Support stand-alone Path objects in Canvas

android/src/toga_android/factory.py

@@ -13,7 +13,7 @@
 from .widgets.activityindicator import ActivityIndicator
 from .widgets.box import Box
 from .widgets.button import Button
-from .widgets.canvas import Canvas
+from .widgets.canvas import Canvas, Path2D
 from .widgets.dateinput import DateInput
 from .widgets.detailedlist import DetailedList
 from .widgets.divider import Divider
@@ -72,6 +72,7 @@ def not_implemented(feature):
     "NumberInput",
     "OptionContainer",
     "PasswordInput",
+    "Path2D",
     "ProgressBar",
     "ScrollContainer",
     # "SplitContainer",

android/src/toga_android/widgets/canvas.py

@@ -1,7 +1,7 @@
 import itertools
 import weakref
 from copy import deepcopy
-from math import degrees
+from math import cos, degrees, sin
 from typing import NamedTuple
 
 from android.graphics import (
@@ -10,7 +10,7 @@
     DashPathEffect,
     Matrix,
     Paint,
-    Path,
+    Path as NativePath,
 )
 from android.view import MotionEvent, View
 from java import dynamic_proxy, jint
@@ -27,6 +27,103 @@
 BLACK = jint(native_color(rgb(0, 0, 0)))
 
 
+def matrix_from_transform(transform):
+    a, b, c, d, e, f = transform
+    matrix = Matrix()
+    matrix.setValues([a, c, e, b, d, f, 0, 0, 1])
+    return matrix
+
+
+class Path2D:
+    native: NativePath
+
+    def __init__(self):
+        self.native = NativePath()
+        self._last_point = None
+
+    def _ensure_subpath(self, x, y):
+        if self.native.isEmpty():
+            self.native.moveTo(x, y)
+
+    def add_path(self, path, transform=None):
+        if transform is None:
+            self.native.addPath(path.native)
+            self._last_point = path._last_point
+        else:
+            native_path = NativePath(path.native)
+            matrix = matrix_from_transform(transform)
+            native_path.transform(matrix)
+            self.native.addPath(native_path)
+            if path._last_point is not None:
+                points = list(path._last_point)
+                matrix.mapPoints(points)
+                self._last_point = points[0]
+
+    def close_path(self):
+        self.native.close()
+        self._last_point = None
+
+    def move_to(self, x, y):
+        self.native.moveTo(x, y)
+        self._last_point = (x, y)
+
+    def line_to(self, x, y):
+        self._ensure_subpath(x, y)
+        self.native.lineTo(x, y)
+        self._last_point = (x, y)
+
+    def bezier_curve_to(self, cp1x, cp1y, cp2x, cp2y, x, y):
+        self._ensure_subpath(cp1x, cp1y)
+        self.native.cubicTo(cp1x, cp1y, cp2x, cp2y, x, y)
+        self._last_point = (x, y)
+
+    def quadratic_curve_to(self, cpx, cpy, x, y):
+        self._ensure_subpath(cpx, cpy)
+        self.native.quadTo(cpx, cpy, x, y)
+        self._last_point = (x, y)
+
+    def arc(self, x, y, radius, startangle, endangle, counterclockwise):
+        self.ellipse(x, y, radius, radius, 0, startangle, endangle, counterclockwise)
+        self._last_point = (x + radius * cos(endangle), y + sin(endangle))
+
+    def ellipse(
+        self,
+        x,
+        y,
+        radiusx,
+        radiusy,
+        rotation,
+        startangle,
+        endangle,
+        counterclockwise,
+    ):
+        matrix = Matrix()
+        matrix.preTranslate(x, y)
+        matrix.preRotate(degrees(rotation))
+        matrix.preScale(radiusx, radiusy)
+        matrix.preRotate(degrees(startangle))
+
+        coords = list(
+            itertools.chain(
+                *arc_to_bezier(sweepangle(startangle, endangle, counterclockwise))
+            )
+        )
+        matrix.mapPoints(coords)
+
+        self.line_to(coords[0], coords[1])
+        i = 2
+        while i < len(coords):
+            self.bezier_curve_to(*coords[i : i + 6])
+            i += 6
+
+    def rect(self, x, y, width, height):
+        self.native.addRect(x, y, x + width, y + height, NativePath.Direction.CW)
+        self._last_point = (x, y)
+
+    def round_rect(self, x, y, width, height, radii):
+        round_rect(self, x, y, width, height, radii)
+
+
 class State(NamedTuple):
     fill: Paint
     stroke: Paint
@@ -40,7 +137,7 @@ class Context:
     def __init__(self, impl, native):
         self.native = native
         self.impl = impl
-        self.path = Path()
+        self.path = Path2D()
 
         # Backwards compatibility for Toga <= 0.5.3
         self.in_fill = False
@@ -73,7 +170,7 @@ def save(self):
     def restore(self):
         self.native.restore()
         # Transform active path to current coordinates
-        self.path.transform(self.state.transform)
+        self.path.native.transform(self.state.transform)
         self.states.pop()
 
     # Setting attributes
@@ -92,34 +189,27 @@ def set_stroke_style(self, color):
     # Basic paths
 
     def begin_path(self):
-        self.path.reset()
+        self.path = Path2D()
 
     def close_path(self):
-        self.path.close()
+        self.path.close_path()
 
     def move_to(self, x, y):
-        self.path.moveTo(x, y)
+        self.path.move_to(x, y)
 
     def line_to(self, x, y):
-        self._ensure_subpath(x, y)
-        self.path.lineTo(x, y)
-
-    def _ensure_subpath(self, x, y):
-        if self.path.isEmpty():
-            self.move_to(x, y)
+        self.path.line_to(x, y)
 
     # Basic shapes
 
     def bezier_curve_to(self, cp1x, cp1y, cp2x, cp2y, x, y):
-        self._ensure_subpath(cp1x, cp1y)
-        self.path.cubicTo(cp1x, cp1y, cp2x, cp2y, x, y)
+        self.path.bezier_curve_to(cp1x, cp1y, cp2x, cp2y, x, y)
 
     def quadratic_curve_to(self, cpx, cpy, x, y):
-        self._ensure_subpath(cpx, cpy)
-        self.path.quadTo(cpx, cpy, x, y)
+        self.path.quadratic_curve_to(cpx, cpy, x, y)
 
     def arc(self, x, y, radius, startangle, endangle, counterclockwise):
-        self.ellipse(x, y, radius, radius, 0, startangle, endangle, counterclockwise)
+        self.path.arc(x, y, radius, startangle, endangle, counterclockwise)
 
     def ellipse(
         self,
@@ -132,45 +222,42 @@ def ellipse(
         endangle,
         counterclockwise,
     ):
-        matrix = Matrix()
-        matrix.preTranslate(x, y)
-        matrix.preRotate(degrees(rotation))
-        matrix.preScale(radiusx, radiusy)
-        matrix.preRotate(degrees(startangle))
-
-        coords = list(
-            itertools.chain(
-                *arc_to_bezier(sweepangle(startangle, endangle, counterclockwise))
-            )
+        self.path.ellipse(
+            x,
+            y,
+            radiusx,
+            radiusy,
+            rotation,
+            startangle,
+            endangle,
+            counterclockwise,
         )
-        matrix.mapPoints(coords)
-
-        self.line_to(coords[0], coords[1])
-        i = 2
-        while i < len(coords):
-            self.bezier_curve_to(*coords[i : i + 6])
-            i += 6
 
     def rect(self, x, y, width, height):
-        self.path.addRect(x, y, x + width, y + height, Path.Direction.CW)
+        self.path.rect(x, y, width, height)
 
     def round_rect(self, x, y, width, height, radii):
-        round_rect(self, x, y, width, height, radii)
+        self.path.round_rect(x, y, width, height, radii)
 
     # Drawing Paths
 
-    def fill(self, fill_rule):
-        self.path.setFillType(
+    def fill(self, fill_rule, path=None):
+        if path is None:
+            path = self.path
+
+        path.native.setFillType(
             {
-                FillRule.EVENODD: Path.FillType.EVEN_ODD,
-                FillRule.NONZERO: Path.FillType.WINDING,
-            }.get(fill_rule, Path.FillType.WINDING)
+                FillRule.EVENODD: NativePath.FillType.EVEN_ODD,
+                FillRule.NONZERO: NativePath.FillType.WINDING,
+            }.get(fill_rule, NativePath.FillType.WINDING)
         )
-        self.native.drawPath(self.path, self.state.fill)
+        self.native.drawPath(path.native, self.state.fill)
 
-    def stroke(self):
+    def stroke(self, path=None):
         # The stroke respects the canvas transform, so we don't need to scale it here.
-        self.native.drawPath(self.path, self.state.stroke)
+        if path is None:
+            path = self.path
+        self.native.drawPath(path.native, self.state.stroke)
 
     # Transformations
 
@@ -183,7 +270,7 @@ def rotate(self, radians):
         # Transform active path to current coordinates
         inverse = Matrix()
         inverse.setRotate(-degrees(radians))
-        self.path.transform(inverse)
+        self.path.native.transform(inverse)
 
     def scale(self, sx, sy):
         # Can't apply inverse transform if scale is 0,
@@ -201,7 +288,7 @@ def scale(self, sx, sy):
         # Transform active path to current coordinates
         inverse = Matrix()
         inverse.setScale(1 / sx, 1 / sy)
-        self.path.transform(inverse)
+        self.path.native.transform(inverse)
 
     def translate(self, tx, ty):
         self.native.translate(tx, ty)
@@ -212,15 +299,15 @@ def translate(self, tx, ty):
         # Transform active path to current coordinates
         inverse = Matrix()
         inverse.setTranslate(-tx, -ty)
-        self.path.transform(inverse)
+        self.path.native.transform(inverse)
 
     def reset_transform(self):
         self.native.setMatrix(None)
 
         # current matrix needs to unwind all previous states
         # can't just ask for current total transform as `getMatrix` is deprecated
         for state in reversed(self.states):
-            self.path.transform(state.transform)
+            self.path.native.transform(state.transform)
             inverse = Matrix()
             # if we can't invert, ignore for now
             if state.transform.invert(inverse):  # pragma: no branch

changes/4163.feature.md

@@ -0,0 +1 @@
+The `Canvas` widget has now has `Path2D` objects that can be used like HTML Canvas `Path2D` objects.

cocoa/src/toga_cocoa/factory.py

@@ -15,7 +15,7 @@
 from .widgets.activityindicator import ActivityIndicator
 from .widgets.box import Box
 from .widgets.button import Button
-from .widgets.canvas import Canvas
+from .widgets.canvas import Canvas, Path2D
 from .widgets.dateinput import DateInput
 from .widgets.detailedlist import DetailedList
 from .widgets.divider import Divider
@@ -76,6 +76,7 @@ def not_implemented(feature):
     "NumberInput",
     "OptionContainer",
     "PasswordInput",
+    "Path2D",
     "ProgressBar",
     "ScrollContainer",
     "Selection",