Merge remote-tracking branch 'origin/main' into resolution

# Conflicts:
#	src/chart/main/chart.cpp

Author: schaumb

src/chart/main/chart.cpp

@@ -103,14 +103,21 @@ void Chart::draw(Gfx::ICanvas &canvas, bool highResolution)
 	    ->setResMode(highResolution ? Draw::ResolutionMode::High
 	                                : Draw::ResolutionMode::Low);
 
-	Draw::DrawChart{Draw::DrawingContext{canvas,
-	                    layout,
-	                    events,
-	                    actPlot,
+	renderedChart = Draw::RenderedChart{
+	    actPlot ? Draw::CoordinateSystem{layout.plotArea,
+	        actPlot->getOptions()->angle,
+	        actPlot->getOptions()->coordSystem,
+	        actPlot->keepAspectRatio}
+	            : Draw::CoordinateSystem{layout.plotArea},
+	    actPlot};
+
+	Draw::DrawChart{Draw::DrawingContext{actPlot,
+	                    renderedChart,
+	                    renderedChart.getCoordSys(),
 	                    actPlot ? actPlot->getStyle()
 	                            : stylesheet.getDefaultParams(),
-	                    renderedChart}}
-	    .draw();
+	                    events}}
+	    .draw(canvas, layout);
 }
 
 Gen::PlotPtr Chart::plot(const Gen::PlotOptionsPtr &options)

src/chart/rendering/drawaxes.cpp

@@ -8,21 +8,17 @@
 namespace Vizzu::Draw
 {
 
-DrawAxes::DrawAxes(const DrawingContext &context) :
-    DrawingContext(context)
-{}
-
-void DrawAxes::drawBase()
+void DrawAxes::drawGeometries() const
 {
 	interlacing.drawGeometries();
 
 	drawAxis(Gen::ChannelId::x);
 	drawAxis(Gen::ChannelId::y);
 
-	DrawGuides(*this);
+	DrawGuides{{ctx()}, canvas, painter}.draw();
 }
 
-void DrawAxes::drawLabels()
+void DrawAxes::drawLabels() const
 {
 	interlacing.drawTexts();
 
@@ -48,7 +44,7 @@ Geom::Line DrawAxes::getAxis(Gen::ChannelId axisIndex) const
 	return {};
 }
 
-void DrawAxes::drawAxis(Gen::ChannelId axisIndex)
+void DrawAxes::drawAxis(Gen::ChannelId axisIndex) const
 {
 	auto eventTarget =
 	    Events::Targets::axis(axisIndex == Gen::ChannelId::x);
@@ -156,7 +152,7 @@ Geom::Point DrawAxes::getTitleOffset(Gen::ChannelId axisIndex,
 	         : Geom::Point{orthogonal, -parallel};
 }
 
-void DrawAxes::drawTitle(Gen::ChannelId axisIndex)
+void DrawAxes::drawTitle(Gen::ChannelId axisIndex) const
 {
 	const auto &titleString = plot->commonAxises.at(axisIndex).title;
 
@@ -234,11 +230,11 @@ void DrawAxes::drawTitle(Gen::ChannelId axisIndex)
 			auto upsideDown =
 			    realAngle > M_PI / 2.0 && realAngle < 3 * M_PI / 2.0;
 
-			[[maybe_unused]] const DrawLabel label(*this,
+			DrawLabel{{ctx()}}.draw(canvas,
 			    Geom::TransformedRect{transform, Geom::Size{size}},
 			    title.value,
 			    titleStyle,
-			    rootEvents.draw.plot.axis.title,
+			    *rootEvents.draw.plot.axis.title,
 			    Events::Targets::axisTitle(title.value,
 			        axisIndex == Gen::ChannelId::x),
 			    DrawLabel::Options(false, 1.0, upsideDown));
@@ -248,7 +244,7 @@ void DrawAxes::drawTitle(Gen::ChannelId axisIndex)
 	}
 }
 
-void DrawAxes::drawDimensionLabels(bool horizontal)
+void DrawAxes::drawDimensionLabels(bool horizontal) const
 {
 	auto axisIndex =
 	    horizontal ? Gen::ChannelId::x : Gen::ChannelId::y;
@@ -273,7 +269,7 @@ void DrawAxes::drawDimensionLabels(bool horizontal)
 
 void DrawAxes::drawDimensionLabel(bool horizontal,
     const Geom::Point &origo,
-    Gen::DimensionAxis::Values::const_iterator it)
+    Gen::DimensionAxis::Values::const_iterator it) const
 {
 	const auto &enabled =
 	    horizontal ? plot->guides.x : plot->guides.y;
@@ -328,13 +324,15 @@ void DrawAxes::drawDimensionLabel(bool horizontal,
 
 		    posDir = posDir.extend(sign);
 
-		    OrientedLabelRenderer labelRenderer(*this);
+		    OrientedLabelRenderer labelRenderer{{ctx()},
+		        canvas,
+		        painter};
 		    auto label =
 		        labelRenderer.create(text, posDir, labelStyle, 0);
 		    labelRenderer.render(label,
 		        textColor * weight * position.weight,
 		        *labelStyle.backgroundColor,
-		        rootEvents.draw.plot.axis.label,
+		        *rootEvents.draw.plot.axis.label,
 		        Events::Targets::axisLabel(text, horizontal));
 	    });
 }

src/chart/rendering/drawaxes.h

@@ -9,13 +9,15 @@
 namespace Vizzu::Draw
 {
 
-class DrawAxes : private DrawingContext
+class DrawAxes : public DrawingContext
 {
 public:
-	explicit DrawAxes(const DrawingContext &context);
+	void drawGeometries() const;
+	void drawLabels() const;
 
-	void drawBase();
-	void drawLabels();
+	Gfx::ICanvas &canvas;
+	Painter &painter;
+	DrawInterlacing interlacing;
 
 private:
 	[[nodiscard]] Geom::Line getAxis(Gen::ChannelId axisIndex) const;
@@ -24,14 +26,12 @@ class DrawAxes : private DrawingContext
 	[[nodiscard]] Geom::Point getTitleOffset(Gen::ChannelId axisIndex,
 	    int index,
 	    bool fades) const;
-	void drawAxis(Gen::ChannelId axisIndex);
-	void drawTitle(Gen::ChannelId axisIndex);
-	void drawDimensionLabels(bool horizontal);
+	void drawAxis(Gen::ChannelId axisIndex) const;
+	void drawTitle(Gen::ChannelId axisIndex) const;
+	void drawDimensionLabels(bool horizontal) const;
 	void drawDimensionLabel(bool horizontal,
 	    const Geom::Point &origo,
-	    Gen::DimensionAxis::Values::const_iterator it);
-
-	DrawInterlacing interlacing{*this};
+	    Gen::DimensionAxis::Values::const_iterator it) const;
 };
 
 }

src/chart/rendering/drawbackground.cpp

@@ -5,28 +5,27 @@
 namespace Vizzu::Draw
 {
 
-DrawBackground::DrawBackground(const DrawingContext &context,
+void DrawBackground::draw(Gfx::ICanvas &canvas,
     const Geom::Rect &rect,
     const Styles::Box &style,
-    const Util::EventDispatcher::event_ptr &onDraw,
-    std::unique_ptr<Util::EventTarget> eventTarget) :
-    DrawingContext(context)
+    Util::EventDispatcher::Event &onDraw,
+    std::unique_ptr<Util::EventTarget> &&eventTarget) const
 {
 	Events::OnRectDrawEvent eventObj(*eventTarget, {rect, false});
 	if (!style.borderColor->isTransparent()
 	    || !style.backgroundColor->isTransparent()) {
 		canvas.setBrushColor(*style.backgroundColor);
 		canvas.setLineColor(*style.borderColor);
 		canvas.setLineWidth(*style.borderWidth);
-		if (onDraw->invoke(std::move(eventObj))) {
+		if (onDraw.invoke(std::move(eventObj))) {
 			canvas.rectangle(rect);
 			renderedChart.emplace(
 			    Geom::TransformedRect::fromRect(rect),
 			    std::move(eventTarget));
 		}
 		canvas.setLineWidth(0);
 	}
-	else if (onDraw->invoke(std::move(eventObj))) {
+	else if (onDraw.invoke(std::move(eventObj))) {
 		renderedChart.emplace(Geom::TransformedRect::fromRect(rect),
 		    std::move(eventTarget));
 	}

src/chart/rendering/drawbackground.h

@@ -10,14 +10,13 @@
 namespace Vizzu::Draw
 {
 
-class DrawBackground : public DrawingContext
+struct DrawBackground : DrawingContext
 {
-public:
-	DrawBackground(const DrawingContext &context,
+	void draw(Gfx::ICanvas &canvas,
 	    const Geom::Rect &rect,
 	    const Styles::Box &style,
-	    const Util::EventDispatcher::event_ptr &onDraw,
-	    std::unique_ptr<Util::EventTarget> eventTarget);
+	    Util::EventDispatcher::Event &onDraw,
+	    std::unique_ptr<Util::EventTarget> &&eventTarget) const;
 };
 
 }

src/chart/rendering/drawchart.cpp

@@ -9,18 +9,54 @@
 
 namespace Vizzu::Draw
 {
+void DrawChart::drawBackground(Gfx::ICanvas &canvas,
+    const Geom::Rect &bounds) const
+{
+	DrawBackground{{ctx()}}.draw(canvas,
+	    bounds,
+	    rootStyle,
+	    *rootEvents.draw.background,
+	    Events::Targets::root());
+}
+
+void DrawChart::drawPlot(Gfx::ICanvas &canvas,
+    Painter &painter,
+    const Geom::Rect &plotRect) const
+{
+	DrawPlot{{ctx()}}.draw(canvas, painter, plotRect);
+}
+
+void DrawChart::drawLegend(Gfx::ICanvas &canvas,
+    const Geom::Rect &bounds) const
+{
+	auto &&legendObj = DrawLegend{{ctx()}};
+
+	getOptions().legend.visit(
+	    [&legendObj, &canvas, &bounds](int, const auto &legend)
+	    {
+		    if (legend.value)
+			    legendObj.draw(canvas,
+			        bounds,
+			        Gen::Options::toChannel(*legend.value),
+			        legend.weight);
+	    });
+}
+
 template <auto targetGetter, class MemberGetter>
-void DrawChart::drawHeading(const MemberGetter &&getter)
+void DrawChart::drawHeading(Gfx::ICanvas &canvas,
+    const Layout &layout,
+    const MemberGetter &&getter) const
 {
 	getter(getOptions())
 	    .visit(
 	        [&layout = getter(layout),
 	            &style = getter(rootStyle),
-	            &event = getter(rootEvents.draw),
+	            &event = *getter(rootEvents.draw),
+	            &canvas,
 	            this](int, const auto &weighted)
 	        {
 		        if (weighted.value.has_value()) {
-			        DrawLabel(*this,
+			        DrawLabel{{ctx()}}.draw(canvas,
 			            Geom::TransformedRect::fromRect(layout),
 			            *weighted.value,
 			            style,
@@ -32,61 +68,67 @@ void DrawChart::drawHeading(const MemberGetter &&getter)
 	        });
 }
 
-void DrawChart::draw()
+void DrawChart::drawMarkerInfo(Gfx::ICanvas &canvas,
+    const Geom::Rect &bounds) const
+{
+	DrawMarkerInfo{{ctx()}, rootStyle.tooltip}.draw(canvas, bounds);
+}
+
+void DrawChart::drawLogo(Gfx::ICanvas &canvas,
+    const Geom::Rect &bounds) const
 {
+	if (auto logoElement = Events::Targets::logo();
+	    rootEvents.draw.logo->invoke(
+	        Events::OnRectDrawEvent(*logoElement, {bounds, false}))) {
+
+		Logo(canvas).draw(bounds.pos,
+		    bounds.width(),
+		    *rootStyle.logo.filter);
+
+		renderedChart.emplace(Geom::TransformedRect::fromRect(bounds),
+		    std::move(logoElement));
+	}
+}
+
+void DrawChart::draw(Gfx::ICanvas &canvas, const Layout &layout) const
+{
+	Painter &painter = *static_cast<Painter *>(canvas.getPainter());
+	painter.setCoordSys(coordSys);
+
 	if (plot && rootEvents.draw.begin->invoke()) {
 
-		DrawBackground(*this,
-		    layout.boundary.outline(Geom::Size::Square(1)),
-		    rootStyle,
-		    rootEvents.draw.background,
-		    Events::Targets::root());
+		drawBackground(canvas,
+		    layout.boundary.outline(Geom::Size::Square(1)));
 
-		DrawPlot{*this};
+		drawPlot(canvas, painter, layout.plot);
 
-		getOptions().legend.visit(
-		    [this](int, const auto &legend)
-		    {
-			    if (legend.value)
-				    DrawLegend(*this,
-				        Gen::Options::toChannel(*legend.value),
-				        legend.weight);
-		    });
+		drawLegend(canvas, layout.legend);
 
-		drawHeading<&Events::Targets::chartTitle>(
+		drawHeading<&Events::Targets::chartTitle>(canvas,
+		    layout,
 		    [](auto &obj) -> decltype((obj.title))
 		    {
 			    return (obj.title);
 		    });
 
-		drawHeading<&Events::Targets::chartSubtitle>(
+		drawHeading<&Events::Targets::chartSubtitle>(canvas,
+		    layout,
 		    [](auto &obj) -> decltype((obj.subtitle))
 		    {
 			    return (obj.subtitle);
 		    });
 
-		drawHeading<&Events::Targets::chartCaption>(
+		drawHeading<&Events::Targets::chartCaption>(canvas,
+		    layout,
 		    [](auto &obj) -> decltype((obj.caption))
 		    {
 			    return (obj.caption);
 		    });
 
-		DrawMarkerInfo(layout, canvas, *plot);
+		drawMarkerInfo(canvas, layout.boundary);
 	}
 
-	if (auto logoElement = Events::Targets::logo();
-	    rootEvents.draw.logo->invoke(
-	        Events::OnRectDrawEvent(*logoElement,
-	            {layout.logo, false}))) {
-
-		Logo(canvas).draw(layout.logo.pos,
-		    layout.logo.width(),
-		    *rootStyle.logo.filter);
-
-		renderedChart.emplace(
-		    Geom::TransformedRect::fromRect(layout.logo),
-		    std::move(logoElement));
-	}
+	drawLogo(canvas, layout.logo);
 
 	rootEvents.draw.complete->invoke();
 }