[widget Audit] toga.Canvas

.github/workflows/ci.yml

@@ -201,6 +201,7 @@ jobs:
 
           - backend: macOS
             runs-on: macos-12
+            app-user-data-path: /Users/runner/Library/Application Support/org.beeware.toga.testbed
 
           # We use a fixed Ubuntu version rather than `-latest` because at some point,
           # `-latest` will be updated, but it will be a soft changeover, which would cause
@@ -225,13 +226,15 @@ jobs:
 
             briefcase-run-prefix: 'DISPLAY=:99'
             setup-python: false  # Use the system Python packages.
+            app-user-data-path: /home/runner/.local/share/testbed
 
           - backend: windows
             runs-on: windows-latest
 
           - backend: iOS
             runs-on: macos-12
             briefcase-run-args: ' -d "iPhone SE (3rd generation)"'
+            # app data path is determined at runtime, as the path contains the Simulator and app ID.
 
           - backend: android
             runs-on: macos-12
@@ -264,3 +267,19 @@ jobs:
       with:
         name: testbed-failure-logs-${{ matrix.backend }}
         path: testbed/logs/*
+    - name: Copy app generated user data
+      if: failure()
+      run: |
+        mkdir testbed/app_data
+        if [ "${{ matrix.backend }}" = "iOS" ]; then
+          APP_DATA_PATH="$(xcrun simctl get_app_container booted org.beeware.toga.testbed data)/Documents"
+        else
+          APP_DATA_PATH="${{ matrix.app-user-data-path }}"
+        fi
+        cp -r "$APP_DATA_PATH" testbed/app_data/testbed-app_data-${{ matrix.backend }}
+    - name: Upload app data
+      uses: actions/[email protected]
+      if: failure()
+      with:
+        name: testbed-failure-app-data-${{ matrix.backend }}
+        path: testbed/app_data/*

android/src/toga_android/fonts.py

@@ -1,5 +1,8 @@
 from pathlib import Path
 
+from org.beeware.android import MainActivity
+
+from android import R
 from android.graphics import Typeface
 from android.util import TypedValue
 from toga.fonts import (
@@ -25,84 +28,88 @@ class Font:
     def __init__(self, interface):
         self.interface = interface
 
-    def apply(self, tv, default_size, default_typeface):
-        """Apply the font to the given native widget.
-
-        :param tv: A native instance of TextView, or one of its subclasses.
-        :param default_size: The default font size of this widget, in pixels.
-        :param default_typeface: The default Typeface of this widget.
-        """
-        if self.interface.size == SYSTEM_DEFAULT_FONT_SIZE:
-            tv.setTextSize(TypedValue.COMPLEX_UNIT_PX, default_size)
-        else:
-            # The default size for most widgets is 14sp, so mapping 1 Toga "point" to 1sp
-            # will give relative sizes that are consistent with desktop platforms. Using
-            # SP means font sizes will all change proportionately if the user adjusts the
-            # text size in the system settings.
-            tv.setTextSize(TypedValue.COMPLEX_UNIT_SP, self.interface.size)
+    def typeface(self, *, default=Typeface.DEFAULT):
+        cache_key = (self.interface, default)
+        if typeface := _FONT_CACHE.get(cache_key):
+            return typeface
 
-        cache_key = (self.interface, default_typeface)
+        font_key = self.interface._registered_font_key(
+            self.interface.family,
+            weight=self.interface.weight,
+            style=self.interface.style,
+            variant=self.interface.variant,
+        )
         try:
-            typeface = _FONT_CACHE[cache_key]
+            font_path = _REGISTERED_FONT_CACHE[font_key]
         except KeyError:
-            typeface = None
-            font_key = self.interface._registered_font_key(
-                self.interface.family,
-                weight=self.interface.weight,
-                style=self.interface.style,
-                variant=self.interface.variant,
-            )
-            try:
-                font_path = _REGISTERED_FONT_CACHE[font_key]
-            except KeyError:
-                # Not a pre-registered font
-                if self.interface.family not in SYSTEM_DEFAULT_FONTS:
-                    print(
-                        f"Unknown font '{self.interface}'; "
-                        "using system font as a fallback"
-                    )
+            # Not a pre-registered font
+            if self.interface.family not in SYSTEM_DEFAULT_FONTS:
+                print(
+                    f"Unknown font '{self.interface}'; "
+                    "using system font as a fallback"
+                )
+        else:
+            if Path(font_path).is_file():
+                typeface = Typeface.createFromFile(font_path)
+                if typeface is Typeface.DEFAULT:
+                    raise ValueError(f"Unable to load font file {font_path}")
             else:
-                if Path(font_path).is_file():
-                    typeface = Typeface.createFromFile(font_path)
-                    if typeface is Typeface.DEFAULT:
-                        raise ValueError(f"Unable to load font file {font_path}")
-                else:
-                    raise ValueError(f"Font file {font_path} could not be found")
+                raise ValueError(f"Font file {font_path} could not be found")
 
-            if typeface is None:
-                if self.interface.family is SYSTEM:
-                    # The default button font is not marked as bold, but it has a weight
-                    # of "medium" (500), which is in between "normal" (400), and "bold"
-                    # (600 or 700). To preserve this, we use the widget's original
-                    # typeface as a starting point rather than Typeface.DEFAULT.
-                    typeface = default_typeface
-                elif self.interface.family is MESSAGE:
-                    typeface = Typeface.DEFAULT
-                elif self.interface.family is SERIF:
-                    typeface = Typeface.SERIF
-                elif self.interface.family is SANS_SERIF:
-                    typeface = Typeface.SANS_SERIF
-                elif self.interface.family is MONOSPACE:
-                    typeface = Typeface.MONOSPACE
-                elif self.interface.family is CURSIVE:
-                    typeface = Typeface.create("cursive", Typeface.NORMAL)
-                elif self.interface.family is FANTASY:
-                    # Android appears to not have a fantasy font available by default,
-                    # but if it ever does, we'll start using it. Android seems to choose
-                    # a serif font when asked for a fantasy font.
-                    typeface = Typeface.create("fantasy", Typeface.NORMAL)
-                else:
-                    typeface = Typeface.create(self.interface.family, Typeface.NORMAL)
+        if typeface is None:
+            if self.interface.family is SYSTEM:
+                # The default button font is not marked as bold, but it has a weight
+                # of "medium" (500), which is in between "normal" (400), and "bold"
+                # (600 or 700). To preserve this, we use the widget's original
+                # typeface as a starting point rather than Typeface.DEFAULT.
+                typeface = default
+            elif self.interface.family is MESSAGE:
+                typeface = Typeface.DEFAULT
+            elif self.interface.family is SERIF:
+                typeface = Typeface.SERIF
+            elif self.interface.family is SANS_SERIF:
+                typeface = Typeface.SANS_SERIF
+            elif self.interface.family is MONOSPACE:
+                typeface = Typeface.MONOSPACE
+            elif self.interface.family is CURSIVE:
+                typeface = Typeface.create("cursive", Typeface.NORMAL)
+            elif self.interface.family is FANTASY:
+                # Android appears to not have a fantasy font available by default,
+                # but if it ever does, we'll start using it. Android seems to choose
+                # a serif font when asked for a fantasy font.
+                typeface = Typeface.create("fantasy", Typeface.NORMAL)
+            else:
+                typeface = Typeface.create(self.interface.family, Typeface.NORMAL)
+
+        native_style = typeface.getStyle()
+        if self.interface.weight == BOLD:
+            native_style |= Typeface.BOLD
+        if self.interface.style in {ITALIC, OBLIQUE}:
+            native_style |= Typeface.ITALIC
 
-            native_style = typeface.getStyle()
-            if self.interface.weight == BOLD:
-                native_style |= Typeface.BOLD
-            if self.interface.style in {ITALIC, OBLIQUE}:
-                native_style |= Typeface.ITALIC
+        if native_style != typeface.getStyle():
+            typeface = Typeface.create(typeface, native_style)
 
-            if native_style != typeface.getStyle():
-                typeface = Typeface.create(typeface, native_style)
+        _FONT_CACHE[cache_key] = typeface
+        return typeface
 
-            _FONT_CACHE[cache_key] = typeface
+    def size(self, *, default=None):
+        """Return the font size in physical pixels."""
+        context = MainActivity.singletonThis
+        if self.interface.size == SYSTEM_DEFAULT_FONT_SIZE:
+            if default is None:
+                typed_array = context.obtainStyledAttributes(
+                    R.style.TextAppearance_Small, [R.attr.textSize]
+                )
+                default = typed_array.getDimension(0, 0)
+                typed_array.recycle()
+            return default
 
-        tv.setTypeface(typeface)
+        else:
+            # Using SP means we follow the standard proportion between CSS pixels and
+            # points by default, but respect the system text scaling setting.
+            return TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_SP,
+                self.interface.size * (96 / 72),
+                context.getResources().getDisplayMetrics(),
+            )

android/src/toga_android/widgets/base.py

@@ -19,20 +19,22 @@ class Scalable:
     def init_scale(self, context):
         # The baseline DPI is 160:
         # https://developer.android.com/training/multiscreen/screendensities
-        self.scale = context.getResources().getDisplayMetrics().densityDpi / 160
+        self.dpi_scale = context.getResources().getDisplayMetrics().densityDpi / 160
 
     # Convert CSS pixels to native pixels
     def scale_in(self, value, rounding=SCALE_DEFAULT_ROUNDING):
-        return self.scale_round(value * self.scale, rounding)
+        return self.scale_round(value * self.dpi_scale, rounding)
 
     # Convert native pixels to CSS pixels
     def scale_out(self, value, rounding=SCALE_DEFAULT_ROUNDING):
         if isinstance(value, at_least):
             return at_least(self.scale_out(value.value, rounding))
         else:
-            return self.scale_round(value / self.scale, rounding)
+            return self.scale_round(value / self.dpi_scale, rounding)
 
     def scale_round(self, value, rounding):
+        if rounding is None:
+            return value
         return int(Decimal(value).to_integral(rounding))