Animator options connected to animator planner.

Author: simzer

src/chart/animator/animator.cpp

@@ -28,7 +28,7 @@ void Animator::init(Diag::DiagramPtr diagram)
 }
 
 void Animator::animate(const Diag::DiagramPtr &diagram,
-    Options &&/*options*/,
+    Options &&options,
     OnComplete onThisCompletes)
 {
 	if (isRunning()) throw std::logic_error("animation already in progress");
@@ -41,7 +41,7 @@ void Animator::animate(const Diag::DiagramPtr &diagram,
 	onComplete = onThisCompletes;
 	target->detachOptions();
 	prepareActual();
-	createPlan(*source, *target, *actual);
+	createPlan(*source, *target, *actual, options);
 	::Anim::Control::reset();
 	::Anim::Control::play();
 }

src/chart/animator/morph.cpp

@@ -19,6 +19,29 @@ AbstractMorph::AbstractMorph(
     actual(actual)
 {}
 
+std::unique_ptr<AbstractMorph> AbstractMorph::create(SectionId sectionId,
+	const Diagram &source,
+    const Diagram &target,
+    Diagram &actual)
+{
+	switch(sectionId) {
+	case SectionId::EnumType::color: 
+		return std::make_unique<Color>(source, target, actual);
+	case SectionId::EnumType::enable:
+		return std::make_unique<Enable>(source, target, actual);
+	case SectionId::EnumType::x: 
+		return std::make_unique<Horizontal>(source, target, actual);
+	case SectionId::EnumType::y: 
+		return std::make_unique<Vertical>(source, target, actual);
+	case SectionId::EnumType::shape: 
+		return std::make_unique<Shape>(source, target, actual);
+	case SectionId::EnumType::coordSystem: 
+		return std::make_unique<CoordinateSystem>
+			(source, target, actual);
+	default: throw std::logic_error("invalid animation section");
+	}
+}
+
 void AbstractMorph::transform(double factor)
 {
 	transform(source, target, actual, factor);
@@ -33,9 +56,9 @@ void AbstractMorph::transform(double factor)
 	}
 }
 
-void CoordinateSystem::transform(const Options &source,
-							const Options &target,
-							Options &actual,
+void CoordinateSystem::transform(const Diag::Options &source,
+							const Diag::Options &target,
+							Diag::Options &actual,
 							double factor) const
 {
 	actual.polar.set(interpolate(source.polar.get(), target.polar.get(), factor));
@@ -50,9 +73,9 @@ void Enable::transform(const Marker &source,
 	actual.enabled = interpolate(source.enabled, target.enabled, factor);
 }
 
-void Shape::transform(const Options &source,
-				  const Options &target,
-				  Options &actual,
+void Shape::transform(const Diag::Options &source,
+				  const Diag::Options &target,
+				  Diag::Options &actual,
 				  double factor) const
 {
 	actual.shapeType.set(interpolate(source.shapeType.get(),
@@ -82,9 +105,9 @@ void Horizontal::transform(const Diagram &source,
 		interpolate(source.anyAxisSet, target.anyAxisSet, factor);
 }
 
-void Horizontal::transform(const Options &source,
-				  const Options &target,
-				  Options &actual,
+void Horizontal::transform(const Diag::Options &source,
+				  const Diag::Options &target,
+				  Diag::Options &actual,
 				  double factor) const
 {
 	auto sourceIsConnecting = Vizzu::Diag::isConnecting(source.shapeType.get().type());
@@ -183,9 +206,9 @@ void Morph::Color::transform(const Diagram &source,
 	        factor);
 }
 
-void Morph::Color::transform(const Options &source,
-    const Options &target,
-    Options &actual,
+void Morph::Color::transform(const Diag::Options &source,
+    const Diag::Options &target,
+    Diag::Options &actual,
     double factor) const
 {
 	actual.legend.set(interpolate(source.legend.get(),

src/chart/animator/morph.h

@@ -1,12 +1,16 @@
 #ifndef MORPH_H
 #define MORPH_H
 
+#include <memory>
+
 #include "base/anim/element.h"
 #include "base/math/ratio.h"
 #include "base/math/interpolation.h"
 #include "chart/options/options.h"
 #include "chart/generator/diagram.h"
 
+#include "options.h"
+
 namespace Vizzu
 {
 namespace Anim
@@ -26,6 +30,8 @@ class AbstractMorph : public ::Anim::IElement
 	virtual ~AbstractMorph()
 	{}
 
+	static std::unique_ptr<AbstractMorph> create(SectionId sectionId,
+		const Dia &source, const Dia &target, Dia &actual);
 	void transform(double factor) override;
 	virtual std::string name() const = 0;
 	virtual void transform(const Dia&, const Dia&, Dia&, double) const {}

src/chart/animator/options.cpp

@@ -26,3 +26,14 @@ void Options::set(const std::string &path,
 		section.duration = ::Anim::Duration(value);
 	else throw std::logic_error("invalid animation option: " + option);
 }
+
+::Anim::Options Options::get(SectionId sectionId, 
+	const ::Anim::Options &defaultOption) const
+{
+	auto &section = sections.at((int)sectionId);
+	auto res = defaultOption;
+	if (section.easing.has_value()) res.easing = *section.easing;
+	if (section.delay.has_value()) res.delay = *section.delay;
+	if (section.duration.has_value()) res.duration = *section.duration;
+	return res;
+}

src/chart/animator/options.h

@@ -13,7 +13,7 @@ namespace Anim
 {
 
 class Enum(SectionId)
-	(style,title,enable,color,coordsys,shape,vertical,horizontal);
+	(style,title,enable,color,coordSystem,shape,y,x);
 
 class Options
 {
@@ -27,6 +27,9 @@ class Options
 	std::array<Section, SectionId::EnumInfo::count()> sections;
 
 	void set(const std::string &path, const std::string &value);
+
+	::Anim::Options get(SectionId sectionId, 
+		const ::Anim::Options &defaultOption) const;
 };
 
 }

src/chart/animator/planner.cpp

@@ -7,21 +7,25 @@
 
 using namespace Vizzu;
 using namespace Vizzu::Anim;
-using namespace Vizzu::Diag;
 using namespace std::literals::chrono_literals;
 
 void Planner::createPlan(const Diag::Diagram &source,
     const Diag::Diagram &target,
-    Diag::Diagram &actual)
+    Diag::Diagram &actual,
+    const Options &options)
 {
+	typedef SectionId::EnumType SectionId;
+
 	this->source = &source;
 	this->target = ⌖
 	this->actual = &actual;
+	this->options = &options;
 
 	::Anim::Group::clear();
 
 	Morph::StyleMorphFactory(source.getStyle(), target.getStyle(),
-	    actual.getStyle(), *this);
+	    actual.getStyle(), *this,
+		options.get(SectionId::style, ::Anim::Options(500ms)));
 
 	if (source.getOptions()->title.get() != target.getOptions()->title.get())
 		addElement(
@@ -30,67 +34,67 @@ void Planner::createPlan(const Diag::Diagram &source,
 		        source.getOptions()->title.ref(),
 		        target.getOptions()->title.ref(),
 		        actual.getOptions()->title.ref()),
-		    ::Anim::Options(500ms));
+		    options.get(SectionId::title, ::Anim::Options(500ms)));
 
 	if (anyMarker(
 		[&](const auto &source, const auto &target) -> bool {
 		    return (bool)(source.enabled && !target.enabled);
 	    }))
-		addMorph<Morph::Enable>(1s);
+		addMorph(SectionId::enable, ::Anim::Options(1s));
 
-	if (needColor()) addMorph<Morph::Color>(500ms);
+	if (needColor()) addMorph(SectionId::color, ::Anim::Options(500ms));
 
 	if (source.getOptions()->polar.get()
 	        != target.getOptions()->polar.get()
 	    || source.getOptions()->angle.get()
 	           != target.getOptions()->angle.get())
-		addMorph<Morph::CoordinateSystem>(1s);
+		addMorph(SectionId::coordSystem, ::Anim::Options(1s));
 
 	const auto &src = source.getOptions()->shapeType.get();
 	const auto &trg = target.getOptions()->shapeType.get();
-	if((bool)src.getFactor(ShapeType::Circle) && src != trg)
-		addMorph<Morph::Shape>(1s);
+	if((bool)src.getFactor(Diag::ShapeType::Circle) && src != trg)
+		addMorph(SectionId::shape, ::Anim::Options(1s));
 
 	if (positionMorphNeeded())
 	{
-		addMorph<Morph::Vertical>(1s);
-		addMorph<Morph::Horizontal>(1s);
+		addMorph(SectionId::y, ::Anim::Options(1s));
+		addMorph(SectionId::x, ::Anim::Options(1s));
 	}
 	else
 	{
 		if (verticalBeforeHorizontal())
 		{
-			if (needVertical()) addMorph<Morph::Vertical>(750ms);
-			if (needHorizontal()) addMorph<Morph::Horizontal>(750ms, 750ms);
+			if (needVertical()) addMorph(SectionId::y, ::Anim::Options(750ms));
+			if (needHorizontal()) addMorph(SectionId::x, 
+				::Anim::Options(750ms, 750ms));
 		}
 		else
 		{
-			if (needHorizontal()) addMorph<Morph::Horizontal>(750ms);
-			if (needVertical()) addMorph<Morph::Vertical>(750ms, 750ms);
+			if (needHorizontal()) addMorph(SectionId::x, ::Anim::Options(750ms));
+			if (needVertical()) addMorph(SectionId::y, 
+				::Anim::Options(750ms, 750ms));
 		}
 	}
 
-	if (!(bool)src.getFactor(ShapeType::Circle) && src != trg)
-		addMorph<Morph::Shape>(1s);
+	if (!(bool)src.getFactor(Diag::ShapeType::Circle) && src != trg)
+		addMorph(SectionId::shape, ::Anim::Options(1s));
 
 	if (anyMarker(
 		[&](const auto &source, const auto &target) {
 			return (bool)(!source.enabled && target.enabled);
 		}))
-		addMorph<Morph::Enable>(1s);
+		addMorph(SectionId::enable, ::Anim::Options(1s));
 
 	if (!source.getOptions()->polar.get()
 	    && target.getOptions()->polar.get())
-		addMorph<Morph::CoordinateSystem>(1s);
+		addMorph(SectionId::coordSystem, ::Anim::Options(1s));
 }
 
-template <typename M>
-void Planner::addMorph(std::chrono::nanoseconds duration,
-    std::chrono::nanoseconds delay)
+void Planner::addMorph(SectionId sectionId, const ::Anim::Options &autoOptions)
 {
 	addElement(
-		std::move(std::make_unique<M>(*source, *target, *actual)),
-		::Anim::Options(duration, delay)
+		Morph::AbstractMorph::create(sectionId, *source, *target, *actual),
+		options->get(sectionId, autoOptions)
 	);
 }
 
@@ -112,20 +116,20 @@ bool Planner::anyMarker(
 bool Planner::positionMorphNeeded() const
 {
 	return Diag::canOverlap(
-	           (ShapeType::Type)source->getOptions()->shapeType.get())
+	           (Diag::ShapeType::Type)source->getOptions()->shapeType.get())
 	    || Diag::canOverlap(
-	        (ShapeType::Type)target->getOptions()->shapeType.get());
+	        (Diag::ShapeType::Type)target->getOptions()->shapeType.get());
 }
 
 bool Planner::needColor() const
 {
 	return source->anySelected != target->anySelected
 	    || source->getOptions()->legend.get()
 	           != target->getOptions()->legend.get()
-	    || source->discreteAxises.at(Scale::Type::Color)
-	           != target->discreteAxises.at(Scale::Type::Color)
-	    || source->discreteAxises.at(Scale::Type::Lightness)
-	           != target->discreteAxises.at(Scale::Type::Lightness)
+	    || source->discreteAxises.at(Diag::Scale::Type::Color)
+	           != target->discreteAxises.at(Diag::Scale::Type::Color)
+	    || source->discreteAxises.at(Diag::Scale::Type::Lightness)
+	           != target->discreteAxises.at(Diag::Scale::Type::Lightness)
 	    || anyMarker(
 	        [&](const auto &source, const auto &target)
 	        {
@@ -139,16 +143,16 @@ size_t Planner::discreteCount(const Diag::Diagram *diagram,
     Diag::Scale::Type type) const
 {
 	return diagram->getOptions()->getScales()
-		.at(Scales::Id{type, Scales::Index{0}})
+		.at(Diag::Scales::Id{type, Diag::Scales::Index{0}})
 		.discretesIds().size();
 }
 
 bool Planner::verticalBeforeHorizontal() const
 {
-	auto srcXcnt = discreteCount(source, Scale::X);
-	auto srcYcnt = discreteCount(source, Scale::Y);
-	auto trgXcnt = discreteCount(target, Scale::X);
-	auto trgYcnt = discreteCount(target, Scale::Y);
+	auto srcXcnt = discreteCount(source, Diag::Scale::X);
+	auto srcYcnt = discreteCount(source, Diag::Scale::Y);
+	auto trgXcnt = discreteCount(target, Diag::Scale::X);
+	auto trgYcnt = discreteCount(target, Diag::Scale::Y);
 
 	if ((trgYcnt != srcYcnt) || (trgXcnt != srcXcnt))
 	{

src/chart/animator/planner.h

@@ -9,6 +9,8 @@
 #include "base/anim/group.h"
 #include "chart/generator/diagram.h"
 
+#include "options.h"
+
 namespace Vizzu
 {
 namespace Anim
@@ -23,17 +25,16 @@ class Planner : public ::Anim::Group
 
 	void createPlan(const Diag::Diagram &source,
 	    const Diag::Diagram &target,
-	    Diag::Diagram &actual);
+	    Diag::Diagram &actual,
+	    const Options &options);
 
 private:
 	const Diag::Diagram *source;
 	const Diag::Diagram *target;
 	Diag::Diagram *actual;
+	const Options *options;
 
-	template <typename M>
-	void addMorph(std::chrono::nanoseconds duration,
-	    std::chrono::nanoseconds delay = std::chrono::nanoseconds(0));
-
+	void addMorph(SectionId sectionId, const ::Anim::Options &autoOptions);
 	bool anyMarker(const std::function<bool(const Diag::Marker &,
 	        const Diag::Marker &)> &compare) const;
 

src/chart/animator/styles.cpp

@@ -29,8 +29,9 @@ StyleMorphFactory::StyleMorphFactory(
 	const Styles::Chart &source,
     const Styles::Chart &target,
     Styles::Chart &actual,
-    ::Anim::Group &group) :
-	group(group)
+    ::Anim::Group &group,
+	const ::Anim::Options &options) :
+	group(group), options(options)
 {
 	pSource = reinterpret_cast<const std::byte *>(&source);
 	pTarget = reinterpret_cast<const std::byte *>(&target);
@@ -64,8 +65,7 @@ StyleMorphFactory &StyleMorphFactory::operator()(T &value,
 			auto morph = std::make_unique<StyleMorph<T>>
 				(source, target, value);
 
-			group.addElement(std::move(morph),
-				::Anim::Options(std::chrono::milliseconds(500)));
+			group.addElement(std::move(morph), options);
 		}
 	}
 	return *this;

src/chart/animator/styles.h

@@ -21,7 +21,8 @@ class StyleMorphFactory
 	StyleMorphFactory(const Styles::Chart &source,
 	    const Styles::Chart &target,
 	    Styles::Chart &actual,
-		::Anim::Group &group);
+		::Anim::Group &group,
+		const ::Anim::Options &options);
 
 	template <typename T>
 	StyleMorphFactory &operator()(T &value, const char *);
@@ -31,6 +32,7 @@ class StyleMorphFactory
 	const std::byte *pSource;
 	const std::byte *pTarget;
 	::Anim::Group &group;
+	const ::Anim::Options &options;
 };
 
 }