CI: run FreeBSD and Windows ARM64 checks nightly and on release, not per PR

They ran on every push to main and on any PR touching Cargo.toml/Cargo.lock,
which is nearly every PR. See craftrules release/playbook.md §2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.github/workflows/freebsd.yml

@@ -2,16 +2,19 @@
 # (GitHub has no FreeBSD runners). GPU tests skip themselves when the VM has no adapter.
 name: FreeBSD
 
+# The VM build is slow, so it runs nightly on main and on pushes to `release`, not on every push
+# or dependency change: a drifted dependency still shows up within a day, and always before a
+# release ships. PRs that change the FreeBSD packaging itself still run it.
 on:
+  schedule:
+    - cron: "7 2 * * *"
   push:
-    branches: [main]
+    branches: [release]
   pull_request:
     paths:
-      - Cargo.toml
-      - Cargo.lock
-      - "**/Cargo.toml"
       - "crates/fonts/**"
       - .github/workflows/freebsd.yml
+      - packaging/freebsd/**
   workflow_dispatch:
 
 concurrency:
@@ -23,7 +26,33 @@ permissions:
 
 jobs:
   freebsd:
-    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
-    uses: storytold/craft-common-actions/.github/workflows/freebsd.yml@main
-    with:
-      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+    name: FreeBSD 14 (build + test)
+    runs-on: ubuntu-latest
+    timeout-minutes: 300
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+          path: craft-fonts
+      - name: Build and test in a FreeBSD VM
+        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc # v1.5.9
+        with:
+          release: "14.3"
+          usesh: true
+          cpu: 4
+          mem: 12288
+          # Nothing to bring back; copying the target dir out of the VM fails on large builds.
+          copyback: false
+          prepare: |
+            pkg install -y git curl pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader gtk3 fontconfig freetype2 alsa-lib
+            curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal
+          run: |
+            . "$HOME/.cargo/env"
+            # The checkout is synced in under another owner; let tests that call git read it.
+            git config --global --add safe.directory "*"
+            rustc --version
+            CARGO_PROFILE_DEV_DEBUG=0 cargo build --workspace --all-targets --locked
+            CRAFT_FONTS_DIR="$PWD/craft-fonts" CARGO_PROFILE_DEV_DEBUG=0 cargo test --workspace --locked

.github/workflows/packaging-lint.yml

@@ -19,5 +19,48 @@ concurrency:
 
 jobs:
   lint:
-    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
-    uses: storytold/craft-common-actions/.github/workflows/packaging-lint.yml@main
+    runs-on: ubuntu-latest
+    env:
+      ACTIONLINT_VERSION: 1.7.12
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Install tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends shellcheck desktop-file-utils appstream libxml2-utils python3-yaml
+          curl -fsSL "https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_linux_amd64.tar.gz" \
+            | tar -xz -C "$RUNNER_TEMP" actionlint
+      - name: actionlint
+        run: |
+          "$RUNNER_TEMP/actionlint" -color
+      - name: shellcheck
+        run: shellcheck packaging/*.sh packaging/*/*.sh
+      - name: PowerShell
+        shell: pwsh
+        run: |
+          foreach ($f in Get-ChildItem packaging/windows/*.ps1) {
+            $errors = $null
+            [System.Management.Automation.Language.Parser]::ParseFile($f.FullName, [ref]$null, [ref]$errors) | Out-Null
+            if ($errors) { $errors | ForEach-Object { Write-Output "::error file=$($f.Name)::$_" }; exit 1 }
+            Write-Output "ok $($f.Name)"
+          }
+      - name: XML, desktop entry, AppStream, Flatpak manifest
+        run: |
+          xmllint --noout packaging/windows/deckcraft.wxs packaging/macos/*.plist* packaging/linux/*.xml*
+          # Windows Installer needs Icon ids ending in .ico or .exe, or shortcuts show a blank icon.
+          if grep -oE '<Icon Id="[^"]*"' packaging/windows/deckcraft.wxs | grep -vE '\.(ico|exe)"$'; then
+            echo "::error::Icon Id must end in .ico or .exe"; exit 1
+          fi
+          desktop-file-validate packaging/linux/ai.storyteller.deckcraft.desktop
+          sed -e 's/@VERSION@/0.0.0/' -e 's/@DATE@/2026-01-01/' packaging/linux/ai.storyteller.deckcraft.metainfo.xml.in >"$RUNNER_TEMP/ai.storyteller.deckcraft.metainfo.xml"
+          appstreamcli validate --no-net --explain "$RUNNER_TEMP/ai.storyteller.deckcraft.metainfo.xml"
+          python3 - <<'EOF'
+          import yaml
+          src = yaml.safe_load(open("packaging/linux/flatpak/ai.storyteller.deckcraft.yml"))
+          bundle = yaml.safe_load(open("packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml"))
+          for m in (src, bundle):
+              assert m["id"] == "ai.storyteller.deckcraft" and m["command"] == "deckcraft", m["id"]
+          for key in ("runtime", "runtime-version", "sdk", "finish-args"):
+              assert src[key] == bundle[key], f"Flatpak manifests disagree on {key}: {src[key]} vs {bundle[key]}"
+          print("Flatpak manifests ok")
+          EOF

.github/workflows/release.yml

@@ -1,3 +1,16 @@
+# Release pipeline: every push to `release` builds installers for every platform and creates or
+# updates the draft GitHub Release "DeckCraft v<version>" (tag v<version>). Recipe:
+# craftrules release/playbook.md.
+#
+# The version has one source: `[workspace.package] version` in Cargo.toml (`cargo xtask version`,
+# `cargo xtask version set X.Y.Z`). The app shows it in About and `--version`; the release name
+# and tag use it too. workflow_dispatch can override it for a test build (applied to the build).
+#
+# The jobs that sign (macOS, Windows) and the one that drafts the release run in the `release`
+# environment (restricted to the `release` branch), which holds the signing secrets. Every secret
+# is optional: missing ones produce unsigned artifacts and a warning, never a failed build. The
+# other jobs sign nothing and get no secrets, so a workflow_dispatch from another branch is a dry
+# run: they build, the signed jobs are refused by the environment, and no release is drafted.
 name: Release
 
 on:
@@ -11,33 +24,469 @@ on:
         default: ""
 
 permissions:
-  contents: write
+  contents: read
 
 concurrency:
   group: release-${{ github.ref }}
+  # Never cancel a run mid-notarization or mid-upload; a newer push waits its turn.
   cancel-in-progress: false
 
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: 1
+  DECKCRAFT_BUILD_SHA: ${{ github.sha }}
+  INPUT_VERSION: ${{ inputs.version }}
+  # Optional font input (storytold/craft-fonts docs/integration.md); releases always embed it.
+  # This commit adds fonts/latin-manifest.txt (the Latin presentation fonts).
+  CRAFT_FONTS_REF: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+
 jobs:
+  version:
+    name: version
+    runs-on: ubuntu-latest
+    # No `environment: release`: no secrets needed, so branch dry runs get past it.
+    outputs:
+      version: ${{ steps.v.outputs.version }}
+      date: ${{ steps.v.outputs.date }}
+      prerelease: ${{ steps.v.outputs.prerelease }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - id: v
+        name: Resolve version
+        run: |
+          . packaging/common.sh
+          v="${INPUT_VERSION#v}"
+          v="${v:-$VERSION}"
+          if ! printf '%s' "$v" | grep -Eq '^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$'; then
+            echo "::error::'$v' is not a version like 1.2.3 or 1.2.3-rc.1"
+            exit 1
+          fi
+          case "$v" in *-*) pre=true ;; *) pre=false ;; esac
+          {
+            echo "version=$v"
+            echo "date=$(date -u +%Y-%m-%d)"
+            echo "prerelease=$pre"
+          } >>"$GITHUB_OUTPUT"
+          echo "### DeckCraft v$v (\`${GITHUB_SHA::9}\`)" >>"$GITHUB_STEP_SUMMARY"
+
+  macos:
+    name: macOS universal
+    needs: version
+    runs-on: macos-15-xlarge  # M2 Pro larger runner; use only in release.yml (actions_macos_xl budget caps spend)
+    environment: release
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: aarch64-apple-darwin, x86_64-apple-darwin
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-macos-universal
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_VERSION"
+      - name: Import signing certificate
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: packaging/macos/import-cert.sh
+      - name: Build, sign, notarize
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: packaging/macos/package.sh --arch universal
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-macos
+          path: dist/release/*
+          if-no-files-found: error
+      - name: Remove temporary keychain
+        if: always()
+        run: |
+          if [ -n "${MACOS_KEYCHAIN:-}" ]; then security delete-keychain "$MACOS_KEYCHAIN" || true; fi
+
+  windows:
+    name: Windows ${{ matrix.arch }}
+    needs: version
+    runs-on: windows-latest
+    environment: release
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { arch: x64, target: x86_64-pc-windows-msvc }
+          - { arch: x86, target: i686-pc-windows-msvc }
+          # Windows on ARM: cross-compiled on the x64 runner, so signing (x64 signtool / Azure
+          # Trusted Signing) and WiX (-arch arm64) run as above. package.ps1 checks the PE machine
+          # type and skips the CLI smoke test, since an ARM64 exe can't run on the x64 runner.
+          - { arch: arm64, target: aarch64-pc-windows-msvc }
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-windows-${{ matrix.arch }}
+      - name: Apply version override
+        if: inputs.version != ''
+        shell: bash
+        run: cargo xtask version set "$DECKCRAFT_VERSION"
+      - name: Install WiX
+        shell: pwsh
+        run: dotnet tool install --global wix --version 5.0.2
+      - name: Build, sign, package
+        shell: pwsh
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+          AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+          AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+          AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
+          AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
+          AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
+          AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
+        run: ./packaging/windows/package.ps1 -Arch ${{ matrix.arch }}
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-windows-${{ matrix.arch }}
+          path: dist/release/*
+          if-no-files-found: error
+
+  linux:
+    name: Linux ${{ matrix.arch }}
+    needs: version
+    # The oldest GitHub-hosted image, so the binaries only need glibc >= 2.35 (Ubuntu 22.04+,
+    # Debian 12+, Fedora 36+, RHEL 10).
+    runs-on: ${{ matrix.runner }}
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { arch: x86_64, runner: ubuntu-22.04, deb: amd64 }
+          - { arch: aarch64, runner: ubuntu-22.04-arm, deb: arm64 }
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+      NFPM_VERSION: 2.47.0
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - name: Install build and packaging tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            libasound2-dev libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev \
+            desktop-file-utils appstream python3-yaml zsync
+          curl -fsSL -o "$RUNNER_TEMP/nfpm.deb" \
+            "https://github.com/goreleaser/nfpm/releases/download/v${NFPM_VERSION}/nfpm_${NFPM_VERSION}_${{ matrix.deb }}.deb"
+          sudo dpkg -i "$RUNNER_TEMP/nfpm.deb"
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-linux-${{ matrix.arch }}
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_VERSION"
+      - name: Build and package (AppImage, deb, rpm, tar.gz)
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+        run: packaging/linux/package.sh
+      - name: Check the packages
+        run: |
+          dpkg-deb --info dist/release/*.deb
+          dpkg-deb --contents dist/release/*.deb | grep -E 'usr/bin/deckcraft$|metainfo|applications'
+          ldd target/release/deckcraft
+          for appimage in dist/release/*.AppImage; do
+            chmod +x "$appimage"
+            APPIMAGE_EXTRACT_AND_RUN=1 "$appimage" --version
+            # Update information is embedded, and the .zsync for delta updates sits beside it.
+            "$appimage" --appimage-updateinformation | grep -F 'gh-releases-zsync|'
+            test -s "$appimage.zsync"
+          done
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-linux-${{ matrix.arch }}
+          path: dist/release/*
+          if-no-files-found: error
+
+  flatpak:
+    name: Flatpak ${{ matrix.arch }}
+    needs: [version, linux]
+    # Repackages the Linux job's tarball (the same binaries as the AppImage/deb/rpm, with the
+    # craft-fonts embedded); no Rust build here. packaging/linux/flatpak/ai.storyteller.deckcraft.yml
+    # stays the from-source manifest for Flathub. 24.04 for a newer flatpak-builder (1.4) than
+    # 22.04 ships.
+    runs-on: ${{ matrix.runner }}
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { arch: x86_64, runner: ubuntu-24.04 }
+          - { arch: aarch64, runner: ubuntu-24.04-arm }
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          name: release-linux-${{ matrix.arch }}
+          path: dist/linux
+      - name: Install flatpak-builder
+        run: |
+          sudo apt-get update
+          # librsvg2-common: the SVG pixbuf loader. flatpak-builder runs the host's
+          # `appstreamcli compose`, which can fail without it.
+          sudo apt-get install -y --no-install-recommends flatpak flatpak-builder librsvg2-common
+          # Ubuntu 24.04's AppArmor blocks the unprivileged user namespaces bubblewrap needs.
+          sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
+      - name: Build the Flatpak bundle
+        run: packaging/linux/flatpak-bundle.sh "dist/linux/deckcraft-$DECKCRAFT_VERSION-linux-${{ matrix.arch }}.tar.gz"
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-flatpak-${{ matrix.arch }}
+          path: dist/release/*.flatpak
+          if-no-files-found: error
+
+  freebsd:
+    name: FreeBSD x86_64
+    needs: version
+    runs-on: ubuntu-latest
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    timeout-minutes: 240
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+      VERSION_OVERRIDE: ${{ inputs.version }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - name: Build and package in a FreeBSD VM
+        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc # v1.5.9
+        with:
+          release: "14.3"
+          usesh: true
+          cpu: 4
+          mem: 12288
+          envs: DECKCRAFT_VERSION DECKCRAFT_BUILD_DATE DECKCRAFT_BUILD_SHA VERSION_OVERRIDE
+          # Copies the workspace (with dist/release) back; the target dir lives outside it so the
+          # copy stays small.
+          copyback: true
+          prepare: |
+            pkg install -y bash git curl pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader fontconfig freetype2 alsa-lib
+            curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal
+          run: |
+            . "$HOME/.cargo/env"
+            git config --global --add safe.directory "*"
+            export CARGO_TARGET_DIR="$HOME/target" CRAFT_FONTS_DIR="$PWD/craft-fonts" CRAFT_FONTS_REQUIRED=1
+            if [ -n "$VERSION_OVERRIDE" ]; then cargo xtask version set "$DECKCRAFT_VERSION"; fi
+            bash packaging/freebsd/package.sh
+            tar -tzf dist/release/deckcraft-*-freebsd-x86_64.tar.gz \
+              | grep -E '/bin/deckcraft$|/bin/deckcraft-cli$|/share/applications/ai\.storyteller\.deckcraft\.desktop$'
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-freebsd
+          path: dist/release/*
+          if-no-files-found: error
+
+  web:
+    name: Web (wasm)
+    needs: version
+    runs-on: ubuntu-latest
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+      TRUNK_VERSION: 0.21.14
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-web
+      - name: Install trunk
+        run: |
+          curl -fsSL "https://github.com/trunk-rs/trunk/releases/download/v${TRUNK_VERSION}/trunk-x86_64-unknown-linux-gnu.tar.gz" \
+            | tar -xz -C "$HOME/.cargo/bin" trunk
+          trunk --version
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_VERSION"
+      - name: Build and zip
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+        run: packaging/web/package.sh
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-web
+          path: dist/release/*
+          if-no-files-found: error
+
+  linux-riscv64:
+    name: Linux riscv64
+    needs: version
+    # Cross-compiled on x86_64 (no hosted RISC-V runners) against the runner's own Ubuntu release
+    # from ports.ubuntu.com, so the binaries need that release's glibc (24.04: 2.39). 22.04's
+    # riscv64 ports lag its amd64 updates, which breaks the multiarch install. tar.gz only; the
+    # CLI is smoke-tested under QEMU.
+    runs-on: ubuntu-24.04
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: riscv64gc-unknown-linux-gnu
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-linux-riscv64
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_VERSION"
+      - name: Install cross-compilation dependencies
+        run: |
+          . /etc/os-release
+          sudo dpkg --add-architecture riscv64
+          # Pin the existing (archive.ubuntu.com) sources to amd64; riscv64 comes from ports.
+          if [ -f /etc/apt/sources.list.d/ubuntu.sources ]; then
+            sudo sed -i '/^Types: deb/a Architectures: amd64' /etc/apt/sources.list.d/ubuntu.sources
+          fi
+          if [ -f /etc/apt/sources.list ]; then
+            sudo sed -i 's/^deb /deb [arch=amd64] /g' /etc/apt/sources.list
+            sudo sed -i 's/^deb-src /deb-src [arch=amd64] /g' /etc/apt/sources.list
+          fi
+          for suite in "$VERSION_CODENAME" "$VERSION_CODENAME-updates" "$VERSION_CODENAME-security"; do
+            echo "deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports $suite main universe restricted multiverse"
+          done | sudo tee /etc/apt/sources.list.d/riscv64.list
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu libc6-dev-riscv64-cross libc6-dev:riscv64 qemu-user \
+            libasound2-dev:riscv64 libxkbcommon-dev:riscv64 libwayland-dev:riscv64 libx11-dev:riscv64 \
+            libxrandr-dev:riscv64 libxi-dev:riscv64 libgl1-mesa-dev:riscv64
+      - name: Build and package (tar.gz)
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+          CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER: riscv64-linux-gnu-gcc
+          PKG_CONFIG_SYSROOT_DIR: /
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig:/usr/share/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: "1"
+          CROSS_ARCH: riscv64
+          CROSS_TARGET: riscv64gc-unknown-linux-gnu
+          CROSS_COMPILE: riscv64-linux-gnu-
+          EMULATOR: qemu-riscv64
+          QEMU_LD_PREFIX: /usr/riscv64-linux-gnu
+        run: packaging/linux/package.sh --formats tar
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-linux-riscv64
+          path: dist/release/*.tar.gz
+          if-no-files-found: error
+
   release:
-    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
-    uses: storytold/craft-common-actions/.github/workflows/release.yml@main
-    with:
-      app-name: deckcraft
-      app-title: DeckCraft
-      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
-      version: ${{ inputs.version }}
-    secrets:
-      APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-      APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-      KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
-      APPLE_ID: ${{ secrets.APPLE_ID }}
-      APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-      APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-      WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-      WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
-      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
-      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
-      AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
-      AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
-      AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
-      AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
+    name: Draft GitHub Release
+    # Every build is required, so the draft always has the full set the README lists. Needing the
+    # signed jobs also keeps branch dry runs from drafting a release.
+    needs: [version, macos, windows, linux, linux-riscv64, flatpak, freebsd, web]
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      contents: write
+    env:
+      VERSION: ${{ needs.version.outputs.version }}
+      PRERELEASE: ${{ needs.version.outputs.prerelease }}
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      GH_REPO: ${{ github.repository }}
+    steps:
+      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          pattern: release-*
+          path: artifacts
+          merge-multiple: true
+      - name: Checksums
+        working-directory: artifacts
+        run: |
+          sha256sum -- * | tee SHA256SUMS.txt
+      - name: Create or update the draft release
+        working-directory: artifacts
+        run: |
+          tag="v$VERSION"
+          title="DeckCraft v$VERSION"
+          pre=()
+          if [ "$PRERELEASE" = true ]; then pre=(--prerelease); fi
+          if draft="$(gh release view "$tag" --json isDraft --jq .isDraft 2>/dev/null)"; then
+            if [ "$draft" != "true" ]; then
+              echo "::error::Release $tag is already published. Bump the version (cargo xtask version set) before pushing to release."
+              exit 1
+            fi
+            echo "Updating draft $tag: replacing its assets"
+            gh release view "$tag" --json assets --jq '.assets[].name' | while read -r asset; do
+              gh release delete-asset "$tag" "$asset" --yes
+            done
+            gh release edit "$tag" --draft --title "$title" --target "$GITHUB_SHA" --prerelease="$PRERELEASE"
+            gh release upload "$tag" --clobber -- *
+          else
+            echo "Creating draft $tag"
+            gh release create "$tag" --draft --title "$title" --target "$GITHUB_SHA" --generate-notes "${pre[@]}" -- *
+          fi
+          {
+            echo "Draft release **$title** at \`${GITHUB_SHA::9}\`:"
+            echo
+            sed 's/^/    /' SHA256SUMS.txt
+          } >>"$GITHUB_STEP_SUMMARY"

ATTRIBUTION.md

@@ -27,10 +27,6 @@ deck and UI icons are original work of the DeckCraft contributors (drawn or gene
 | `crates/media/tests/fixtures/tone*` (`tone.mp3`, `.m4a`, `.aac`, `.ogg`, `.opus`, `.flac`, `.wma`, `tone-alac.m4a`) | DeckCraft contributors | synthesised 0.5 s 440 Hz sine, encoded by `crates/media/tests/fixtures/make.sh` (ffmpeg as the encoder only) | CC0-1.0 | Audio decoding tests |
 | `crates/media/tests/fixtures/clip-*` (`clip-h264.mp4`, `clip-h264.mov`, `clip-hevc.mp4`, `clip-vp9.webm`, `clip-av1.mkv`) | DeckCraft contributors | 6 frames of a colour gradient generated by `make.sh` (python3), encoded by ffmpeg (x264 / x265 / libvpx / SVT-AV1 as encoders only) | CC0-1.0 | Video decoding tests |
 | `crates/media/tests/fixtures/make.sh` | DeckCraft contributors | this repository | MIT OR Apache-2.0 | Regenerates the media fixtures |
-| `crates/render/tests/fixtures/colr-squares.ttf` | DeckCraft contributors | two squares as a COLRv0/CPAL test font, built by `make_colr_font.py` (fontTools as the builder only) | CC0-1.0 | Colour glyph rendering tests |
-| `crates/fonts/tests/fixtures/legacy-semibold.ttf` | DeckCraft contributors | a one-glyph Semibold face named like Segoe UI Semibold (its Windows family differs from the typographic one), built by `make_legacy_font.py` (fontTools as the builder only) | CC0-1.0 | Font lookup by Windows family name tests |
-| `crates/fonts/tests/fixtures/legacy-regular.ttf` | DeckCraft contributors | the same family's one-glyph Regular face, built by `make_legacy_font.py` (fontTools as the builder only) | CC0-1.0 | Font lookup by Windows family name tests |
-| `crates/render/tests/fixtures/make_colr_font.py` | DeckCraft contributors | this repository | MIT OR Apache-2.0 | Regenerates the COLR test font |
 
 ## Bundled through dependencies
 

Cargo.lock

@@ -877,7 +877,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
 name = "deckcraft"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "arboard",
  "cpal",
@@ -896,7 +896,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-anim"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-geom",
  "deckcraft-model",
@@ -905,7 +905,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-av1"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -914,14 +914,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-bitstream"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "proptest",
 ]
 
 [[package]]
 name = "deckcraft-cli"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-mcp",
@@ -930,14 +930,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-color"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "deckcraft-engine"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-fonts",
@@ -959,7 +959,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-fonts"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "epaint_default_fonts",
  "harfrust 0.13.3",
@@ -971,7 +971,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-format"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-model",
  "serde",
@@ -982,7 +982,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-geom"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "kurbo",
  "serde",
@@ -990,7 +990,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-h264"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -999,7 +999,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-hevc"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1008,7 +1008,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-isobmff"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-bitstream",
  "thiserror 2.0.21",
@@ -1016,11 +1016,11 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-matroska"
-version = "0.6.1"
+version = "0.5.0"
 
 [[package]]
 name = "deckcraft-mcp"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-render",
@@ -1030,7 +1030,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-media"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-av1",
  "deckcraft-h264",
@@ -1046,37 +1046,28 @@ dependencies = [
  "thiserror 2.0.21",
 ]
 
-[[package]]
-name = "deckcraft-metafile"
-version = "0.6.1"
-dependencies = [
- "kurbo",
- "thiserror 2.0.21",
-]
-
 [[package]]
 name = "deckcraft-model"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-geom",
  "serde",
  "serde_json",
  "thiserror 2.0.21",
- "unicode-segmentation",
 ]
 
 [[package]]
 name = "deckcraft-ogg"
-version = "0.6.1"
+version = "0.5.0"
 
 [[package]]
 name = "deckcraft-opus"
-version = "0.6.1"
+version = "0.5.0"
 
 [[package]]
 name = "deckcraft-pdf"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-fonts",
  "deckcraft-model",
@@ -1091,7 +1082,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-pptx"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-engine",
@@ -1107,26 +1098,23 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-render"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
- "deckcraft-anim",
  "deckcraft-color",
  "deckcraft-fonts",
  "deckcraft-geom",
- "deckcraft-metafile",
  "deckcraft-model",
  "deckcraft-text",
  "image",
  "kurbo",
  "log",
- "skrifa 0.47.0",
  "vello_common 0.2.0",
  "vello_cpu 0.2.0",
 ]
 
 [[package]]
 name = "deckcraft-text"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "chrono",
  "deckcraft-color",
@@ -1140,7 +1128,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ui-egui"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-anim",
  "deckcraft-color",
@@ -1162,7 +1150,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-vp9"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1171,7 +1159,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-web"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-ui-egui",
@@ -5667,7 +5655,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
  "serde_json",
 ]

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
 
 [workspace.package]
-version = "0.6.1"
+version = "0.5.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.90"
@@ -14,7 +14,6 @@ repository = "https://github.com/storytold/deckcraft"
 # internal
 deckcraft-geom = { path = "crates/geom" }
 deckcraft-color = { path = "crates/color" }
-deckcraft-metafile = { path = "crates/metafile" }
 deckcraft-model = { path = "crates/model" }
 deckcraft-fonts = { path = "crates/fonts" }
 deckcraft-text = { path = "crates/text" }

ROADMAP.md

@@ -128,17 +128,6 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | What landed |
 |---|---|
-| 2026-10-13 | Slide transitions like PowerPoint: every transition and option measured frame by frame against PowerPoint's video export and retuned (curves, directions, soft edges, 3-D perspective, contents moving over backgrounds); PowerPoint's own XML elements and defaults read and written (diagonal Wipe, Zoom, Shape In/Out, Glitter Hexagons, Shred In/Out, Page Curl Single); `deckcraft-cli render-transition` renders frames headless |
-| 2026-10-13 | Wild text cases measured against PowerPoint (102 synthetic slides): bidi by run language, East Asian vertical text upright, mongolianVert/wordArtVert/wordArtVertRtl, underline styles and strikethrough at the font's metrics, centre/right/decimal tabs, East Asian, Thai, Hindi, Arabic and Hebrew numbering, small caps, all-caps "ß", transparent text, soft hyphens, kinsoku, rtlCol and just/dist anchoring, emoji presentation, fallback faces that no longer move the baseline |
-| 2026-10-13 | Render matches PowerPoint more closely on wild shape, picture and table cases: even-odd custom paths, dashes and caps, arrowheads, radial and path gradients, tile rects, rotWithShape, gradient lines, shadows cast by what is drawn (group and perspective too), group fill, picture borders, tiles, reflection, recolour (biLevel, alphaInv, brightness/contrast), table borders and grid default, 20+ preset shapes by their ECMA formulas, default miter joins, and approximate 3-D bevels, cameras and face lighting |
-| 2026-10-12 | Objects off the slide show and can be selected and moved around it in Normal view, as in PowerPoint; the show, exports and thumbnails still clip to the slide (#270) |
-| 2026-10-12 | Korean, Japanese and Chinese input: IME composition shown in place and underlined, one undo step per composition, candidate window at the caret (slide text, notes, fields); interface text (title, notes, outline, sections, comments) borrows installed fonts for scripts the interface fonts lack (#101) |
-| 2026-10-12 | Selection Pane like PowerPoint (#133): front-most first, groups fold, drag and drop restacks among siblings, Bring Forward / Send Backward, Show All / Hide All, eye, rename in place, keyboard; Lock (pane padlock, canvas menu) keeps objects from moving, sizing or rotating and round-trips PowerPoint's locking attributes |
-| 2026-10-12 | Text keys like PowerPoint for Windows (#268): Ctrl+arrows and Ctrl+Shift+arrows by word (punctuation, CJK, emoji, RTL), Ctrl+Backspace/Delete with smart spacing, Ctrl+Up/Down by paragraph, Ctrl+Home/End, End on wrapped lines, Ctrl+]/[ and Ctrl+Shift+>/< font size, Shift+F3 case cycle, word and paragraph selection |
-| 2026-10-12 | EMF/WMF pictures draw their text (fonts, alignment, dx advances, escapement, symbol fonts), pattern and hatch brushes, PATBLT and the XOR/AND see-through shadow; legacy OLE objects show their VML preview and ActiveX controls their pictures |
-| 2026-10-12 | File tab (Backstage) like PowerPoint's (#76): File or Alt+F opens Home, New, Open, Info, Save, Save As, Print, Export, Close, Account and Options over the window, Esc or Back returns, arrows walk the side menu; the start screen is File › Home. Pages run the existing file commands; new `file.info`, print slide ranges (`"1-3, 5"`), Print through a PDF, Ctrl+P, and Close/Ctrl+W ask about unsaved changes |
-| 2026-10-12 | WordArt text warps (`prstTxWarp`): all 40 presets drawn, curves fitted to PowerPoint by observation; warp adjusts round-trip |
-| 2026-10-12 | Render: line widths, dashes and arrowheads inside a group no longer scale with the group's child-coordinate mapping, so a group in a small legacy child space (scale about 1600) draws thin lines instead of covering the slide (#233) |
 | 2026-10-10 | Progress docs restructured to the craftrules standard; full re-measure (breadth 79%, ready ~55%, mainstream ~53%, essentials ~62%, alpha). Landed: Animation Painter (#54), Morph geometry outlines (#27), animated GIF playback (#39), hyperlink colour and following links in the show (#37, #45), date fields in their own format (#36), flipped shapes keep readable text (#35), show transition fix (#46), start screen from the Home button (#49), MCP export lists PDF (#65), OmaStore manifest (#57) |
 | 2026-10-09 | v0.4.0 released. UAX #9 bidi and Arabic shaping (#4), Morph with Words and Characters (#5), tables grow to fit and PDF cell text (#14), rotating log file (#7), DX12 default on Windows (#16), H.264/HEVC overflow hardening (#2), PPTX sniffing anywhere in the zip (#19) |
 | 2026-10-08 | v0.2.0 and v0.3.0 released: Windows arm64, Flatpak aarch64, AppImage zsync updates, branded DMG |
@@ -150,9 +139,6 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-13 | trivial | Progress log: wild text cases |
-| 2026-10-12 | trivial | Progress log: File tab (Backstage, #76) |
-| 2026-10-12 | trivial | Progress log: lines in scaled groups (#233) |
 | 2026-10-10 | minor | Readiness-by-audience table with hours to ~95% for full, mainstream and essentials |
 | 2026-10-10 | minor | Added mainstream practitioner (~53%) and essentials user (~62%); features recomputed from written area weights, ready ~56% → ~55% |
 | 2026-10-10 | minor | Stage checked against the new core-workflow gate: passes, stays alpha |

apps/deckcraft-cli/src/main.rs

@@ -3,7 +3,6 @@
 //! ```text
 //! deckcraft-cli info FILE                       # slides, titles, layouts (JSON)
 //! deckcraft-cli render (FILE | --sample) [--slide N | --all] [--scale S] OUT.png|OUT_DIR
-//! deckcraft-cli render-transition FILE --slide N --t T[,T…] [--width PX] OUT.png   # transition frame(s)
 //! deckcraft-cli convert IN OUT                  # .deckcraft ⇄ .pptx, outline .txt, .png (first slide)
 //! deckcraft-cli run [--in FILE | --sample] [--cmd ID[=JSON]]... [--save OUT] [--export OUT] [--print]
 //! deckcraft-cli commands [FILTER]               # list commands (JSON)
@@ -35,7 +34,6 @@ macro_rules! outln {
 
 const USAGE: &str = "usage: deckcraft-cli info FILE
        deckcraft-cli render (FILE | --sample) [--slide N | --all] [--scale S] [--edit] OUT
-       deckcraft-cli render-transition FILE --slide N --t T[,T...] [--width PX] OUT.png
        deckcraft-cli convert IN OUT
        deckcraft-cli run [--in FILE | --sample] [--cmd ID[=JSON]]... [--save OUT] [--export OUT] [--print]
        deckcraft-cli commands [FILTER]
@@ -54,7 +52,6 @@ fn main() -> ExitCode {
         }
         Some("info") => report(info(rest)),
         Some("render") => report(render(rest)),
-        Some("render-transition") => report(render_transition(rest)),
         Some("convert") => report(convert(rest)),
         Some("run") => report(run(rest)),
         Some("commands") => {
@@ -164,80 +161,6 @@ fn render(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// Frames of slide N's transition (0-based N; from slide N-1, or black for the first slide) at
-/// the given progress values. With several values, OUT gets `-t<value>` before its extension.
-fn render_transition(args: &[String]) -> Result<(), String> {
-    use deckcraft_engine::render;
-    let mut input = None;
-    let mut slide: Option<usize> = None;
-    let mut ts: Vec<f64> = Vec::new();
-    let mut width: Option<f64> = None;
-    let mut out = None;
-    let mut it = args.iter();
-    while let Some(a) = it.next() {
-        match a.as_str() {
-            "--slide" => slide = Some(it.next().and_then(|v| v.parse().ok()).ok_or("--slide needs a number")?),
-            "--t" => {
-                let v = it.next().ok_or("--t needs a value")?;
-                for x in v.split(',') {
-                    let t: f64 = x.trim().parse().map_err(|_| format!("bad --t value `{x}`"))?;
-                    if !t.is_finite() {
-                        return Err(format!("bad --t value `{x}`"));
-                    }
-                    ts.push(t);
-                }
-            }
-            "--width" => {
-                width = Some(it.next().and_then(|v| v.parse().ok()).filter(|w: &f64| w.is_finite() && *w >= 1.0).ok_or("--width needs pixels")?)
-            }
-            other if input.is_none() => input = Some(other.to_string()),
-            other => out = Some(other.to_string()),
-        }
-    }
-    let input = input.ok_or("render-transition needs a FILE")?;
-    let out = out.ok_or("render-transition needs an output path")?;
-    let i = slide.ok_or("render-transition needs --slide N")?;
-    if ts.is_empty() {
-        return Err("render-transition needs --t".into());
-    }
-    let mut s = Session::new();
-    open(&mut s, Some(&input), false)?;
-    let st = s.doc().map_err(|e| e.to_string())?;
-    let doc = &st.doc;
-    let n = doc.slides.len();
-    let Some(sl) = doc.slides.get(i) else { return Err(format!("no slide {i} (the deck has {n})")) };
-    let sw = doc.slide_size.width.max(1.0);
-    let w = width.unwrap_or(sw * 2.0).min(render::MAX_SIDE as f64);
-    let opts = render::RenderOpts { scale: w / sw, ..Default::default() };
-    let tr = sl.transition.clone().unwrap_or_default();
-    // Render both slides once and composite every frame from them (morph re-renders per frame).
-    let prev = i.checked_sub(1);
-    let cached = (tr.kind != "morph").then(|| {
-        let parts = render::uses_slide_parts(&tr.kind, &tr.option).then(|| render::SlideParts::render(doc, prev, i, &opts));
-        (prev.map(|p| render::render_slide(doc, p, &opts)), render::render_slide(doc, i, &opts), parts)
-    });
-    let aspect = sw / doc.slide_size.height.max(1.0);
-    for t in &ts {
-        let img = match &cached {
-            Some((old, new, parts)) => {
-                render::composite_transition(old.as_ref(), new, parts.as_ref(), &render::transition_frame(&tr.kind, &tr.option, *t, aspect))
-            }
-            None => render::render_transition(doc, i, *t, &opts),
-        };
-        let path = if ts.len() == 1 {
-            out.clone()
-        } else {
-            let p = std::path::Path::new(&out);
-            let stem = p.file_stem().and_then(|x| x.to_str()).unwrap_or("frame");
-            let name = format!("{stem}-t{t:.3}.png");
-            p.with_file_name(name).to_string_lossy().into_owned()
-        };
-        std::fs::write(&path, img.to_png()).map_err(|e| format!("{path}: {e}"))?;
-        outln!("{path} ({}×{}) {} {} t={t}", img.width, img.height, tr.kind, tr.option);
-    }
-    Ok(())
-}
-
 fn convert(args: &[String]) -> Result<(), String> {
     let (Some(input), Some(out)) = (args.first(), args.get(1)) else { return Err("convert needs IN and OUT".into()) };
     let mut s = Session::new();

contributors/people.toml

@@ -37,7 +37,3 @@ sync_github_name = false
 
 [people.Johannesgauss]
 sync_github_name = true
-
-[people.Silvertree2010]
-display_name = "Netter"
-sync_github_name = false

crates/anim/src/lib.rs

@@ -14,30 +14,24 @@
 
 mod easing;
 mod effects;
-mod mesh;
 mod morph;
 mod path;
 mod show;
 mod timeline;
 mod transition;
-mod transition_fx;
-mod transition_geom;
 
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod transition_tests;
 
 pub use deckcraft_model::Rgba;
 use serde::{Deserialize, Serialize};
 
 pub use easing::ease;
-pub use mesh::{MeshVertex, layer_mesh};
 pub use morph::{MorphFrame, MorphPath, MorphText, morph_frame, morph_pairs, morph_xfrm};
 pub use path::{MotionPath, default_path};
 pub use show::{LinkJump, ShowAction, ShowState, safe_url, show_order};
 pub use timeline::{EffectTiming, Sequence, Timeline, TriggerPlay};
-pub use transition::{DEFAULT_ASPECT, Layer, Source, transition_frame, transition_layers, uses_slide_parts};
+pub use transition::{Layer, Source, transition_layers};
 
 /// Animation state of one shape (or one paragraph of a shape's text) at one moment of the show.
 ///

crates/anim/src/mesh.rs

@@ -1,139 +0,0 @@
-//! Triangle meshes for transition layers.
-//!
-//! A [`Layer`] is a textured quad. Drawn as two triangles, a trapezoid (a slide seen in
-//! perspective) bends its texture along the diagonal, because GPUs and simple rasterisers
-//! interpolate texture coordinates linearly in screen space. [`layer_mesh`] splits such quads into a
-//! grid whose vertices follow the projective map from the source rectangle to the quad, so the
-//! picture looks like a flat card turned in 3-D. Rectangles and parallelograms stay two triangles,
-//! wedges one: the per-frame cost stays a handful of vertices per layer.
-
-use crate::transition::Layer;
-
-/// One mesh vertex: position in slide-unit space (0..1, y down), texture coordinate (0..1) and
-/// opacity (the layer's alpha times its corner fade, interpolated).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct MeshVertex {
-    pub pos: [f64; 2],
-    pub uv: [f64; 2],
-    pub a: f64,
-}
-
-/// Grid cells per side for quads that need a projective subdivision.
-const GRID: usize = 8;
-
-/// The triangles of a layer: vertices and index triples into them.
-pub fn layer_mesh(l: &Layer) -> (Vec<MeshVertex>, Vec<[u32; 3]>) {
-    let q = l.quad;
-    let uv = l.uv;
-    let fa = l.fade.map(|f| f * l.alpha);
-    // A wedge (triangle): the 4th corner repeats the 3rd.
-    if q[3] == q[2] && uv[3] == uv[2] {
-        let v = (0..3).map(|k| MeshVertex { pos: q[k], uv: uv[k], a: fa[k] }).collect();
-        return (v, vec![[0, 1, 2]]);
-    }
-    let affine = {
-        // Parallelogram: opposite edges equal.
-        let e1 = [q[1][0] - q[0][0], q[1][1] - q[0][1]];
-        let e2 = [q[2][0] - q[3][0], q[2][1] - q[3][1]];
-        (e1[0] - e2[0]).abs() < 1e-9 && (e1[1] - e2[1]).abs() < 1e-9
-    };
-    let h = if affine { None } else { square_to_quad(q) };
-    let Some(h) = h else {
-        let v = (0..4).map(|k| MeshVertex { pos: q[k], uv: uv[k], a: fa[k] }).collect();
-        return (v, vec![[0, 1, 2], [0, 2, 3]]);
-    };
-    // Small quads (tiles, shards) bend their texture too little to matter: fewer cells.
-    let span = q.iter().flat_map(|p| q.iter().map(move |r| (p[0] - r[0]).abs().max((p[1] - r[1]).abs()))).fold(0.0, f64::max);
-    let n = ((span * 2.0 * GRID as f64).ceil() as usize).clamp(1, GRID);
-    let mut v = Vec::with_capacity((n + 1) * (n + 1));
-    for j in 0..=n {
-        let b = j as f64 / n as f64;
-        for i in 0..=n {
-            let a = i as f64 / n as f64;
-            // Texture: bilinear in (a, b) over the four uv corners (exact for rectangles).
-            let top = lerp2(uv[0], uv[1], a);
-            let bot = lerp2(uv[3], uv[2], a);
-            let t = lerp2(top, bot, b);
-            let at = fa[0] + (fa[1] - fa[0]) * a;
-            let ab = fa[3] + (fa[2] - fa[3]) * a;
-            v.push(MeshVertex { pos: apply(&h, a, b), uv: t, a: at + (ab - at) * b });
-        }
-    }
-    let mut tris = Vec::with_capacity(n * n * 2);
-    let w = (n + 1) as u32;
-    for j in 0..n as u32 {
-        for i in 0..n as u32 {
-            let p = j * w + i;
-            tris.push([p, p + 1, p + w + 1]);
-            tris.push([p, p + w + 1, p + w]);
-        }
-    }
-    (v, tris)
-}
-
-fn lerp2(a: [f64; 2], b: [f64; 2], t: f64) -> [f64; 2] {
-    [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
-}
-
-/// Projective map taking the unit square's corners (0,0), (1,0), (1,1), (0,1) to `q`'s tl, tr, br,
-/// bl (Heckbert's square-to-quad). `None` when the quad is degenerate.
-fn square_to_quad(q: [[f64; 2]; 4]) -> Option<[f64; 8]> {
-    let [[x0, y0], [x1, y1], [x2, y2], [x3, y3]] = q;
-    let sx = x0 - x1 + x2 - x3;
-    let sy = y0 - y1 + y2 - y3;
-    let (dx1, dx2, dy1, dy2) = (x1 - x2, x3 - x2, y1 - y2, y3 - y2);
-    let den = dx1 * dy2 - dx2 * dy1;
-    if !den.is_finite() || den.abs() < 1e-12 {
-        return None;
-    }
-    let g = (sx * dy2 - dx2 * sy) / den;
-    let h = (dx1 * sy - sx * dy1) / den;
-    let m = [x1 - x0 + g * x1, x3 - x0 + h * x3, x0, y1 - y0 + g * y1, y3 - y0 + h * y3, y0, g, h];
-    m.iter().all(|v| v.is_finite()).then_some(m)
-}
-
-fn apply(m: &[f64; 8], u: f64, v: f64) -> [f64; 2] {
-    let w = m[6] * u + m[7] * v + 1.0;
-    let w = if w.abs() < 1e-9 { 1e-9_f64.copysign(w) } else { w };
-    [(m[0] * u + m[1] * v + m[2]) / w, (m[3] * u + m[4] * v + m[5]) / w]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::transition::{Layer, Source};
-
-    #[test]
-    fn rect_is_two_triangles() {
-        let (v, t) = layer_mesh(&Layer::full(Source::New, 1.0));
-        assert_eq!((v.len(), t.len()), (4, 2));
-    }
-
-    #[test]
-    fn trapezoid_is_subdivided_projectively() {
-        // A card turned about its left edge: the right edge is shorter.
-        let q = [[0.0, 0.0], [0.6, 0.2], [0.6, 0.8], [0.0, 1.0]];
-        let l = Layer::quad(Source::Old, [0.0, 0.0, 1.0, 1.0], q, 1.0);
-        let (v, t) = layer_mesh(&l);
-        assert_eq!(v.len(), (GRID + 1) * (GRID + 1));
-        assert_eq!(t.len(), GRID * GRID * 2);
-        // A small tile in perspective needs no more than a couple of triangles.
-        let small = Layer::quad(Source::Old, [0.0, 0.0, 1.0, 1.0], [[0.5, 0.5], [0.52, 0.505], [0.52, 0.515], [0.5, 0.52]], 1.0);
-        assert!(layer_mesh(&small).1.len() <= 2);
-        // Corners land on the quad's corners.
-        assert_eq!(v[0].pos, q[0]);
-        let last = v[v.len() - 1].pos;
-        assert!((last[0] - 0.6).abs() < 1e-9 && (last[1] - 0.8).abs() < 1e-9);
-        // The texture's middle column sits nearer the far (short) edge than halfway: foreshortening.
-        let mid = v[GRID / 2].pos[0];
-        assert!(mid > 0.3, "{mid}");
-    }
-
-    #[test]
-    fn degenerate_quads_do_not_blow_up() {
-        let q = [[0.5, 0.5]; 4];
-        let l = Layer::quad(Source::Old, [0.0, 0.0, 1.0, 1.0], q, 1.0);
-        let (v, _) = layer_mesh(&l);
-        assert!(v.iter().all(|p| p.pos[0].is_finite() && p.pos[1].is_finite()));
-    }
-}

crates/anim/src/transition.rs

@@ -1,18 +1,15 @@
 //! Slide transitions as layers of textured quads.
 //!
 //! A frame is drawn over black: each [`Layer`] maps part of a source image (old slide, new slide,
-//! their backgrounds or contents alone, or a solid colour) onto a quad in slide-unit space (0..1, y
-//! down), with an opacity per corner. Perspective comes from projecting 3-D cards
-//! ([`crate::layer_mesh`] keeps their textures straight); soft edges come from per-corner opacity
-//! ramps; wedges are triangles (4th corner repeats the 3rd).
-//!
-//! The motions, curves, directions and option meanings were measured frame by frame on
-//! PowerPoint's video export of synthetic decks (`plan/powerpoint/tools/synth_transitions.ps1`).
-//! The effects themselves live in [`crate::transition_fx`].
+//! or a solid colour) onto a quad in slide-unit space (0..1, y down). Fake 3-D comes from
+//! trapezoids; wedges are triangles (4th corner repeats the 3rd).
+
+use std::f64::consts::PI;
 
 use serde::{Deserialize, Serialize};
 
 use crate::clampf;
+use crate::easing::smooth;
 
 /// What a layer shows.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -23,35 +20,6 @@ pub enum Source {
     New,
     Black,
     White,
-    /// The outgoing slide's background (background fill plus master and layout graphics) alone.
-    OldBack,
-    /// The incoming slide's background alone.
-    NewBack,
-    /// The outgoing slide's own shapes alone, over transparency.
-    OldContent,
-    /// The incoming slide's own shapes alone, over transparency.
-    NewContent,
-}
-
-impl Source {
-    /// The whole-slide source to draw instead when the parts aren't available: a background
-    /// becomes its slide, content becomes nothing.
-    pub fn whole(self) -> Option<Source> {
-        match self {
-            Source::OldBack => Some(Source::Old),
-            Source::NewBack => Some(Source::New),
-            Source::OldContent | Source::NewContent => None,
-            s => Some(s),
-        }
-    }
-    /// Does this source need the slide rendered in parts (background / content)?
-    pub fn is_part(self) -> bool {
-        matches!(self, Source::OldBack | Source::NewBack | Source::OldContent | Source::NewContent)
-    }
-}
-
-fn ones() -> [f64; 4] {
-    [1.0; 4]
 }
 
 /// One textured quad of a transition frame.
@@ -66,18 +34,12 @@ pub struct Layer {
     /// are the corners of `src`; triangles and mirrored flaps carry their own. Draw with these.
     pub uv: [[f64; 2]; 4],
     pub alpha: f64,
-    /// Opacity of each corner (tl, tr, br, bl), multiplied by `alpha` and interpolated across the
-    /// quad: soft edges and feathered masks.
-    #[serde(default = "ones")]
-    pub fade: [f64; 4],
 }
 
-pub(crate) type R = [f64; 4];
-pub(crate) type P = [f64; 2];
-pub(crate) type Q = [[f64; 2]; 4];
-pub(crate) const FULL: R = [0.0, 0.0, 1.0, 1.0];
+type R = [f64; 4];
+const FULL: R = [0.0, 0.0, 1.0, 1.0];
 
-pub(crate) fn corners(r: R) -> Q {
+fn corners(r: R) -> [[f64; 2]; 4] {
     [[r[0], r[1]], [r[2], r[1]], [r[2], r[3]], [r[0], r[3]]]
 }
 
@@ -88,39 +50,23 @@ impl Layer {
     }
     /// `src` rectangle of the source drawn into the `dst` rectangle.
     pub fn rect(source: Source, src: R, dst: R, alpha: f64) -> Layer {
-        Layer { source, src, quad: corners(dst), uv: corners(src), alpha, fade: ones() }
+        Layer { source, src, quad: corners(dst), uv: corners(src), alpha }
     }
     /// `src` rectangle of the source drawn onto a quad.
-    pub fn quad(source: Source, src: R, quad: Q, alpha: f64) -> Layer {
-        Layer { source, src, quad, uv: corners(src), alpha, fade: ones() }
+    pub fn quad(source: Source, src: R, quad: [[f64; 2]; 4], alpha: f64) -> Layer {
+        Layer { source, src, quad, uv: corners(src), alpha }
     }
     /// The part of the source under `dst` drawn in place.
-    pub(crate) fn inplace(source: Source, dst: R, alpha: f64) -> Layer {
+    fn inplace(source: Source, dst: R, alpha: f64) -> Layer {
         Layer::rect(source, dst, dst, alpha)
     }
-    /// A triangle with its own texture coordinates and corner opacities.
-    pub(crate) fn tri_uv(source: Source, p: [P; 3], uv: [P; 3], fade: [f64; 3], alpha: f64) -> Layer {
-        let xs = [uv[0][0], uv[1][0], uv[2][0]];
-        let ys = [uv[0][1], uv[1][1], uv[2][1]];
+    /// A triangle of the source drawn in place.
+    fn tri(source: Source, a: [f64; 2], b: [f64; 2], c: [f64; 2], alpha: f64) -> Layer {
+        let xs = [a[0], b[0], c[0]];
+        let ys = [a[1], b[1], c[1]];
         let mn = |v: [f64; 3]| v.iter().copied().fold(f64::INFINITY, f64::min);
         let mx = |v: [f64; 3]| v.iter().copied().fold(f64::NEG_INFINITY, f64::max);
-        Layer {
-            source,
-            src: [mn(xs), mn(ys), mx(xs), mx(ys)],
-            quad: [p[0], p[1], p[2], p[2]],
-            uv: [uv[0], uv[1], uv[2], uv[2]],
-            alpha,
-            fade: [fade[0], fade[1], fade[2], fade[2]],
-        }
-    }
-    /// With corner opacities.
-    pub(crate) fn faded(mut self, fade: [f64; 4]) -> Layer {
-        self.fade = fade;
-        self
-    }
-    /// A black copy of this layer's shape at `k` of its opacity: shading a card.
-    pub(crate) fn shade(&self, k: f64) -> Layer {
-        Layer { source: Source::Black, alpha: self.alpha * k.clamp(0.0, 1.0), ..*self }
+        Layer { source, src: [mn(xs), mn(ys), mx(xs), mx(ys)], quad: [a, b, c, c], uv: [a, b, c, c], alpha }
     }
     fn sanitized(mut self) -> Layer {
         let f = |v: f64| if v.is_finite() { v.clamp(-1.0e6, 1.0e6) } else { 0.0 };
@@ -135,48 +81,827 @@ impl Layer {
             c[0] = c[0].clamp(0.0, 1.0);
             c[1] = c[1].clamp(0.0, 1.0);
         }
-        for a in self.fade.iter_mut() {
-            *a = clampf(*a, 0.0, 1.0, 0.0);
-        }
         self.alpha = clampf(self.alpha, 0.0, 1.0, 0.0);
         self
     }
 }
 
-/// Slide aspect assumed by [`transition_layers`] (16:9).
-pub const DEFAULT_ASPECT: f64 = 16.0 / 9.0;
+// ---------- geometry helpers ----------
 
-/// Layers of the transition `kind` (a [`deckcraft_model::anim::TRANSITIONS`] id) with `option` at
-/// progress `t` (0..1) on a 16:9 slide. See [`transition_frame`].
-pub fn transition_layers(kind: &str, option: &str, t: f64) -> Vec<Layer> {
-    transition_frame(kind, option, t, DEFAULT_ASPECT)
+fn offset(r: R, dx: f64, dy: f64) -> R {
+    [r[0] + dx, r[1] + dy, r[2] + dx, r[3] + dy]
 }
 
-/// Layers of the transition `kind` with `option` at linear progress `t` (0..1; the effect applies
-/// its own easing) on a slide `aspect` wide per unit of height. Draw in order over black. At
-/// `t >= 1` the result is the new slide alone; at `t <= 0` (or NaN) the old slide alone. Morph
-/// returns a plain crossfade (the UI renders morph frames with [`crate::morph_frame`]). Layers
-/// with [`Source::is_part`] sources need the slides rendered as background and content
-/// ([`uses_slide_parts`]).
-pub fn transition_frame(kind: &str, option: &str, t: f64, aspect: f64) -> Vec<Layer> {
+fn moved(source: Source, dx: f64, dy: f64, alpha: f64) -> Layer {
+    Layer::rect(source, FULL, offset(FULL, dx, dy), alpha)
+}
+
+/// The whole source scaled about (cx, cy) and moved.
+fn scaled(source: Source, s: f64, cx: f64, cy: f64, dx: f64, dy: f64, alpha: f64) -> Layer {
+    let r = [cx + (0.0 - cx) * s + dx, cy + (0.0 - cy) * s + dy, cx + (1.0 - cx) * s + dx, cy + (1.0 - cy) * s + dy];
+    Layer::rect(source, FULL, r, alpha)
+}
+
+/// Rotate a point about a pivot (degrees).
+fn rot(p: [f64; 2], c: [f64; 2], deg: f64) -> [f64; 2] {
+    let (s, co) = deg.to_radians().sin_cos();
+    let (x, y) = (p[0] - c[0], p[1] - c[1]);
+    [c[0] + x * co - y * s, c[1] + x * s + y * co]
+}
+
+fn rot_quad(q: [[f64; 2]; 4], c: [f64; 2], deg: f64) -> [[f64; 2]; 4] {
+    [rot(q[0], c, deg), rot(q[1], c, deg), rot(q[2], c, deg), rot(q[3], c, deg)]
+}
+
+/// Horizontal perspective: left/right edges shortened by `li`/`ri` (fraction of height, each end).
+fn persp_h(r: R, li: f64, ri: f64) -> [[f64; 2]; 4] {
+    let h = r[3] - r[1];
+    [[r[0], r[1] + li * h], [r[2], r[1] + ri * h], [r[2], r[3] - ri * h], [r[0], r[3] - li * h]]
+}
+
+/// Vertical perspective: top/bottom edges shortened by `ti`/`bi` (fraction of width, each end).
+fn persp_v(r: R, ti: f64, bi: f64) -> [[f64; 2]; 4] {
+    let w = r[2] - r[0];
+    [[r[0] + ti * w, r[1]], [r[2] - ti * w, r[1]], [r[2] - bi * w, r[3]], [r[0] + bi * w, r[3]]]
+}
+
+/// Mirror a rectangle horizontally and/or vertically, or swap its axes (canonical → direction).
+fn map_rect(r: R, mx: bool, my: bool, swap: bool) -> R {
+    let mut r = if swap { [r[1], r[0], r[3], r[2]] } else { r };
+    if mx {
+        r = [1.0 - r[2], r[1], 1.0 - r[0], r[3]];
+    }
+    if my {
+        r = [r[0], 1.0 - r[3], r[2], 1.0 - r[1]];
+    }
+    r
+}
+
+/// Motion direction of an option: l, r, u, d and diagonals.
+fn dir(opt: &str, default: (f64, f64)) -> (f64, f64) {
+    let mut d = (0.0, 0.0);
+    if opt.contains('l') {
+        d.0 = -1.0;
+    }
+    if opt.contains('r') {
+        d.0 = 1.0;
+    }
+    if opt.contains('u') {
+        d.1 = -1.0;
+    }
+    if opt.contains('d') {
+        d.1 = 1.0;
+    }
+    if d == (0.0, 0.0) { default } else { d }
+}
+
+fn hash64(mut x: u64) -> u64 {
+    x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
+    x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+    x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+    x ^ (x >> 31)
+}
+
+/// Deterministic pseudo-random value in [0, 1).
+fn rnd(i: u64) -> f64 {
+    (hash64(i) >> 11) as f64 / (1u64 << 53) as f64
+}
+
+fn ramp(t: f64, order: f64, window: f64) -> f64 {
+    let w = window.clamp(0.01, 1.0);
+    ((t - order * (1.0 - w)) / w).clamp(0.0, 1.0)
+}
+
+fn grid(cols: usize, rows: usize) -> Vec<(usize, usize, R)> {
+    let mut v = Vec::with_capacity(cols * rows);
+    for r in 0..rows {
+        for c in 0..cols {
+            let cell = [c as f64 / cols as f64, r as f64 / rows as f64, (c + 1) as f64 / cols as f64, (r + 1) as f64 / rows as f64];
+            v.push((c, r, cell));
+        }
+    }
+    v
+}
+
+fn center(r: R) -> [f64; 2] {
+    [(r[0] + r[2]) / 2.0, (r[1] + r[3]) / 2.0]
+}
+
+fn scale_rect(r: R, s: f64) -> R {
+    let c = center(r);
+    let hw = (r[2] - r[0]) / 2.0 * s;
+    let hh = (r[3] - r[1]) / 2.0 * s;
+    [c[0] - hw, c[1] - hh, c[0] + hw, c[1] + hh]
+}
+
+// ---------- effects ----------
+
+/// Layers of the transition `kind` (a [`deckcraft_model::anim::TRANSITIONS`] id) with `option` at
+/// progress `t` (0..1). Draw in order over black. At `t >= 1` the result is the new slide alone;
+/// at `t <= 0` (or NaN) the old slide alone. Morph returns a plain crossfade (the UI renders morph
+/// frames with [`crate::morph_frame`]).
+pub fn transition_layers(kind: &str, option: &str, t: f64) -> Vec<Layer> {
     let t = clampf(t, 0.0, 1.0, 0.0);
-    let aspect = if aspect.is_finite() && aspect > 0.01 { aspect.min(100.0) } else { DEFAULT_ASPECT };
     let v = if t >= 1.0 {
         vec![Layer::full(Source::New, 1.0)]
     } else if t <= 0.0 {
         vec![Layer::full(Source::Old, 1.0)]
     } else {
-        crate::transition_fx::layers(kind, option, t, aspect, 0)
+        layers(kind, option, t, 0)
     };
-    v.into_iter().map(Layer::sanitized).filter(|l| l.alpha > 0.0 && l.fade.iter().any(|a| *a > 0.0)).collect()
+    v.into_iter().map(Layer::sanitized).filter(|l| l.alpha > 0.0).collect()
 }
 
-/// Does `kind` animate the slides' backgrounds and contents separately (PowerPoint's Dynamic
-/// Content transitions and Reveal)? Then the frame uses [`Source::OldBack`] & co.
-pub fn uses_slide_parts(kind: &str, option: &str) -> bool {
+fn crossfade(t: f64) -> Vec<Layer> {
+    vec![Layer::full(Source::Old, 1.0), Layer::full(Source::New, t)]
+}
+
+const RANDOM_KINDS: &[&str] = &[
+    "fade",
+    "push",
+    "wipe",
+    "split",
+    "reveal",
+    "randomBar",
+    "shape",
+    "uncover",
+    "cover",
+    "fallOver",
+    "drape",
+    "curtains",
+    "wind",
+    "prestige",
+    "fracture",
+    "crush",
+    "peelOff",
+    "pageCurlDouble",
+    "airplane",
+    "origami",
+    "dissolve",
+    "checker",
+    "blinds",
+    "clock",
+    "ripple",
+    "honeycomb",
+    "glitter",
+    "vortex",
+    "shred",
+    "switch",
+    "flip",
+    "gallery",
+    "cube",
+    "doors",
+    "box",
+    "comb",
+    "zoom",
+    "pan",
+    "ferris",
+    "conveyor",
+    "rotate",
+    "window",
+    "orbit",
+    "flythrough",
+];
+
+fn layers(kind: &str, option: &str, t: f64, depth: u32) -> Vec<Layer> {
+    use Source::{Black, New, Old, White};
+    let o = option;
+    let s = smooth(t);
     match kind {
-        "pan" | "ferris" | "conveyor" | "rotate" | "window" | "orbit" | "flythrough" => true,
-        "reveal" => !option.starts_with("black"),
-        _ => false,
+        "none" => vec![Layer::full(New, 1.0)],
+        "cut" => {
+            if o == "throughBlack" && t < 0.5 {
+                vec![Layer::full(Black, 1.0)]
+            } else {
+                vec![Layer::full(New, 1.0)]
+            }
+        }
+        "fade" if o == "throughBlack" => {
+            if t < 0.5 {
+                vec![Layer::full(Black, 1.0), Layer::full(Old, 1.0 - 2.0 * t)]
+            } else {
+                vec![Layer::full(Black, 1.0), Layer::full(New, 2.0 * t - 1.0)]
+            }
+        }
+        "fade" | "morph" => crossfade(t),
+        "push" | "pan" => {
+            let (dx, dy) = dir(o, (0.0, -1.0));
+            vec![moved(Old, dx * s, dy * s, 1.0), moved(New, dx * (s - 1.0), dy * (s - 1.0), 1.0)]
+        }
+        "uncover" => {
+            let (dx, dy) = dir(o, (-1.0, 0.0));
+            vec![Layer::full(New, 1.0), moved(Old, dx * s, dy * s, 1.0)]
+        }
+        "cover" => {
+            let (dx, dy) = dir(o, (-1.0, 0.0));
+            vec![Layer::full(Old, 1.0), moved(New, dx * (s - 1.0), dy * (s - 1.0), 1.0)]
+        }
+        "wipe" => wipe(o, t),
+        "split" => {
+            let horz = o.starts_with("horz");
+            let mut v = vec![Layer::full(Old, 1.0)];
+            let rects: Vec<R> = if o.ends_with("In") {
+                vec![[0.0, 0.0, s / 2.0, 1.0], [1.0 - s / 2.0, 0.0, 1.0, 1.0]]
+            } else {
+                vec![[0.5 - s / 2.0, 0.0, 0.5 + s / 2.0, 1.0]]
+            };
+            for r in rects {
+                v.push(Layer::inplace(New, map_rect(r, false, false, horz), 1.0));
+            }
+            v
+        }
+        "reveal" => {
+            let dx = if o.ends_with("Right") { 1.0 } else { -1.0 };
+            if o.starts_with("black") {
+                if t < 0.5 {
+                    vec![Layer::full(Black, 1.0), moved(Old, dx * t * 0.4, 0.0, 1.0 - 2.0 * t)]
+                } else {
+                    vec![Layer::full(Black, 1.0), moved(New, -dx * (1.0 - t) * 0.2, 0.0, 2.0 * t - 1.0)]
+                }
+            } else {
+                vec![Layer::full(New, 1.0), moved(Old, dx * s * 0.6, 0.0, 1.0 - t)]
+            }
+        }
+        "randomBar" => {
+            let horz = o == "horz";
+            let n = 48;
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for i in 0..n {
+                if t > rnd(i as u64 + 17) * 0.98 {
+                    let r = [i as f64 / n as f64, 0.0, (i + 1) as f64 / n as f64, 1.0];
+                    v.push(Layer::inplace(New, map_rect(r, false, false, horz), 1.0));
+                }
+            }
+            v
+        }
+        "shape" => {
+            let form = match o {
+                "circle" | "diamond" | "plus" => o,
+                _ => "box",
+            };
+            let inward = o == "in";
+            if inward {
+                let mut v = vec![Layer::full(New, 1.0)];
+                v.extend(shape_form(Old, form, 1.0 - s));
+                v
+            } else {
+                let mut v = vec![Layer::full(Old, 1.0)];
+                v.extend(shape_form(New, form, s));
+                v
+            }
+        }
+        "flash" => {
+            if t < 0.5 {
+                vec![Layer::full(Old, 1.0), Layer::full(White, (2.0 * t).min(1.0))]
+            } else {
+                vec![Layer::full(New, 1.0), Layer::full(White, 2.0 - 2.0 * t)]
+            }
+        }
+        "fallOver" => {
+            let sg = if o == "r" { 1.0 } else { -1.0 };
+            let a = t * t * PI / 2.0;
+            let top = 1.0 - a.cos();
+            let ins = 0.12 * a.sin();
+            let sh = sg * 0.15 * a.sin();
+            let q = [[ins + sh, top], [1.0 - ins + sh, top], [1.0, 1.0], [0.0, 1.0]];
+            vec![Layer::full(New, 1.0), Layer::quad(Old, FULL, q, 1.0 - t.powi(3))]
+        }
+        "drape" => {
+            let k = t * t;
+            let q = [[0.0, 0.0], [1.0 - 0.3 * k, k], [1.0 - 0.3 * k, 1.0 + k], [0.0, 1.0]];
+            let q = if o == "r" { mirror_q(q) } else { q };
+            vec![Layer::full(New, 1.0), Layer::quad(Old, FULL, q, 1.0 - k)]
+        }
+        "curtains" => {
+            let w = 0.5 * (1.0 - s);
+            let lq = [[0.0, 0.0], [w, 0.12 * s], [w, 1.0 - 0.12 * s], [0.0, 1.0]];
+            let rq = [[1.0 - w, 0.12 * s], [1.0, 0.0], [1.0, 1.0], [1.0 - w, 1.0 - 0.12 * s]];
+            vec![
+                scaled(New, 0.9 + 0.1 * s, 0.5, 0.5, 0.0, 0.0, 1.0),
+                Layer::quad(Old, [0.0, 0.0, 0.5, 1.0], lq, 1.0),
+                Layer::quad(Old, [0.5, 0.0, 1.0, 1.0], rq, 1.0),
+            ]
+        }
+        "wind" => {
+            let d = if o == "r" { 1.0 } else { -1.0 };
+            let r = offset(FULL, d * 1.2 * s, -0.1 * s);
+            let q = [[r[0] + d * 0.2 * s, r[1]], [r[2] + d * 0.2 * s, r[1]], [r[2], r[3]], [r[0], r[3]]];
+            vec![moved(New, -d * 0.3 * (1.0 - s), 0.0, smooth((t * 1.5).min(1.0))), Layer::quad(Old, FULL, q, 1.0 - t)]
+        }
+        "prestige" => vec![scaled(Old, 1.0 - 0.3 * s, 0.5, 0.5, 0.0, 0.2 * s, 1.0 - t), scaled(New, 0.7 + 0.3 * s, 0.5, 0.5, 0.0, 0.0, s)],
+        "fracture" => {
+            let mut v = vec![Layer::full(New, 1.0)];
+            for (c, r, cell) in grid(8, 6) {
+                let i = (r * 8 + c) as u64;
+                let q = ramp(t, rnd(i + 101) * 0.5, 0.5);
+                let cc = center(cell);
+                let (dx, dy) = ((cc[0] - 0.5) * 1.5 * q, (cc[1] - 0.5) * 1.5 * q + 0.5 * q * q);
+                let quad = rot_quad(corners(offset(cell, dx, dy)), [cc[0] + dx, cc[1] + dy], (rnd(i + 7) - 0.5) * 180.0 * q);
+                v.push(Layer::quad(Old, cell, quad, 1.0 - q));
+            }
+            v
+        }
+        "crush" => {
+            let mut v = vec![Layer::full(New, 1.0)];
+            for (c, r, cell) in grid(4, 4) {
+                let i = (r * 4 + c) as u64;
+                let cc = center(cell);
+                let k = 1.0 - s;
+                let pos = [0.5 + (cc[0] - 0.5) * k, 0.5 + (cc[1] - 0.5) * k];
+                let half = scale_rect(cell, k * (0.8 + 0.2 * rnd(i + 3)));
+                let half = offset(half, pos[0] - cc[0], pos[1] - cc[1]);
+                let quad = rot_quad(corners(half), pos, (rnd(i + 5) - 0.5) * 60.0 * s);
+                v.push(Layer::quad(Old, cell, quad, 1.0 - t * t));
+            }
+            v
+        }
+        "peelOff" => {
+            let mut v = vec![Layer::full(New, 1.0)];
+            v.extend(peel(Old, [0.0, 0.0, 1.0, 1.0], s, o == "r"));
+            v
+        }
+        "pageCurlDouble" => {
+            let mut v = vec![Layer::full(New, 1.0)];
+            let left_first = o != "r";
+            v.extend(peel(Old, [0.0, 0.0, 0.5, 1.0], s, !left_first));
+            v.extend(peel(Old, [0.5, 0.0, 1.0, 1.0], s, left_first));
+            v
+        }
+        "airplane" => {
+            let d = if o == "r" { 1.0 } else { -1.0 };
+            let k = 1.0 - 0.8 * s;
+            let r = offset(scale_rect(FULL, k), d * 1.2 * s * s, -0.5 * s * s);
+            let q = persp_h(r, if d > 0.0 { 0.3 * s } else { 0.0 }, if d > 0.0 { 0.0 } else { 0.3 * s });
+            vec![Layer::full(New, 1.0), Layer::quad(Old, FULL, q, 1.0 - t * t)]
+        }
+        "origami" => {
+            let d = if o == "r" { 1.0 } else { -1.0 };
+            let mut v = vec![Layer::full(New, 1.0)];
+            if t < 0.5 {
+                let f = t * 2.0;
+                let w = 0.5 * (1.0 - 0.8 * f);
+                v.push(Layer::quad(Old, [0.0, 0.0, 0.5, 1.0], persp_h([0.5 - w, 0.0, 0.5, 1.0], 0.15 * f, 0.0), 1.0));
+                v.push(Layer::quad(Old, [0.5, 0.0, 1.0, 1.0], persp_h([0.5, 0.0, 0.5 + w, 1.0], 0.0, 0.15 * f), 1.0));
+            } else {
+                let f = (t - 0.5) * 2.0;
+                let r = offset(scale_rect([0.4, 0.0, 0.6, 1.0], 1.0 - 0.6 * f), d * f * 0.8, -0.3 * f);
+                v.push(Layer::quad(Old, FULL, persp_v(r, 0.1, 0.0), 1.0 - f));
+            }
+            v
+        }
+        "dissolve" => {
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for (c, r, cell) in grid(32, 18) {
+                if t > rnd((r * 32 + c) as u64 + 991) * 0.98 {
+                    v.push(Layer::inplace(New, cell, 1.0));
+                }
+            }
+            v
+        }
+        "checker" => {
+            let vert = o == "vert";
+            let (n, m) = (10usize, 8usize);
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for (c, r, cell) in grid(n, m) {
+                let across = if vert { c } else { r };
+                let f = (t * 2.0 - (across % 2) as f64 * 0.5).clamp(0.0, 1.0);
+                if f <= 0.0 {
+                    continue;
+                }
+                let rc = if vert {
+                    [cell[0], cell[1], cell[2], cell[1] + (cell[3] - cell[1]) * f]
+                } else {
+                    [cell[0], cell[1], cell[0] + (cell[2] - cell[0]) * f, cell[3]]
+                };
+                v.push(Layer::inplace(New, rc, 1.0));
+            }
+            v
+        }
+        "blinds" => {
+            let horz = o == "horz";
+            let n = 8;
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for i in 0..n {
+                let x0 = i as f64 / n as f64;
+                let r = [x0, 0.0, x0 + s / n as f64, 1.0];
+                v.push(Layer::inplace(New, map_rect(r, false, false, horz), 1.0));
+            }
+            v
+        }
+        "clock" => clock(o, s),
+        "ripple" => {
+            let origin = match o {
+                "lu" => [0.0, 0.0],
+                "ru" => [1.0, 0.0],
+                "ld" => [0.0, 1.0],
+                "rd" => [1.0, 1.0],
+                _ => [0.5, 0.5],
+            };
+            let maxd = if origin == [0.5, 0.5] { 0.71 } else { 1.42 };
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for (_, _, cell) in grid(24, 14) {
+                let cc = center(cell);
+                let d = ((cc[0] - origin[0]).powi(2) + (cc[1] - origin[1]).powi(2)).sqrt() / maxd;
+                let a = ramp(t, d.min(1.0), 0.3);
+                if a > 0.0 {
+                    let sc = 1.0 + 0.15 * (a * PI).sin();
+                    v.push(Layer::rect(New, cell, scale_rect(cell, sc), a));
+                }
+            }
+            v
+        }
+        "honeycomb" => {
+            let (cols, rows) = (12usize, 8usize);
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for c in 0..cols {
+                let odd = c % 2 == 1;
+                let extra = if odd { 1 } else { 0 };
+                for r in 0..rows + extra {
+                    let y0 = (r as f64 - if odd { 0.5 } else { 0.0 }) / rows as f64;
+                    let cell = [c as f64 / cols as f64, y0.max(0.0), (c + 1) as f64 / cols as f64, (y0 + 1.0 / rows as f64).min(1.0)];
+                    let a = ramp(t, rnd((c * 64 + r) as u64 + 4242), 0.35);
+                    if a > 0.0 {
+                        v.push(Layer::rect(New, cell, scale_rect(cell, 0.3 + 0.7 * a), a));
+                    }
+                }
+            }
+            v
+        }
+        "glitter" => {
+            let (dx, dy) = dir(o, (-1.0, 0.0));
+            let mut v = vec![Layer::full(Old, 1.0)];
+            for (c, r, cell) in grid(20, 12) {
+                let cc = center(cell);
+                let grad = if dx < 0.0 {
+                    1.0 - cc[0]
+                } else if dx > 0.0 {
+                    cc[0]
+                } else if dy < 0.0 {
+                    1.0 - cc[1]
+                } else {
+                    cc[1]
+                };
+                let order = 0.6 * grad + 0.4 * rnd((r * 20 + c) as u64 + 77);
+                let a = ramp(t, order, 0.25);
+                if a > 0.0 {
+                    let quad = rot_quad(corners(cell), cc, (1.0 - a) * 90.0);
+                    v.push(Layer::quad(New, cell, quad, a));
+                }
+            }
+            v
+        }
+        "vortex" => {
+            let (dx, dy) = dir(o, (-1.0, 0.0));
+            let mut v = vec![Layer::full(New, 1.0)];
+            for (c, r, cell) in grid(16, 9) {
+                let i = (r * 16 + c) as u64;
+                let cc = center(cell);
+                let grad = 0.5 + 0.5 * ((cc[0] - 0.5) * -dx + (cc[1] - 0.5) * -dy);
+                let q = ramp(t, 0.5 * grad + 0.5 * rnd(i + 31), 0.4);
+                let ang = q * 2.0 * PI + rnd(i) * PI;
+                let rad = q * 1.2;
+                let (ox, oy) = (dx * q * 0.8 + rad * ang.cos() * 0.3, dy * q * 0.8 + rad * ang.sin() * 0.3);
+                let pos = [cc[0] + ox, cc[1] + oy];
+                let quad = rot_quad(corners(offset(scale_rect(cell, 1.0 - 0.5 * q), ox, oy)), pos, q * 360.0);
+                v.push(Layer::quad(Old, cell, quad, 1.0 - q));
+            }
+            v
+        }
+        "shred" => {
+            let mut v = vec![Layer::full(New, 1.0)];
+            if o == "particles" {
+                for (c, r, cell) in grid(24, 14) {
+                    let i = (r * 24 + c) as u64;
+                    let q = ramp(t, rnd(i + 555) * 0.6 + 0.4 * (1.0 - center(cell)[1]), 0.4);
+                    let dy = q * q * 1.2;
+                    let dx = (rnd(i + 9) - 0.5) * 0.3 * q;
+                    v.push(Layer::rect(Old, cell, offset(scale_rect(cell, 1.0 - 0.6 * q), dx, dy), 1.0 - q));
+                }
+            } else {
+                let n = 16;
+                for i in 0..n {
+                    let x0 = i as f64 / n as f64;
+                    let x1 = (i + 1) as f64 / n as f64;
+                    let q = ramp(t, i as f64 / n as f64 * 0.3 + 0.1 * rnd(i as u64), 0.7);
+                    let dy = if i % 2 == 0 { 1.1 * q * q } else { -1.1 * q * q };
+                    v.push(Layer::rect(Old, [x0, 0.0, x1, 1.0], [x0, dy, x1, 1.0 + dy], 1.0));
+                }
+            }
+            v
+        }
+        "switch" => {
+            let d = if o == "r" { 1.0 } else { -1.0 };
+            let k = (t * PI).sin();
+            let old = Layer::quad(
+                Old,
+                FULL,
+                persp_h(
+                    offset(scale_rect(FULL, 1.0 - 0.25 * t), d * 0.45 * k, 0.0),
+                    if d > 0.0 { 0.0 } else { 0.08 * k },
+                    if d > 0.0 { 0.08 * k } else { 0.0 },
+                ),
+                1.0,
+            );
+            let new = Layer::quad(
+                New,
+                FULL,
+                persp_h(
+                    offset(scale_rect(FULL, 0.75 + 0.25 * t), -d * 0.45 * k, 0.0),
+                    if d > 0.0 { 0.08 * k } else { 0.0 },
+                    if d > 0.0 { 0.0 } else { 0.08 * k },
+                ),
+                1.0,
+            );
+            if t < 0.5 { vec![new, old] } else { vec![old, new] }
+        }
+        "flip" => {
+            let a = PI * s;
+            let w = a.cos().abs();
+            let k = 0.1 * a.sin();
+            let r = [0.5 - w / 2.0, 0.0, 0.5 + w / 2.0, 1.0];
+            let right = o != "l";
+            if t < 0.5 {
+                let q = if right { persp_h(r, -k / 2.0, k) } else { persp_h(r, k, -k / 2.0) };
+                vec![Layer::quad(Old, FULL, q, 1.0)]
+            } else {
+                let q = if right { persp_h(r, k, -k / 2.0) } else { persp_h(r, -k / 2.0, k) };
+                vec![Layer::quad(New, FULL, q, 1.0)]
+            }
+        }
+        "gallery" | "conveyor" => {
+            let d = if o == "r" { 1.0 } else { -1.0 };
+            let k = (s * PI).sin();
+            let sc = 1.0 - if kind == "gallery" { 0.25 } else { 0.1 } * k;
+            let gap = if kind == "gallery" { 1.15 } else { 1.05 };
+            let old = offset(scale_rect(FULL, sc), d * s * gap, 0.0);
+            let new = offset(scale_rect(FULL, sc), d * (s - 1.0) * gap, 0.0);
+            let p = 0.08 * k;
+            vec![
+                Layer::quad(Old, FULL, if d > 0.0 { persp_h(old, 0.0, p) } else { persp_h(old, p, 0.0) }, 1.0),
+                Layer::quad(New, FULL, if d > 0.0 { persp_h(new, p, 0.0) } else { persp_h(new, 0.0, p) }, 1.0),
+            ]
+        }
+        "cube" | "box" | "rotate" => {
+            let (dx, dy) = dir(o, (-1.0, 0.0));
+            let vertical = dy != 0.0 && dx == 0.0;
+            let neg = if vertical { dy < 0.0 } else { dx < 0.0 };
+            let k = (s * PI).sin();
+            let (far_old, far_new, shared) = match kind {
+                "cube" => (0.18 * s, 0.18 * (1.0 - s), 0.05 * k),
+                "box" => (0.0, 0.0, 0.18 * k),
+                _ => (0.25 * s, 0.25 * (1.0 - s), 0.0),
+            };
+            // Canonical: moving toward -x; old on the left [0, 1-s], new on the right [1-s, 1].
+            let split = 1.0 - s;
+            let (old_q, new_q) = if kind == "rotate" {
+                if t < 0.5 {
+                    (Some(canon_q([0.0, 0.0, (1.0 - 2.0 * t).max(0.0), 1.0], far_old, 0.0)), None)
+                } else {
+                    (None, Some(canon_q([1.0 - (2.0 * t - 1.0), 0.0, 1.0, 1.0], 0.0, far_new)))
+                }
+            } else {
+                (Some(canon_q([0.0, 0.0, split, 1.0], far_old, shared)), Some(canon_q([split, 0.0, 1.0, 1.0], shared, far_new)))
+            };
+            let fix = |q: [[f64; 2]; 4]| -> [[f64; 2]; 4] {
+                let q = if neg { q } else { mirror_q(q) };
+                if vertical { swap_q(q) } else { q }
+            };
+            let mut v = vec![Layer::full(Black, 1.0)];
+            if let Some(q) = old_q {
+                v.push(Layer::quad(Old, FULL, fix(q), 1.0));
+            }
+            if let Some(q) = new_q {
+                v.push(Layer::quad(New, FULL, fix(q), 1.0));
+            }
+            v
+        }
+        "doors" | "window" => {
+            let horz = o == "horz";
+            let (zoom0, persp) = if kind == "doors" { (0.85, 0.1) } else { (0.6, 0.2) };
+            let w = 0.5 * (1.0 - s);
+            let k = persp * s;
+            let left = [[0.0, 0.0], [w, -k], [w, 1.0 + k], [0.0, 1.0]];
+            let right = [[1.0 - w, -k], [1.0, 0.0], [1.0, 1.0], [1.0 - w, 1.0 + k]];
+            let (l, r) = if horz { (swap_q(left), swap_q(right)) } else { (left, right) };
+            let (sl, sr) = if horz { ([0.0, 0.0, 1.0, 0.5], [0.0, 0.5, 1.0, 1.0]) } else { ([0.0, 0.0, 0.5, 1.0], [0.5, 0.0, 1.0, 1.0]) };
+            vec![scaled(New, zoom0 + (1.0 - zoom0) * s, 0.5, 0.5, 0.0, 0.0, s.max(0.2)), Layer::quad(Old, sl, l, 1.0), Layer::quad(Old, sr, r, 1.0)]
+        }
+        "comb" => {
+            let vert = o == "vert";
+            let n = 8;
+            let mut v = Vec::new();
+            for i in 0..n {
+                let a = i as f64 / n as f64;
+                let b = (i + 1) as f64 / n as f64;
+                let d = if i % 2 == 0 { 1.0 } else { -1.0 };
+                let band = if vert { [a, 0.0, b, 1.0] } else { [0.0, a, 1.0, b] };
+                let (ox, oy) = if vert { (0.0, d * s) } else { (d * s, 0.0) };
+                let (nx, ny) = if vert { (0.0, -d * (1.0 - s)) } else { (-d * (1.0 - s), 0.0) };
+                v.push(Layer::rect(Old, band, offset(band, ox, oy), 1.0));
+                v.push(Layer::rect(New, band, offset(band, nx, ny), 1.0));
+            }
+            v
+        }
+        "zoom" => {
+            if o == "out" {
+                vec![scaled(New, 1.5 - 0.5 * s, 0.5, 0.5, 0.0, 0.0, s), scaled(Old, 1.0 - 0.7 * s, 0.5, 0.5, 0.0, 0.0, 1.0 - t)]
+            } else {
+                vec![scaled(Old, 1.0 + s, 0.5, 0.5, 0.0, 0.0, 1.0 - t), scaled(New, s.max(0.01), 0.5, 0.5, 0.0, 0.0, s)]
+            }
+        }
+        "orbit" => {
+            let (dx, dy) = dir(o, (-1.0, 0.0));
+            let k = (s * PI).sin();
+            let old = scaled(Old, 1.0 - 0.4 * k, 0.5, 0.5, dx * s + dy.abs() * 0.15 * k, dy * s + dx.abs() * 0.15 * k, 1.0 - 0.5 * s);
+            let new = scaled(New, 1.0 - 0.4 * k, 0.5, 0.5, dx * (s - 1.0) - dy.abs() * 0.15 * k, dy * (s - 1.0) - dx.abs() * 0.15 * k, 0.5 + 0.5 * s);
+            if t < 0.5 { vec![new, old] } else { vec![old, new] }
+        }
+        "flythrough" => {
+            let bounce = o.ends_with("Bounce");
+            let ns = |base: f64| if bounce { base + 0.08 * (s * PI).sin() } else { base };
+            if o.starts_with("out") {
+                vec![scaled(Old, 1.0 - 0.5 * s, 0.5, 0.5, 0.0, 0.0, 1.0 - t), scaled(New, ns(1.5 - 0.5 * s), 0.5, 0.5, 0.0, 0.0, s)]
+            } else {
+                vec![scaled(New, ns(0.5 + 0.5 * s), 0.5, 0.5, 0.0, 0.0, s), scaled(Old, 1.0 + 1.5 * s, 0.5, 0.5, 0.0, 0.0, 1.0 - t)]
+            }
+        }
+        "ferris" => {
+            let d = if o == "r" { 1.0 } else { -1.0 };
+            let pivot = [0.5, 2.5];
+            let a = 50.0 * s * d;
+            let oq = rot_quad(corners(FULL), pivot, a);
+            let nq = rot_quad(corners(FULL), pivot, a - 50.0 * d);
+            vec![Layer::quad(Old, FULL, oq, 1.0), Layer::quad(New, FULL, nq, 1.0)]
+        }
+        "random" if depth == 0 => {
+            let h = option.bytes().fold(0x51ED_u64, |h, b| hash64(h ^ b as u64));
+            let k = RANDOM_KINDS.get((h % RANDOM_KINDS.len() as u64) as usize).copied().unwrap_or("fade");
+            let opt = deckcraft_model::anim::TRANSITIONS.iter().find(|x| x.0 == k).and_then(|x| x.4.first().copied()).unwrap_or("");
+            layers(k, opt, t, depth + 1)
+        }
+        _ => crossfade(t),
     }
 }
+
+fn mirror_q(q: [[f64; 2]; 4]) -> [[f64; 2]; 4] {
+    // Mirror x and keep the tl, tr, br, bl order (swap left/right corners).
+    let m = |p: [f64; 2]| [1.0 - p[0], p[1]];
+    [m(q[1]), m(q[0]), m(q[3]), m(q[2])]
+}
+
+fn swap_q(q: [[f64; 2]; 4]) -> [[f64; 2]; 4] {
+    // Transpose x/y; corners reordered so tl, tr, br, bl still map to the source's corners.
+    let s = |p: [f64; 2]| [p[1], p[0]];
+    [s(q[0]), s(q[3]), s(q[2]), s(q[1])]
+}
+
+fn canon_q(r: R, left_inset: f64, right_inset: f64) -> [[f64; 2]; 4] {
+    persp_h(r, left_inset, right_inset)
+}
+
+fn wipe(o: &str, t: f64) -> Vec<Layer> {
+    let mut v = vec![Layer::full(Source::Old, 1.0)];
+    let diag = o.len() == 2;
+    if diag {
+        // Diagonal: columns revealed by a slanted edge.
+        let (mx, my) = (o.contains('l'), o.contains('u'));
+        let n = 32;
+        for i in 0..n {
+            let x0 = i as f64 / n as f64;
+            let x1 = (i + 1) as f64 / n as f64;
+            let h = (2.0 * t - (x0 + x1) / 2.0).clamp(0.0, 1.0);
+            if h > 0.0 {
+                v.push(Layer::inplace(Source::New, map_rect([x0, 0.0, x1, h], mx, my, false), 1.0));
+            }
+        }
+        return v;
+    }
+    let (mx, swap) = match o {
+        "l" => (true, false),
+        "d" => (false, true),
+        "u" => (true, true),
+        _ => (false, false),
+    };
+    let soft = 0.15;
+    let e = t * (1.0 + soft);
+    let solid = (e - soft).clamp(0.0, 1.0);
+    if solid > 0.0 {
+        v.push(Layer::inplace(Source::New, map_rect([0.0, 0.0, solid, 1.0], mx, false, swap), 1.0));
+    }
+    let n = 6;
+    for k in 0..n {
+        let a = e - soft + soft * k as f64 / n as f64;
+        let b = e - soft + soft * (k + 1) as f64 / n as f64;
+        let (a, b) = (a.clamp(0.0, 1.0), b.clamp(0.0, 1.0));
+        if b > a {
+            let alpha = 1.0 - (k as f64 + 0.5) / n as f64;
+            v.push(Layer::inplace(Source::New, map_rect([a, 0.0, b, 1.0], mx, false, swap), alpha));
+        }
+    }
+    v
+}
+
+/// A centred shape of the source at size `f` (0 = nothing, 1 = covers the slide), as strips.
+fn shape_form(src: Source, form: &str, f: f64) -> Vec<Layer> {
+    let f = f.clamp(0.0, 1.0);
+    if f <= 0.0 {
+        return vec![];
+    }
+    match form {
+        "plus" => {
+            let h = f / 2.0;
+            vec![Layer::inplace(src, [0.0, 0.5 - h, 1.0, 0.5 + h], 1.0), Layer::inplace(src, [0.5 - h, 0.0, 0.5 + h, 1.0], 1.0)]
+        }
+        "circle" | "diamond" => {
+            let n = 40;
+            let r = if form == "circle" { f * 0.75 } else { f * 1.02 };
+            let mut v = Vec::new();
+            for i in 0..n {
+                let y0 = i as f64 / n as f64;
+                let y1 = (i + 1) as f64 / n as f64;
+                let dy = ((y0 + y1) / 2.0 - 0.5).abs();
+                let half = if form == "circle" { if r > dy { (r * r - dy * dy).sqrt() } else { 0.0 } } else { r - dy };
+                if half > 0.0 {
+                    let half = half.min(0.5);
+                    v.push(Layer::inplace(src, [0.5 - half, y0, 0.5 + half, y1], 1.0));
+                }
+            }
+            v
+        }
+        _ => vec![Layer::inplace(src, scale_rect(FULL, f), 1.0)],
+    }
+}
+
+/// A peeling page: the part of `area` not yet peeled stays, the peeled part shows as a mirrored flap.
+fn peel(src: Source, area: R, s: f64, toward_right: bool) -> Vec<Layer> {
+    let w = area[2] - area[0];
+    let p = s * w;
+    if toward_right {
+        let edge = area[0] + p;
+        let stay = [edge, area[1], area[2], area[3]];
+        let flap_src = [area[0], area[1], edge, area[3]];
+        let x2 = edge + p;
+        let flap = Layer {
+            source: src,
+            src: flap_src,
+            quad: [[x2, area[1]], [edge, area[1]], [edge, area[3]], [x2, area[3]]],
+            uv: corners(flap_src),
+            alpha: 0.85,
+        };
+        vec![Layer::inplace(src, stay, 1.0), flap]
+    } else {
+        let edge = area[2] - p;
+        let stay = [area[0], area[1], edge, area[3]];
+        let flap_src = [edge, area[1], area[2], area[3]];
+        let x2 = edge - p;
+        let flap = Layer {
+            source: src,
+            src: flap_src,
+            quad: [[edge, area[1]], [x2, area[1]], [x2, area[3]], [edge, area[3]]],
+            uv: corners(flap_src),
+            alpha: 0.85,
+        };
+        vec![Layer::inplace(src, stay, 1.0), flap]
+    }
+}
+
+/// Point on the unit square's boundary seen from the centre at angle `a` (radians, clockwise from
+/// 12 o'clock).
+fn boundary(a: f64) -> [f64; 2] {
+    let (dx, dy) = (a.sin(), -a.cos());
+    let m = dx.abs().max(dy.abs()).max(1e-9);
+    [0.5 + 0.5 * dx / m, 0.5 + 0.5 * dy / m]
+}
+
+fn clock(o: &str, s: f64) -> Vec<Layer> {
+    let mut v = vec![Layer::full(Source::Old, 1.0)];
+    let c = [0.5, 0.5];
+    let sweep = s * 2.0 * PI;
+    let (a0, a1) = match o {
+        "counterClockwise" => (-sweep, 0.0),
+        "wedge" => (-sweep / 2.0, sweep / 2.0),
+        _ => (0.0, sweep),
+    };
+    let span = a1 - a0;
+    if span <= 0.0 {
+        return v;
+    }
+    let n = ((span / (PI / 24.0)).ceil() as usize).clamp(1, 96);
+    let mut angles: Vec<f64> = (0..=n).map(|k| a0 + span * k as f64 / n as f64).collect();
+    // Square corners inside the sweep, so the fan reaches them.
+    for k in -8i32..=8 {
+        let a = PI / 4.0 + k as f64 * PI / 2.0;
+        if a > a0 && a < a1 {
+            angles.push(a);
+        }
+    }
+    angles.sort_by(f64::total_cmp);
+    for w in angles.windows(2) {
+        if let [x, y] = w
+            && y > x
+        {
+            v.push(Layer::tri(Source::New, c, boundary(*x), boundary(*y), 1.0));
+        }
+    }
+    v
+}

crates/anim/src/transition_geom.rs

@@ -1,382 +0,0 @@
-//! Geometry for transition effects: easing, 3-D cards, opacity fields, polygons.
-
-use std::f64::consts::PI;
-
-use crate::easing::{ease, smooth};
-use crate::transition::{FULL, Layer, P, Q, R, Source, corners};
-
-// ---------- easing ----------
-
-/// Smoothstep ease in-out (PowerPoint's fades).
-pub(crate) fn ss(x: f64) -> f64 {
-    smooth(x)
-}
-
-/// Quadratic ease in-out: velocity ramps up for the first half and down for the second
-/// (PowerPoint's moves: Push, Cover, Uncover, Pan…).
-pub(crate) fn q2(x: f64) -> f64 {
-    ease(x, 0.5, 0.5, 0.0)
-}
-
-/// Power ease in-out of degree `n` (2: quadratic, 3: cubic, 4: quartic).
-pub(crate) fn pow_inout(x: f64, n: f64) -> f64 {
-    let x = x.clamp(0.0, 1.0);
-    if x < 0.5 { 0.5 * (2.0 * x).powf(n) } else { 1.0 - 0.5 * (2.0 - 2.0 * x).powf(n) }
-}
-
-/// Quadratic ease-in.
-pub(crate) fn ein(x: f64) -> f64 {
-    let x = x.clamp(0.0, 1.0);
-    x * x
-}
-
-/// Quadratic ease-out.
-pub(crate) fn eout(x: f64) -> f64 {
-    let x = 1.0 - x.clamp(0.0, 1.0);
-    1.0 - x * x
-}
-
-/// Progress through the window [a, b] of t, clamped to 0..1.
-pub(crate) fn win(t: f64, a: f64, b: f64) -> f64 {
-    if b <= a {
-        return if t >= b { 1.0 } else { 0.0 };
-    }
-    ((t - a) / (b - a)).clamp(0.0, 1.0)
-}
-
-// ---------- randomness ----------
-
-pub(crate) fn hash64(mut x: u64) -> u64 {
-    x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
-    x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
-    x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
-    x ^ (x >> 31)
-}
-
-/// Deterministic pseudo-random value in [0, 1).
-pub(crate) fn rnd(i: u64) -> f64 {
-    (hash64(i) >> 11) as f64 / (1u64 << 53) as f64
-}
-
-// ---------- 2-D ----------
-
-pub(crate) fn offset(r: R, dx: f64, dy: f64) -> R {
-    [r[0] + dx, r[1] + dy, r[2] + dx, r[3] + dy]
-}
-
-pub(crate) fn center(r: R) -> P {
-    [(r[0] + r[2]) / 2.0, (r[1] + r[3]) / 2.0]
-}
-
-pub(crate) fn scale_rect(r: R, s: f64) -> R {
-    scale_rect_about(r, s, center(r))
-}
-
-pub(crate) fn scale_rect_about(r: R, s: f64, c: P) -> R {
-    [c[0] + (r[0] - c[0]) * s, c[1] + (r[1] - c[1]) * s, c[0] + (r[2] - c[0]) * s, c[1] + (r[3] - c[1]) * s]
-}
-
-/// The whole source moved by (dx, dy).
-pub(crate) fn moved(source: Source, dx: f64, dy: f64, alpha: f64) -> Layer {
-    Layer::rect(source, FULL, offset(FULL, dx, dy), alpha)
-}
-
-/// The whole source scaled by `s` about (cx, cy) and moved.
-pub(crate) fn scaled(source: Source, s: f64, cx: f64, cy: f64, dx: f64, dy: f64, alpha: f64) -> Layer {
-    Layer::rect(source, FULL, offset(scale_rect_about(FULL, s, [cx, cy]), dx, dy), alpha)
-}
-
-/// Rotate a point about a pivot by `deg` (clockwise on screen), in a slide `a` wide per unit of
-/// height, so angles and shapes stay true.
-pub(crate) fn rot(p: P, c: P, deg: f64, a: f64) -> P {
-    let (s, co) = deg.to_radians().sin_cos();
-    let (x, y) = ((p[0] - c[0]) * a, p[1] - c[1]);
-    [c[0] + (x * co - y * s) / a, c[1] + x * s + y * co]
-}
-
-pub(crate) fn rot_quad(q: Q, c: P, deg: f64, a: f64) -> Q {
-    [rot(q[0], c, deg, a), rot(q[1], c, deg, a), rot(q[2], c, deg, a), rot(q[3], c, deg, a)]
-}
-
-/// Motion direction of an option: l, r, u, d and diagonals.
-pub(crate) fn dir(opt: &str, default: (f64, f64)) -> (f64, f64) {
-    let mut d = (0.0, 0.0);
-    if opt.contains('l') {
-        d.0 = -1.0;
-    }
-    if opt.contains('r') {
-        d.0 = 1.0;
-    }
-    if opt.contains('u') {
-        d.1 = -1.0;
-    }
-    if opt.contains('d') {
-        d.1 = 1.0;
-    }
-    if d == (0.0, 0.0) { default } else { d }
-}
-
-/// A rectangle with a soft border `f` wide (slide units) fading out to nothing: the rectangle at
-/// full opacity, four edge ramps and four corner ramps. `src` maps onto `dst`; the border samples
-/// the texture's edge.
-pub(crate) fn soft_rect(source: Source, src: R, dst: R, f: f64, alpha: f64) -> Vec<Layer> {
-    let mut v = vec![Layer::rect(source, src, dst, alpha)];
-    if f <= 1e-6 {
-        return v;
-    }
-    let (l, t, r, b) = (dst[0], dst[1], dst[2], dst[3]);
-    let (fx, fy) = (f, f * 16.0 / 9.0);
-    let uv_at = |x: f64, y: f64| -> P {
-        let u = if r > l { src[0] + (x.clamp(l, r) - l) / (r - l) * (src[2] - src[0]) } else { src[0] };
-        let w = if b > t { src[1] + (y.clamp(t, b) - t) / (b - t) * (src[3] - src[1]) } else { src[1] };
-        [u, w]
-    };
-    let mut q = |pts: Q, fade: [f64; 4]| {
-        let uv = pts.map(|p| uv_at(p[0], p[1]));
-        let xs = uv.map(|p| p[0]);
-        let ys = uv.map(|p| p[1]);
-        let mn = |a: [f64; 4]| a.iter().copied().fold(f64::INFINITY, f64::min);
-        let mx = |a: [f64; 4]| a.iter().copied().fold(f64::NEG_INFINITY, f64::max);
-        v.push(Layer { source, src: [mn(xs), mn(ys), mx(xs), mx(ys)], quad: pts, uv, alpha, fade });
-    };
-    q([[l, t - fy], [r, t - fy], [r, t], [l, t]], [0.0, 0.0, 1.0, 1.0]);
-    q([[l, b], [r, b], [r, b + fy], [l, b + fy]], [1.0, 1.0, 0.0, 0.0]);
-    q([[l - fx, t], [l, t], [l, b], [l - fx, b]], [0.0, 1.0, 1.0, 0.0]);
-    q([[r, t], [r + fx, t], [r + fx, b], [r, b]], [1.0, 0.0, 0.0, 1.0]);
-    q([[l - fx, t - fy], [l, t - fy], [l, t], [l - fx, t]], [0.0, 0.0, 1.0, 0.0]);
-    q([[r, t - fy], [r + fx, t - fy], [r + fx, t], [r, t]], [0.0, 0.0, 0.0, 1.0]);
-    q([[r, b], [r + fx, b], [r + fx, b + fy], [r, b + fy]], [1.0, 0.0, 0.0, 0.0]);
-    q([[l - fx, b], [l, b], [l, b + fy], [l - fx, b + fy]], [0.0, 1.0, 0.0, 0.0]);
-    v
-}
-
-// ---------- opacity fields ----------
-
-/// The source shown in place through an opacity field `f(x, y)` (0..1) sampled on an `n` × `m`
-/// grid: each cell is a quad with its corners' opacities. Cells with nothing to show are left out
-/// and runs of fully opaque cells merge, so most frames stay small.
-pub(crate) fn field(source: Source, n: usize, m: usize, f: &dyn Fn(f64, f64) -> f64) -> Vec<Layer> {
-    let (n, m) = (n.clamp(1, 256), m.clamp(1, 256));
-    let mut vals = vec![0.0; (n + 1) * (m + 1)];
-    for j in 0..=m {
-        for i in 0..=n {
-            let v = f(i as f64 / n as f64, j as f64 / m as f64);
-            if let Some(x) = vals.get_mut(j * (n + 1) + i) {
-                *x = if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 };
-            }
-        }
-    }
-    let at = |i: usize, j: usize| vals.get(j * (n + 1) + i).copied().unwrap_or(0.0);
-    let mut out = Vec::new();
-    for j in 0..m {
-        let (y0, y1) = (j as f64 / m as f64, (j + 1) as f64 / m as f64);
-        let mut run: Option<usize> = None;
-        for i in 0..=n {
-            let full = i < n && at(i, j) >= 1.0 && at(i + 1, j) >= 1.0 && at(i, j + 1) >= 1.0 && at(i + 1, j + 1) >= 1.0;
-            if full {
-                run.get_or_insert(i);
-                continue;
-            }
-            if let Some(s) = run.take() {
-                out.push(Layer::inplace(source, [s as f64 / n as f64, y0, i as f64 / n as f64, y1], 1.0));
-            }
-            if i == n {
-                break;
-            }
-            let c = [at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1)];
-            if c.iter().all(|v| *v <= 0.0) {
-                continue;
-            }
-            out.push(Layer::inplace(source, [i as f64 / n as f64, y0, (i + 1) as f64 / n as f64, y1], 1.0).faded(c));
-        }
-    }
-    out
-}
-
-/// Opacity of a soft edge at position `p` when the edge's middle is at `c` and it ramps over `w`.
-pub(crate) fn edge(c: f64, p: f64, w: f64) -> f64 {
-    if w <= 1e-9 {
-        return if p <= c { 1.0 } else { 0.0 };
-    }
-    ((c - p) / w + 0.5).clamp(0.0, 1.0)
-}
-
-/// Point on the unit square's boundary seen from its centre at angle `ang` (radians, clockwise
-/// from 12 o'clock, measured on a slide `a` wide per unit of height).
-pub(crate) fn boundary(ang: f64, a: f64) -> P {
-    let (dx, dy) = (ang.sin() / a, -ang.cos());
-    let m = (dx.abs() / 0.5).max(dy.abs() / 0.5).max(1e-9);
-    [0.5 + dx / m, 0.5 + dy / m]
-}
-
-/// The source shown in place through an angular opacity field `f(angle)` (radians clockwise from
-/// 12 o'clock, 0..2π): a fan of thin wedges from the centre.
-pub(crate) fn fan(source: Source, a: f64, steps: usize, f: &dyn Fn(f64) -> f64) -> Vec<Layer> {
-    let n = steps.clamp(8, 720);
-    let mut angles: Vec<f64> = (0..=n).map(|k| 2.0 * PI * k as f64 / n as f64).collect();
-    // The square's corners, so wedges reach them.
-    for c in [[1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0]] {
-        let ang = ((c[0] - 0.5) * a).atan2(-(c[1] - 0.5));
-        angles.push(ang.rem_euclid(2.0 * PI));
-    }
-    angles.sort_by(f64::total_cmp);
-    angles.dedup_by(|x, y| (*x - *y).abs() < 1e-9);
-    let mut out = Vec::new();
-    let c = [0.5, 0.5];
-    for w in angles.windows(2) {
-        let [x, y] = w else { continue };
-        let (fx, fy) = (f(*x).clamp(0.0, 1.0), f(*y).clamp(0.0, 1.0));
-        if fx <= 0.0 && fy <= 0.0 {
-            continue;
-        }
-        let (bx, by) = (boundary(*x, a), boundary(*y, a));
-        out.push(Layer::tri_uv(source, [c, bx, by], [c, bx, by], [(fx + fy) / 2.0, fx, fy], 1.0));
-    }
-    out
-}
-
-// ---------- polygons ----------
-
-/// Keep the part of a convex polygon where `n · p <= d`.
-pub(crate) fn clip(poly: &[P], n: P, d: f64) -> Vec<P> {
-    let mut out = Vec::with_capacity(poly.len() + 2);
-    let side = |p: P| n[0] * p[0] + n[1] * p[1] - d;
-    for (i, p) in poly.iter().enumerate() {
-        let q = poly.get((i + 1) % poly.len()).copied().unwrap_or(*p);
-        let (sp, sq) = (side(*p), side(q));
-        if sp <= 0.0 {
-            out.push(*p);
-        }
-        if (sp < 0.0 && sq > 0.0) || (sp > 0.0 && sq < 0.0) {
-            let k = sp / (sp - sq);
-            out.push([p[0] + (q[0] - p[0]) * k, p[1] + (q[1] - p[1]) * k]);
-        }
-    }
-    out
-}
-
-/// A convex polygon as triangles: vertices drawn at `map(p)` with texture coordinate `p`.
-pub(crate) fn poly_layers(source: Source, poly: &[P], alpha: f64, map: &dyn Fn(P) -> P) -> Vec<Layer> {
-    let Some(first) = poly.first().copied() else { return vec![] };
-    poly.windows(2)
-        .skip(1)
-        .filter_map(|w| match w {
-            [b, c] => Some(Layer::tri_uv(source, [map(first), map(*b), map(*c)], [first, *b, *c], [1.0; 3], alpha)),
-            _ => None,
-        })
-        .collect()
-}
-
-pub(crate) fn rect_poly(r: R) -> Vec<P> {
-    corners(r).to_vec()
-}
-
-// ---------- 3-D ----------
-
-/// A point in the 3-D scene: x right and y down in slide heights (the slide spans x ∈ [−a/2, a/2],
-/// y ∈ [−½, ½] at z = 0), z away from the viewer.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub(crate) struct V3 {
-    pub x: f64,
-    pub y: f64,
-    pub z: f64,
-}
-
-pub(crate) fn v3(x: f64, y: f64, z: f64) -> V3 {
-    V3 { x, y, z }
-}
-
-impl V3 {
-    pub fn add(self, o: V3) -> V3 {
-        v3(self.x + o.x, self.y + o.y, self.z + o.z)
-    }
-    pub fn sub(self, o: V3) -> V3 {
-        v3(self.x - o.x, self.y - o.y, self.z - o.z)
-    }
-    /// Rotate about the vertical axis through `c` (degrees; positive turns the right side away).
-    pub fn yaw(self, c: V3, deg: f64) -> V3 {
-        let (s, co) = deg.to_radians().sin_cos();
-        let p = self.sub(c);
-        v3(p.x * co - p.z * s, p.y, p.x * s + p.z * co).add(c)
-    }
-    /// Rotate about the horizontal axis through `c` (degrees; positive turns the top away).
-    pub fn pitch(self, c: V3, deg: f64) -> V3 {
-        let (s, co) = deg.to_radians().sin_cos();
-        let p = self.sub(c);
-        v3(p.x, p.y * co + p.z * s, -p.y * s + p.z * co).add(c)
-    }
-    /// Rotate in the screen plane about `c` (degrees, clockwise).
-    pub fn roll(self, c: V3, deg: f64) -> V3 {
-        let (s, co) = deg.to_radians().sin_cos();
-        let p = self.sub(c);
-        v3(p.x * co - p.y * s, p.x * s + p.y * co, p.z).add(c)
-    }
-}
-
-/// A perspective camera looking at the slide plane from `d` slide heights away.
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct Cam {
-    pub a: f64,
-    pub d: f64,
-}
-
-impl Cam {
-    pub fn p(&self, v: V3) -> P {
-        let k = self.d / (self.d + v.z).max(self.d * 0.02);
-        [v.x * k / self.a + 0.5, v.y * k + 0.5]
-    }
-    /// The 3-D corners (tl, tr, br, bl) of the unit-space rectangle `r` lying on the slide plane.
-    pub fn rect(&self, r: R) -> [V3; 4] {
-        corners(r).map(|p| v3((p[0] - 0.5) * self.a, p[1] - 0.5, 0.0))
-    }
-    /// The unit-space point of a 3-D point on the slide plane.
-    pub fn unit(&self, x: f64, y: f64) -> V3 {
-        v3((x - 0.5) * self.a, y - 0.5, 0.0)
-    }
-    pub fn quad(&self, c: [V3; 4]) -> Q {
-        c.map(|v| self.p(v))
-    }
-}
-
-/// Signed area of a quad (positive: front side facing the viewer).
-pub(crate) fn area(q: &Q) -> f64 {
-    let mut s = 0.0;
-    for i in 0..4 {
-        let (a, b) = (q[i], q[(i + 1) % 4]);
-        s += a[0] * b[1] - b[0] * a[1];
-    }
-    s / 2.0
-}
-
-/// A card: `src` of the source mapped onto 3-D corners, if it faces the viewer; `shade` (0..1)
-/// darkens it. Seen from behind it is left out unless `back` is set (then drawn mirrored).
-pub(crate) fn card(cam: &Cam, source: Source, src: R, c: [V3; 4], alpha: f64, shade: f64, back: bool) -> Vec<Layer> {
-    let q = cam.quad(c);
-    if !q.iter().all(|p| p[0].is_finite() && p[1].is_finite()) {
-        return vec![];
-    }
-    let front = area(&q) > 0.0;
-    if !front && !back {
-        return vec![];
-    }
-    let l = Layer::quad(source, src, q, alpha);
-    let mut v = vec![l];
-    if shade > 0.001 {
-        v.push(l.shade(shade));
-    }
-    v
-}
-
-/// How much a card facing along `n` (unit normal toward the viewer is (0, 0, −1)) is darkened by
-/// the light behind the viewer: 0 facing straight on.
-pub(crate) fn facing_shade(c: [V3; 4], k: f64) -> f64 {
-    let u = c[1].sub(c[0]);
-    let w = c[3].sub(c[0]);
-    let n = v3(u.y * w.z - u.z * w.y, u.z * w.x - u.x * w.z, u.x * w.y - u.y * w.x);
-    let len = (n.x * n.x + n.y * n.y + n.z * n.z).sqrt();
-    if len < 1e-12 {
-        return 0.0;
-    }
-    let cos = (n.z / len).abs();
-    (k * (1.0 - cos)).clamp(0.0, 1.0)
-}

crates/anim/src/transition_tests.rs

@@ -1,230 +0,0 @@
-//! Transition curves and geometry against values measured on PowerPoint's video export
-//! (`plan/powerpoint/tools/synth_transitions.ps1`, 2 s transitions, 30 fps).
-
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-
-use deckcraft_model::anim::TRANSITIONS;
-
-use crate::transition::{Layer, Source, transition_frame, transition_layers, uses_slide_parts};
-use crate::transition_geom::{edge, pow_inout, q2, ss};
-
-const A: f64 = 16.0 / 9.0;
-
-fn near(a: f64, b: f64, tol: f64) -> bool {
-    (a - b).abs() <= tol
-}
-
-fn of(ls: &[Layer], src: Source) -> Vec<&Layer> {
-    ls.iter().filter(|l| l.source == src).collect()
-}
-
-fn left(l: &Layer) -> f64 {
-    l.quad.iter().map(|p| p[0]).fold(f64::INFINITY, f64::min)
-}
-
-fn top(l: &Layer) -> f64 {
-    l.quad.iter().map(|p| p[1]).fold(f64::INFINITY, f64::min)
-}
-
-#[test]
-fn fade_follows_powerpoints_s_curve() {
-    // Measured share of the new slide in a 2 s Fade at t = 0.25, 0.5, 0.75: 0.155, 0.49, 0.82.
-    for (t, want) in [(0.25, 0.155), (0.5, 0.49), (0.75, 0.82)] {
-        let ls = transition_layers("fade", "smoothly", t);
-        let new = of(&ls, Source::New);
-        assert!(near(new[0].alpha, want, 0.04), "t={t}: {}", new[0].alpha);
-    }
-    // Through black: the old slide is gone to black at the middle, then the new one fades in.
-    let mid = transition_layers("fade", "throughBlack", 0.5);
-    assert!(mid.iter().all(|l| l.source == Source::Black));
-    let q = transition_layers("fade", "throughBlack", 0.25);
-    assert!(near(of(&q, Source::Old)[0].alpha, 0.5, 0.01));
-}
-
-#[test]
-fn push_moves_both_slides_with_an_eased_curve() {
-    for (o, dx, dy) in [("l", -1.0, 0.0), ("r", 1.0, 0.0), ("u", 0.0, -1.0), ("d", 0.0, 1.0)] {
-        for t in [0.25, 0.5, 0.75] {
-            let ls = transition_layers("push", o, t);
-            let (old, new) = (of(&ls, Source::Old)[0], of(&ls, Source::New)[0]);
-            let s = q2(t);
-            assert!(near(old.quad[0][0], dx * s, 1e-9) && near(old.quad[0][1], dy * s, 1e-9), "{o} {t}");
-            assert!(near(new.quad[0][0], dx * (s - 1.0), 1e-9) && near(new.quad[0][1], dy * (s - 1.0), 1e-9), "{o} {t}");
-        }
-    }
-    // Ease in-out: slow at both ends.
-    assert!(q2(0.1) < 0.05 && q2(0.9) > 0.95 && near(q2(0.5), 0.5, 1e-9));
-}
-
-#[test]
-fn cover_and_uncover_match_measured_positions() {
-    // Offset of the new slide in Cover Left (fraction of the width) at measured times.
-    for (t, off) in [(0.445, 0.655), (0.495, 0.512), (0.544, 0.359), (0.643, 0.134), (0.742, 0.046)] {
-        let ls = transition_layers("cover", "l", t);
-        assert!(near(left(of(&ls, Source::New)[0]), off, 0.05), "cover t={t}");
-    }
-    // Offset of the old slide in Uncover Left.
-    for (t, off) in [(0.244, -0.06), (0.343, -0.14), (0.442, -0.32), (0.508, -0.5), (0.558, -0.63)] {
-        let ls = transition_layers("uncover", "l", t);
-        assert!(near(left(of(&ls, Source::Old)[0]), off, 0.05), "uncover t={t}");
-    }
-    // Diagonal Cover shoots in and settles slowly.
-    for (t, off) in [(0.142, 0.728), (0.257, 0.49), (0.356, 0.29), (0.455, 0.146), (0.604, 0.053)] {
-        let ls = transition_layers("cover", "lu", t);
-        let n = of(&ls, Source::New)[0];
-        assert!(near(left(n), off, 0.06) && near(top(n), off, 0.06), "cover lu t={t}");
-    }
-    assert!(near(pow_inout(0.25, 3.0), 0.0625, 1e-9));
-}
-
-#[test]
-fn wipe_has_a_wide_soft_edge() {
-    // Measured along a row of Wipe Right at t = 0.5: about half-way through at x = 0.6, nearly
-    // nothing at the right edge, fully new on the left third.
-    let c = -0.4 + 1.8 * 1.05 * 0.5;
-    assert!(near(edge(c, 0.6, 0.8), 0.49, 0.1));
-    assert!(edge(c, 1.0, 0.8) < 0.1);
-    assert!(edge(c, 0.2, 0.8) > 0.8);
-    // Directions: "r" starts on the left, "l" on the right, "u" at the bottom, "d" at the top,
-    // diagonals at the opposite corner.
-    let first = |o: &str| {
-        let ls = transition_layers("wipe", o, 0.15);
-        let n = of(&ls, Source::New);
-        assert!(!n.is_empty(), "{o}");
-        let cx = n.iter().map(|l| (l.quad[0][0] + l.quad[2][0]) / 2.0).sum::<f64>() / n.len() as f64;
-        let cy = n.iter().map(|l| (l.quad[0][1] + l.quad[2][1]) / 2.0).sum::<f64>() / n.len() as f64;
-        (cx, cy)
-    };
-    assert!(first("r").0 < 0.3 && first("l").0 > 0.7);
-    assert!(first("u").1 > 0.7 && first("d").1 < 0.3);
-    let ru = first("ru");
-    assert!(ru.0 < 0.4 && ru.1 > 0.6, "{ru:?}");
-}
-
-#[test]
-fn split_and_shape_open_from_the_middle() {
-    for o in ["horzOut", "vertOut"] {
-        let ls = transition_layers("split", o, 0.2);
-        let n = of(&ls, Source::New);
-        assert!(n.iter().all(|l| {
-            let c = [(l.quad[0][0] + l.quad[2][0]) / 2.0, (l.quad[0][1] + l.quad[2][1]) / 2.0];
-            if o.starts_with("horz") { (c[1] - 0.5).abs() < 0.4 } else { (c[0] - 0.5).abs() < 0.4 }
-        }));
-    }
-    // Shape In is done with the old slide at half time; Shape Out starts the new one then.
-    assert!(of(&transition_layers("shape", "in", 0.55), Source::Old).is_empty());
-    assert!(of(&transition_layers("shape", "out", 0.45), Source::New).is_empty());
-}
-
-#[test]
-fn dynamic_content_curves() {
-    // Pan: the new content's offset (fraction of the width) at measured times.
-    for (t, off) in [(0.6, 0.134), (0.7, 0.086), (0.8, 0.039), (0.9, 0.011)] {
-        let ls = transition_layers("pan", "l", t);
-        assert!(near(left(of(&ls, Source::NewContent)[0]), off, 0.07), "pan t={t}");
-    }
-    // The backgrounds cross-fade under the moving contents.
-    let ls = transition_layers("pan", "l", 0.5);
-    assert_eq!(ls.first().map(|l| l.source), Some(Source::OldBack));
-    assert!(of(&ls, Source::NewBack)[0].alpha > 0.5);
-    // Ferris Wheel: the old content drops (top edge, slide heights) as measured.
-    for (t, dy) in [(0.147, 0.06), (0.246, 0.17), (0.345, 0.36), (0.444, 0.70)] {
-        let ls = transition_layers("ferris", "l", t);
-        let q = of(&ls, Source::OldContent)[0].quad;
-        let cy = q.iter().map(|p| p[1]).sum::<f64>() / 4.0 - 0.5;
-        assert!(near(cy, dy, 0.08), "ferris t={t}: {cy}");
-    }
-    for k in ["pan", "ferris", "conveyor", "rotate", "window", "orbit", "flythrough"] {
-        assert!(uses_slide_parts(k, ""), "{k}");
-    }
-    assert!(uses_slide_parts("reveal", "smoothlyLeft") && !uses_slide_parts("reveal", "blackLeft"));
-    assert!(!uses_slide_parts("cube", "l") && !uses_slide_parts("push", "l"));
-}
-
-#[test]
-fn cube_turns_toward_the_option() {
-    // Cube Left at the middle: the shared edge is near the middle, the old face on the left.
-    let ls = transition_frame("cube", "l", 0.5, A);
-    let (o, n) = (of(&ls, Source::Old)[0], of(&ls, Source::New)[0]);
-    let o_right = o.quad.iter().map(|p| p[0]).fold(f64::NEG_INFINITY, f64::max);
-    assert!(near(o_right, left(n), 0.02), "shared edge: {o_right} vs {}", left(n));
-    assert!(o_right > 0.3 && o_right < 0.7);
-    // Up: the new face comes from below.
-    let ls = transition_frame("cube", "u", 0.5, A);
-    assert!(top(of(&ls, Source::New)[0]) > top(of(&ls, Source::Old)[0]));
-}
-
-#[test]
-fn switch_swaps_the_cards_past_halfway() {
-    let order = |t: f64| {
-        let ls = transition_frame("switch", "l", t, A);
-        let pos = |s: Source| ls.iter().position(|l| l.source == s);
-        (pos(Source::Old), pos(Source::New))
-    };
-    let (o, n) = order(0.3);
-    assert!(o > n, "old in front early");
-    let (o, n) = order(0.8);
-    assert!(n > o, "new in front late");
-}
-
-#[test]
-fn clock_hand_sweeps_at_constant_speed() {
-    // The share of the slide covered grows linearly.
-    let area = |t: f64| {
-        let ls = transition_layers("clock", "clockwise", t);
-        of(&ls, Source::New)
-            .iter()
-            .map(|l| {
-                let [a, b, c, _] = l.quad;
-                ((b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1])).abs() / 2.0 * (l.fade[0] + l.fade[1] + l.fade[2]) / 3.0
-            })
-            .sum::<f64>()
-    };
-    let (a1, a2, a3) = (area(0.25), area(0.5), area(0.75));
-    assert!(near(a2 - a1, a3 - a2, 0.08), "{a1} {a2} {a3}");
-    assert!(near(a2, 0.5, 0.08), "{a2}");
-}
-
-#[test]
-fn options_change_the_frame() {
-    // Every option of a transition draws something different from its other options midway.
-    for (id, _, _, _, opts) in TRANSITIONS {
-        if matches!(*id, "morph" | "none" | "random") || opts.len() < 2 {
-            continue;
-        }
-        for (i, a) in opts.iter().enumerate() {
-            for b in opts.iter().skip(i + 1) {
-                let differs = [0.2, 0.35, 0.5, 0.8].iter().any(|t| transition_layers(id, a, *t) != transition_layers(id, b, *t));
-                assert!(differs, "{id}: {a} vs {b}");
-            }
-        }
-    }
-}
-
-#[test]
-fn frames_stay_cheap() {
-    // Per frame, the show draws these meshes from cached slide textures: keep them small.
-    for (id, _, _, _, opts) in TRANSITIONS {
-        let mut options: Vec<&str> = opts.to_vec();
-        options.push("");
-        for o in options {
-            for t in [0.1, 0.3, 0.5, 0.7, 0.9] {
-                let tris: usize = transition_frame(id, o, t, A).iter().map(|l| crate::layer_mesh(l).1.len()).sum();
-                assert!(tris < 30_000, "{id}/{o} t={t}: {tris} triangles");
-            }
-        }
-    }
-}
-
-#[test]
-fn hostile_aspects_are_safe() {
-    for a in [f64::NAN, 0.0, -3.0, 1e9, f64::INFINITY] {
-        for (id, ..) in TRANSITIONS {
-            for l in transition_frame(id, "", 0.4, a) {
-                assert!(l.quad.iter().all(|p| p[0].is_finite() && p[1].is_finite()));
-                assert!(l.fade.iter().all(|f| (0.0..=1.0).contains(f)));
-            }
-        }
-    }
-    assert!(near(ss(0.5), 0.5, 1e-12));
-}

crates/engine/src/cmd/arrange.rs

@@ -13,15 +13,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("arrange.bringForward", "Bring Forward", ["Arrange"], Some("Cmd+]"), "{ids?}", has_selection, |s, p| order(s, p, 1)),
         cmd!("arrange.sendBackward", "Send Backward", ["Arrange"], Some("Cmd+["), "{ids?}", has_selection, |s, p| order(s, p, -1)),
         cmd!("arrange.sendToBack", "Send to Back", ["Arrange"], Some("Cmd+Shift+["), "{ids?}", has_selection, |s, p| order(s, p, -2)),
-        cmd!(
-            "arrange.reorder",
-            "Reorder Objects",
-            ["Arrange"],
-            None,
-            "{id, index: position among its siblings (0 = back; a group's child stays in its group)} → {index}",
-            has_slide,
-            reorder
-        ),
+        cmd!("arrange.reorder", "Reorder Objects", ["Arrange"], None, "{id, index: position in the stack (0 = back)}", has_slide, reorder),
         cmd!("arrange.group", "Group", ["Arrange"], Some("Cmd+Alt+G"), "{ids?}", has_two, group),
         cmd!("arrange.ungroup", "Ungroup", ["Arrange"], Some("Cmd+Alt+Shift+G"), "{ids?}", has_selection, ungroup),
         cmd!("arrange.regroup", "Regroup", ["Arrange"], Some("Cmd+Alt+J"), "{}", has_doc, regroup),
@@ -58,98 +50,52 @@ pub fn specs() -> Vec<CommandSpec> {
 
 fn order(s: &mut Session, p: &Value, how: i32) -> Result<Value> {
     let ids = targets(s, p)?;
-    // Already in place (front of its group, say): no change and no undo step.
-    let mut trial = s.doc()?.shapes().to_vec();
-    order_tree(&mut trial, &ids, how, 0);
-    if stacking(&trial) == stacking(s.doc()?.shapes()) {
-        return ok();
-    }
     s.edit(|doc, sel| {
         let list = crate::shapes_mut(doc, sel).ok_or_else(|| bad("arrange", "no slide"))?;
-        order_tree(list, &ids, how, 0);
+        match how {
+            2 => {
+                let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
+                list.extend(rest);
+                list.append(&mut moved);
+            }
+            -2 => {
+                let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
+                moved.extend(rest);
+                *list = moved;
+            }
+            1 => {
+                for i in (0..list.len().saturating_sub(1)).rev() {
+                    let (a, b) = (list.get(i).map(|x| ids.contains(&x.id)), list.get(i + 1).map(|x| ids.contains(&x.id)));
+                    if a == Some(true) && b == Some(false) {
+                        list.swap(i, i + 1);
+                    }
+                }
+            }
+            _ => {
+                for i in 1..list.len() {
+                    let (a, b) = (list.get(i - 1).map(|x| ids.contains(&x.id)), list.get(i).map(|x| ids.contains(&x.id)));
+                    if a == Some(false) && b == Some(true) {
+                        list.swap(i - 1, i);
+                    }
+                }
+            }
+        }
         Ok(())
     })?;
     ok()
 }
 
-/// Every shape id with its depth, in tree order.
-fn stacking(v: &[Shape]) -> Vec<(ShapeId, usize)> {
-    let mut out = vec![];
-    deckcraft_model::walk(v, &mut |sh, d| out.push((sh.id, d)));
-    out
-}
-
-/// Restack `ids` among their siblings, in every list of the tree: a shape inside a group moves
-/// within its group and never leaves it (PowerPoint's Selection pane arrows work the same way).
-fn order_tree(list: &mut Vec<Shape>, ids: &[ShapeId], how: i32, depth: usize) {
-    if depth > 64 {
-        return;
-    }
-    if list.iter().any(|x| ids.contains(&x.id)) {
-        order_list(list, ids, how);
-    }
-    for sh in list.iter_mut() {
-        if let Some(children) = sh.children_mut() {
-            order_tree(children, ids, how, depth + 1);
-        }
-    }
-}
-
-fn order_list(list: &mut Vec<Shape>, ids: &[ShapeId], how: i32) {
-    match how {
-        2 => {
-            let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
-            list.extend(rest);
-            list.append(&mut moved);
-        }
-        -2 => {
-            let (mut moved, rest): (Vec<Shape>, Vec<Shape>) = list.drain(..).partition(|x| ids.contains(&x.id));
-            moved.extend(rest);
-            *list = moved;
-        }
-        1 => {
-            for i in (0..list.len().saturating_sub(1)).rev() {
-                let (a, b) = (list.get(i).map(|x| ids.contains(&x.id)), list.get(i + 1).map(|x| ids.contains(&x.id)));
-                if a == Some(true) && b == Some(false) {
-                    list.swap(i, i + 1);
-                }
-            }
-        }
-        _ => {
-            for i in 1..list.len() {
-                let (a, b) = (list.get(i - 1).map(|x| ids.contains(&x.id)), list.get(i).map(|x| ids.contains(&x.id)));
-                if a == Some(false) && b == Some(true) {
-                    list.swap(i - 1, i);
-                }
-            }
-        }
-    }
-}
-
-/// Move one shape to `index` among its siblings (0 = back): the Selection pane's drag and drop.
-/// A shape stays in the list that holds it, so a group's child stays in its group.
 fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
     let id = id_param(p, "id").ok_or_else(|| bad("arrange.reorder", "missing `id`"))?;
     let to = usize_param(p, "index").ok_or_else(|| bad("arrange.reorder", "missing `index`"))?;
-    let st = s.doc()?;
-    let siblings: &[Shape] = match deckcraft_model::parent_of(st.shapes(), id) {
-        None => return Err(bad("arrange.reorder", "no such shape")),
-        Some(None) => st.shapes(),
-        Some(Some(g)) => st.shape(g).map(Shape::children).unwrap_or(&[]),
-    };
-    let from = siblings.iter().position(|x| x.id == id).ok_or_else(|| bad("arrange.reorder", "no such shape"))?;
-    if from == to.min(siblings.len().saturating_sub(1)) {
-        return Ok(json!({"index": from}));
-    }
     s.edit(|doc, sel| {
-        let tree = crate::shapes_mut(doc, sel).ok_or_else(|| bad("arrange.reorder", "no slide"))?;
-        let list = deckcraft_model::sibling_list_mut(tree, id).ok_or_else(|| bad("arrange.reorder", "no such shape"))?;
-        let i = list.iter().position(|x| x.id == id).ok_or_else(|| bad("arrange.reorder", "no such shape"))?;
+        let list = crate::shapes_mut(doc, sel).ok_or_else(|| bad("arrange.reorder", "no slide"))?;
+        let i = list.iter().position(|x| x.id == id).ok_or_else(|| bad("arrange.reorder", "not a top-level shape"))?;
         let sh = list.remove(i);
-        let at = to.min(list.len());
-        list.insert(at, sh);
-        Ok(json!({"index": at}))
-    })
+        list.insert(to.min(list.len()), sh);
+        Ok(())
+    })?;
+    ok()
 }
 
 /// Bounds of shapes (rotation included).
@@ -275,7 +221,7 @@ fn align(s: &mut Session, p: &Value) -> Result<Value> {
     } else {
         union_bounds(&boxes.iter().map(|b| b.1).collect::<Vec<_>>()).unwrap_or_default()
     };
-    edit_geometry(s, p, "arrange.align", |sh| {
+    edit_shapes(s, p, "arrange.align", |sh| {
         if let Some(x) = sh.xfrm.as_mut() {
             let b = x.bounds();
             let (dx, dy) = match edge.as_str() {
@@ -327,7 +273,7 @@ fn distribute(s: &mut Session, p: &Value) -> Result<Value> {
         targets_pos.push((*id, d));
         cur += (if horiz { b.width() } else { b.height() }) + gap;
     }
-    edit_geometry(s, p, "arrange.distribute", |sh| {
+    edit_shapes(s, p, "arrange.distribute", |sh| {
         if let (Some(x), Some((_, d))) = (sh.xfrm.as_mut(), targets_pos.iter().find(|(i, _)| *i == sh.id)) {
             if horiz {
                 x.x += d;

crates/engine/src/cmd/design.rs

@@ -483,7 +483,6 @@ fn insert_layout(s: &mut Session, p: &Value) -> Result<Value> {
                 background: None,
                 show_master_shapes: true,
                 preserve: true,
-                color_map: None,
                 raw_ext: None,
             },
         );

crates/engine/src/cmd/file.rs

@@ -15,16 +15,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "file.saveAs", "Save As…", ["File"], Some("Cmd+Shift+S"), "{path, format?}", has_doc, save_as),
         cmd!(noundo "file.saveTemplate", "Save as Template…", ["File"], None, "{path}", has_doc, save_as),
         cmd!(query "file.saveBytes", "Save to Data", [], None, "{format?: deckcraft|pptx} → {data: base64}", has_doc, save_bytes_cmd),
-        cmd!(noundo "file.export", "Export…", ["File"], None, "{path, format: png|jpeg|pptx|deckcraft|outline|pdf, slide?: index, all?: bool, scale?: px per pt; pdf: layout?: slides|notes|handouts, perPage?: 1|2|3|4|6|9, dpi?, slides?: [index] | \"1-3,5\", includeHidden?, textLayer?, frame?}", has_doc, export),
-        cmd!(
-            query "file.info",
-            "Info",
-            ["File"],
-            None,
-            "{} → {title, path, format, dirty, slides, hiddenSlides, sections, bytes?, properties}",
-            has_doc,
-            info
-        ),
+        cmd!(noundo "file.export", "Export…", ["File"], None, "{path, format: png|jpeg|pptx|deckcraft|outline|pdf, slide?: index, all?: bool, scale?: px per pt; pdf: layout?: slides|notes|handouts, perPage?: 1|2|3|4|6|9, dpi?, slides?: [index], includeHidden?, textLayer?, frame?}", has_doc, export),
         cmd!(query "file.render", "Render Slide", [], None, "{slide?: index, scale?, edit?: bool} → {png: base64, width, height}", has_doc, render),
         cmd!(noundo "file.close", "Close", ["File"], Some("Cmd+W"), "{}", has_doc, close),
         cmd!(
@@ -88,10 +79,7 @@ pub fn open_presentation(name: &str, bytes: &[u8]) -> Result<Presentation> {
 
 pub fn add_opened(s: &mut Session, name: &str, path: Option<String>, p: Presentation) -> usize {
     let title = std::path::Path::new(name).file_stem().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| name.to_string());
-    let missing_fonts = crate::fonts::missing_fonts(&p);
-    let mut st = DocState::new(p, path, title);
-    st.missing_fonts = missing_fonts;
-    s.add_document(st)
+    s.add_document(DocState::new(p, path, title))
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -101,8 +89,7 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {
     let doc = open_presentation(path, &bytes)?;
     let native = deckcraft_format::sniff(&bytes) || deckcraft_pptx::sniff(&bytes);
     let i = add_opened(s, path, native.then(|| path.to_string()), doc);
-    let st = s.doc()?;
-    Ok(json!({"document": i, "slides": st.doc.slides.len(), "missingFonts": st.missing_fonts}))
+    Ok(json!({"document": i, "slides": s.doc()?.doc.slides.len()}))
 }
 #[cfg(target_arch = "wasm32")]
 fn open(_s: &mut Session, _p: &Value) -> Result<Value> {
@@ -114,7 +101,7 @@ fn open_bytes(s: &mut Session, p: &Value) -> Result<Value> {
     let data = str_param(p, "data").and_then(base64_decode).ok_or_else(|| bad("file.openBytes", "missing or invalid base64 `data`"))?;
     let doc = open_presentation(name, &data)?;
     let i = add_opened(s, name, None, doc);
-    Ok(json!({"document": i, "missingFonts": s.doc()?.missing_fonts}))
+    Ok(json!({"document": i}))
 }
 
 /// Encode the presentation in `format` (`deckcraft`, `pptx`, `outline`).
@@ -127,59 +114,26 @@ pub fn save_bytes(doc: &Presentation, format: &str) -> Result<Vec<u8>> {
     }
 }
 
-/// PDF options from command params: `{layout: slides|notes|handouts, perPage, dpi, slides,
-/// includeHidden, textLayer, frame}` for a presentation of `count` slides. `slides` is a list of
-/// 0-based indices or a range as typed in PowerPoint's Print page (`"1-3, 5"`, 1-based).
-pub fn pdf_options(p: &Value, count: usize) -> Result<deckcraft_pdf::PdfOptions> {
+/// PDF options from command params: `{layout: slides|notes|handouts, perPage, dpi, slides: [i],
+/// includeHidden, textLayer, frame}`.
+pub fn pdf_options(p: &Value) -> deckcraft_pdf::PdfOptions {
     let mut o = deckcraft_pdf::PdfOptions { layout: deckcraft_pdf::PageLayout::Slides, ..Default::default() };
     o.layout = match str_param(p, "layout").unwrap_or("slides") {
         "notes" => deckcraft_pdf::PageLayout::Notes,
-        "handouts" => deckcraft_pdf::PageLayout::Handouts { per_page: usize_param(p, "perPage").unwrap_or(6).clamp(1, 9) as u8 },
+        "handouts" => deckcraft_pdf::PageLayout::Handouts { per_page: usize_param(p, "perPage").unwrap_or(6).min(9) as u8 },
         _ => deckcraft_pdf::PageLayout::Slides,
     };
     o.dpi = f64_or(p, "dpi", o.dpi).clamp(36.0, 600.0);
-    o.slides = match p.get("slides") {
-        Some(Value::Array(a)) => Some(a.iter().filter_map(|v| v.as_u64().map(|x| x as usize)).filter(|i| *i < count).collect()),
-        Some(Value::String(text)) if !text.trim().is_empty() => Some(parse_slide_range(text, count)?),
-        _ => None,
-    };
+    o.slides = p.get("slides").and_then(Value::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(|x| x as usize)).collect());
     o.include_hidden = bool_or(p, "includeHidden", false);
     o.text_layer = bool_or(p, "textLayer", true);
     o.frame_slides = bool_or(p, "frame", true);
-    Ok(o)
-}
-
-/// A slide range as typed in the Print page's Slides box (`"1-3, 5"`; 1-based, either separator
-/// `,` or `;`, ranges either way round) → 0-based indices in order, without repeats. Numbers past
-/// the last slide or a range that isn't numbers is an error, as in PowerPoint.
-pub fn parse_slide_range(text: &str, count: usize) -> Result<Vec<usize>> {
-    let invalid = || bad("file.export", format!("“{text}” isn't a valid slide range: use numbers and ranges such as 1-3, 5"));
-    let mut out: Vec<usize> = vec![];
-    for part in text.split([',', ';']).map(str::trim).filter(|p| !p.is_empty()) {
-        let (a, b) = match part.split_once('-') {
-            Some((a, b)) => (a.trim(), b.trim()),
-            None => (part, part),
-        };
-        let (a, b) = (a.parse::<usize>().map_err(|_| invalid())?, b.parse::<usize>().map_err(|_| invalid())?);
-        let (lo, hi) = (a.min(b), a.max(b));
-        if lo == 0 || hi > count {
-            return Err(bad("file.export", format!("the presentation has {count} slides; “{part}” is outside them")));
-        }
-        for i in lo - 1..hi {
-            if !out.contains(&i) {
-                out.push(i);
-            }
-        }
-    }
-    if out.is_empty() {
-        return Err(invalid());
-    }
-    Ok(out)
+    o
 }
 
 /// PDF bytes for `doc` with [`pdf_options`] from `p`.
 pub fn pdf_bytes(doc: &Presentation, p: &Value) -> Result<Vec<u8>> {
-    deckcraft_pdf::export(doc, &pdf_options(p, doc.slides.len())?).map_err(|e| EngineError::Other(e.to_string()))
+    deckcraft_pdf::export(doc, &pdf_options(p)).map_err(|e| EngineError::Other(e.to_string()))
 }
 
 pub fn format_for_path(path: &str) -> &'static str {
@@ -306,7 +260,7 @@ fn export(s: &mut Session, p: &Value) -> Result<Value> {
             Ok(json!({"files": written}))
         }
         "pdf" => {
-            let bytes = pdf_bytes(&st.doc, p)?;
+            let bytes = deckcraft_pdf::export(&st.doc, &pdf_options(p)).map_err(|e| EngineError::Other(e.to_string()))?;
             write_file(&path, &bytes)?;
             Ok(json!({"path": path, "bytes": bytes.len()}))
         }
@@ -318,27 +272,6 @@ fn export(s: &mut Session, p: &Value) -> Result<Value> {
     }
 }
 
-/// File › Info: what the Info page shows about the active presentation.
-fn info(s: &mut Session, _p: &Value) -> Result<Value> {
-    let st = s.doc()?;
-    let doc = &st.doc;
-    #[cfg(not(target_arch = "wasm32"))]
-    let bytes = st.path.as_ref().and_then(|p| std::fs::metadata(p).ok()).map(|m| m.len());
-    #[cfg(target_arch = "wasm32")]
-    let bytes: Option<u64> = None;
-    Ok(json!({
-        "title": st.title(),
-        "path": st.path,
-        "format": st.path.as_deref().map(format_for_path),
-        "dirty": st.is_dirty(),
-        "slides": doc.slides.len(),
-        "hiddenSlides": doc.slides.iter().filter(|sl| sl.hidden).count(),
-        "sections": doc.sections.len(),
-        "bytes": bytes,
-        "properties": serde_json::to_value(&doc.props).unwrap_or_default(),
-    }))
-}
-
 fn close(s: &mut Session, _p: &Value) -> Result<Value> {
     if let Some(i) = s.active_index() {
         s.close_document(i);

crates/engine/src/cmd/format.rs

@@ -49,15 +49,7 @@ pub fn specs() -> Vec<CommandSpec> {
             color
         ),
         cmd!("format.highlight", "Text Highlight Color", ["Home", "Font"], None, "{color? (absent = none)}", has_text_or_shapes, highlight),
-        cmd!(
-            "format.case",
-            "Change Case",
-            ["Home", "Font"],
-            Some("Shift+F3"),
-            "{mode?: cycle|sentence|lower|upper|title|toggle} — cycle (Shift+F3, the default) goes lowercase → Capitalize Each Word → UPPERCASE; a caret in a word changes that word",
-            has_text_or_shapes,
-            case
-        ),
+        cmd!("format.case", "Change Case", ["Home", "Font"], Some("Shift+F3"), "{mode: sentence|lower|upper|title|toggle}", has_text_or_shapes, case),
         cmd!("format.caps", "Caps", [], None, "{caps: none|small|all}", has_text_or_shapes, caps),
         cmd!(
             "format.spacing",
@@ -336,23 +328,15 @@ fn text_outline(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn case(s: &mut Session, p: &Value) -> Result<Value> {
-    let mode = str_param(p, "mode").unwrap_or("cycle").to_string();
+    let mode = str_param(p, "mode").unwrap_or("sentence").to_string();
     let st = s.doc()?;
     if let Some(t) = st.selection.text.clone() {
-        let (mut a, mut b) = t.ordered();
-        let body = super::text::body_of(st, &t).cloned().unwrap_or_default();
-        let collapsed = a == b;
-        if collapsed {
-            // Shift+F3 with a bare caret changes the word it is in and puts the caret at its start.
-            let (wa, wb) = ed::word_at(&body, a);
-            let is_word = ed::text_range(&body, wa, wb).chars().any(char::is_alphanumeric);
-            if !(is_word && wa.1 <= a.1 && a.1 < wb.1) {
-                return ok();
-            }
-            (a, b) = (wa, wb);
+        let (a, b) = t.ordered();
+        if a == b {
+            return ok();
         }
-        let m = if mode == "cycle" { ed::next_case(&ed::text_range(&body, a, b)).to_string() } else { mode.clone() };
-        super::text::edit_text(s, move |body, t| {
+        let m = mode.clone();
+        super::text::edit_text(s, move |body, _| {
             for pi in a.0..=b.0 {
                 let Some(para) = body.paragraphs.get_mut(pi) else { continue };
                 let n = para.char_len();
@@ -375,23 +359,9 @@ fn case(s: &mut Session, p: &Value) -> Result<Value> {
                     pos += len;
                 }
             }
-            if collapsed {
-                t.anchor = a;
-                t.caret = a;
-            }
         })?;
         return ok();
     }
-    let mode = if mode == "cycle" {
-        let all: String =
-            st.selection.shapes.iter().filter_map(|id| st.shape(*id)).filter_map(|sh| sh.text.as_ref()).map(|t| t.text()).collect::<Vec<_>>().join(
-                "
-",
-            );
-        ed::next_case(&all).to_string()
-    } else {
-        mode
-    };
     edit_shapes(s, &json!({}), "format.case", |sh| {
         if let Some(t) = sh.text.as_mut() {
             for para in &mut t.paragraphs {

crates/engine/src/cmd/mod.rs

@@ -11,7 +11,6 @@ pub mod inspect;
 pub mod media;
 pub mod merge;
 pub mod review;
-pub mod selection;
 pub mod shape;
 pub mod slide;
 pub mod table;
@@ -131,7 +130,6 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(insert::specs());
         v.extend(shape::specs());
         v.extend(arrange::specs());
-        v.extend(selection::specs());
         v.extend(merge::specs());
         v.extend(text::specs());
         v.extend(format::specs());
@@ -311,18 +309,6 @@ pub(crate) fn edit_shapes(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut
     })
 }
 
-/// [`edit_shapes`] for edits a locked object refuses (move, size, rotate, flip, reshape, crop):
-/// locked targets are left out, and when every target is locked nothing changes.
-pub(crate) fn edit_geometry(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut deckcraft_model::Shape) -> Result<()>) -> Result<Value> {
-    let ids = targets(s, p)?;
-    let st = s.doc()?;
-    let free: Vec<u32> = ids.iter().filter(|id| !st.shape(**id).is_some_and(|x| x.locked)).map(|id| id.0).collect();
-    if !ids.is_empty() && free.is_empty() {
-        return Err(bad(cmd, "the object is locked"));
-    }
-    edit_shapes(s, &with_param(p, "ids", Value::from(free)), cmd, f)
-}
-
 pub(crate) fn current_shapes<'a>(doc: &'a deckcraft_model::Presentation, sel: &crate::Selection) -> Option<&'a Vec<deckcraft_model::Shape>> {
     match sel.target {
         crate::Target::Slides => doc.slides.get(sel.slide).map(|s| &s.shapes),

crates/engine/src/cmd/selection.rs

@@ -1,126 +0,0 @@
-//! Selection pane: picking objects from the list, Show All and Hide All. Its other actions are
-//! ordinary commands: `shape.visible` (eye), `shape.lock` (padlock), `shape.rename`,
-//! `arrange.bringForward` / `arrange.sendBackward` (arrows) and `arrange.reorder` (drag and drop).
-
-use deckcraft_model::{Shape, ShapeId};
-use serde_json::{Value, json};
-
-use super::*;
-use crate::{Result, Session};
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        cmd!(
-            "selection.select",
-            "Select",
-            ["Selection Pane"],
-            None,
-            "{ids | id, toggle?: bool (Ctrl+click), add?: bool} → {selected}: objects in groups too; a hidden object picked from the list is shown",
-            has_slide,
-            select
-        ),
-        cmd!("selection.showAll", "Show All", ["Selection Pane"], None, "{} shows every object on the slide, inside groups too", has_slide, show_all),
-        cmd!("selection.hideAll", "Hide All", ["Selection Pane"], None, "{} hides every top-level object on the slide", has_slide, hide_all),
-    ]
-}
-
-/// The Selection pane's click. Objects inside groups and top-level objects can't be selected
-/// together (Ctrl+click on the other kind is ignored, as in PowerPoint), and picking a hidden
-/// object from the list shows it again.
-fn select(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = ids_param(p, "ids").or_else(|| id_param(p, "id").map(|i| vec![i])).unwrap_or_default();
-    let (toggle, add) = (bool_or(p, "toggle", false), bool_or(p, "add", false));
-    let st = s.doc()?;
-    let in_group = |id: &ShapeId| deckcraft_model::parent_of(st.shapes(), *id).map(|p| p.is_some());
-    let mut valid: Vec<ShapeId> = ids.iter().copied().filter(|i| in_group(i).is_some()).collect();
-    if valid.is_empty() {
-        return Err(bad("selection.select", "no such shape"));
-    }
-    let kind = valid.first().and_then(in_group);
-    valid.retain(|i| in_group(i) == kind);
-    let keep: Vec<ShapeId> = if toggle || add {
-        let current = st.selection.shapes.clone();
-        if current.first().is_some_and(|c| in_group(c) != kind) {
-            // Can't mix objects in groups with top-level ones: nothing changes.
-            return Ok(json!({"selected": current}));
-        }
-        current
-    } else {
-        vec![]
-    };
-    let mut next = keep;
-    for i in &valid {
-        match next.iter().position(|x| x == i) {
-            Some(k) if toggle => {
-                next.remove(k);
-            }
-            Some(_) => {}
-            None => next.push(*i),
-        }
-    }
-    let reveal: Vec<ShapeId> = next.iter().copied().filter(|i| valid.contains(i) && st.shape(*i).is_some_and(|x| x.hidden)).collect();
-    if reveal.is_empty() {
-        s.select(|_, sel| {
-            sel.text = None;
-            sel.cells = None;
-            sel.shapes = next.clone();
-        })?;
-    } else {
-        s.edit(|doc, sel| {
-            let shapes = crate::shapes_mut(doc, sel).ok_or_else(|| bad("selection.select", "no slide"))?;
-            for id in &reveal {
-                if let Some(sh) = deckcraft_model::find_shape_mut(shapes, *id) {
-                    sh.hidden = false;
-                }
-            }
-            sel.text = None;
-            sel.cells = None;
-            sel.shapes = next.clone();
-            Ok(())
-        })?;
-    }
-    Ok(json!({"selected": s.doc()?.selection.shapes}))
-}
-
-fn show_all(s: &mut Session, _p: &Value) -> Result<Value> {
-    fn any_hidden(v: &[Shape]) -> bool {
-        let mut found = false;
-        deckcraft_model::walk(v, &mut |sh, _| found |= sh.hidden);
-        found
-    }
-    if !any_hidden(s.doc()?.shapes()) {
-        return ok();
-    }
-    s.edit(|doc, sel| {
-        fn rec(v: &mut [Shape], depth: usize) {
-            for sh in v {
-                sh.hidden = false;
-                if depth < 64
-                    && let Some(c) = sh.children_mut()
-                {
-                    rec(c, depth + 1);
-                }
-            }
-        }
-        rec(crate::shapes_mut(doc, sel).ok_or_else(|| bad("selection.showAll", "no slide"))?, 0);
-        Ok(())
-    })?;
-    ok()
-}
-
-fn hide_all(s: &mut Session, _p: &Value) -> Result<Value> {
-    if s.doc()?.shapes().iter().all(|x| x.hidden) {
-        return ok();
-    }
-    s.edit(|doc, sel| {
-        for sh in crate::shapes_mut(doc, sel).ok_or_else(|| bad("selection.hideAll", "no slide"))? {
-            sh.hidden = true;
-        }
-        Ok(())
-    })?;
-    ok()
-}
-
-#[cfg(test)]
-#[path = "selection_tests.rs"]
-mod tests;

crates/engine/src/cmd/selection_tests.rs

@@ -1,264 +0,0 @@
-//! Selection pane: reorder, groups, hide/show, lock and undo.
-
-use serde_json::{Value, json};
-
-use crate::tools::{Mods, PointerEvent, PointerKind};
-use crate::*;
-
-/// A blank slide with A, B, C (back to front) and G = group [D, H = group [E, F]] in front.
-fn deck() -> (Session, Vec<u32>) {
-    let mut s = Session::with_new();
-    s.execute("slide.new", &json!({"layout": "blank"})).unwrap();
-    let mut ids = vec![];
-    for (i, n) in ["A", "B", "C", "D", "E", "F"].iter().enumerate() {
-        let x = 20.0 + 110.0 * i as f64;
-        let r = s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, 50, 100, 80]})).unwrap();
-        let id = r["id"].as_u64().unwrap() as u32;
-        s.execute("shape.rename", &json!({"id": id, "name": n})).unwrap();
-        ids.push(id);
-    }
-    let h = s.execute("arrange.group", &json!({"ids": [ids[4], ids[5]]})).unwrap()["id"].as_u64().unwrap() as u32;
-    s.execute("shape.rename", &json!({"id": h, "name": "H"})).unwrap();
-    let g = s.execute("arrange.group", &json!({"ids": [ids[3], h]})).unwrap()["id"].as_u64().unwrap() as u32;
-    s.execute("shape.rename", &json!({"id": g, "name": "G"})).unwrap();
-    ids.extend([h, g]);
-    (s, ids)
-}
-
-/// The tree as text, back to front: `A B C G[D H[E F]]`.
-fn tree(s: &Session) -> String {
-    fn rec(v: &[deckcraft_model::Shape]) -> String {
-        v.iter().map(|x| if x.is_group() { format!("{}[{}]", x.name, rec(x.children())) } else { x.name.clone() }).collect::<Vec<_>>().join(" ")
-    }
-    rec(s.doc().unwrap().shapes())
-}
-
-/// (hidden, locked)
-fn flags(s: &Session, id: u32) -> (bool, bool) {
-    let sh = s.doc().unwrap().shape(deckcraft_model::ShapeId(id)).unwrap();
-    (sh.hidden, sh.locked)
-}
-
-fn selected(s: &Session) -> Vec<u32> {
-    s.doc().unwrap().selection.shapes.iter().map(|i| i.0).collect()
-}
-
-fn undo(s: &mut Session) {
-    s.execute("edit.undo", &json!({})).unwrap();
-}
-
-fn bx(s: &mut Session, id: u32) -> Value {
-    s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"].clone()
-}
-
-#[test]
-fn bring_forward_and_send_backward_stay_inside_the_group() {
-    let (mut s, ids) = deck();
-    let (a, d, e, h) = (ids[0], ids[3], ids[4], ids[6]);
-    assert_eq!(tree(&s), "A B C G[D H[E F]]");
-    s.execute("arrange.bringForward", &json!({"ids": [a]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[D H[E F]]");
-    // A child moves among its siblings only and stops at the group's front.
-    s.execute("arrange.bringForward", &json!({"ids": [d]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[H[E F] D]");
-    s.execute("arrange.bringForward", &json!({"ids": [d]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[H[E F] D]");
-    s.execute("arrange.sendBackward", &json!({"ids": [e]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[H[E F] D]", "E is already at the back of H");
-    s.execute("arrange.bringToFront", &json!({"ids": [e]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[H[F E] D]");
-    s.execute("arrange.sendToBack", &json!({"ids": [d]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[D H[F E]]");
-    s.execute("arrange.bringForward", &json!({"ids": [h]})).unwrap();
-    assert_eq!(tree(&s), "B A C G[D H[F E]]", "H is already in front inside G");
-    // Steps that changed nothing left no undo step.
-    undo(&mut s);
-    assert_eq!(tree(&s), "B A C G[H[F E] D]");
-    undo(&mut s);
-    undo(&mut s);
-    assert_eq!(tree(&s), "B A C G[D H[E F]]");
-}
-
-#[test]
-fn reorder_is_the_drag_and_drop_among_siblings() {
-    let (mut s, ids) = deck();
-    let (a, c, d, f, g) = (ids[0], ids[2], ids[3], ids[5], ids[7]);
-    // Drag A to the front of the slide (an index past the end clamps).
-    assert_eq!(s.execute("arrange.reorder", &json!({"id": a, "index": 99})).unwrap()["index"], 3);
-    assert_eq!(tree(&s), "B C G[D H[E F]] A");
-    s.execute("arrange.reorder", &json!({"id": g, "index": 0})).unwrap();
-    assert_eq!(tree(&s), "G[D H[E F]] B C A");
-    // A child is dragged within its group: it never leaves it.
-    s.execute("arrange.reorder", &json!({"id": d, "index": 5})).unwrap();
-    assert_eq!(tree(&s), "G[H[E F] D] B C A");
-    s.execute("arrange.reorder", &json!({"id": f, "index": 0})).unwrap();
-    assert_eq!(tree(&s), "G[H[F E] D] B C A");
-    // Dropping where it already is changes nothing (no undo step).
-    let n = s.doc().unwrap().history.undo.len();
-    s.execute("arrange.reorder", &json!({"id": c, "index": 2})).unwrap();
-    assert_eq!(s.doc().unwrap().history.undo.len(), n);
-    // One undo step per drop.
-    undo(&mut s);
-    assert_eq!(tree(&s), "G[H[E F] D] B C A");
-    undo(&mut s);
-    undo(&mut s);
-    undo(&mut s);
-    assert_eq!(tree(&s), "A B C G[D H[E F]]");
-    assert!(s.execute("arrange.reorder", &json!({"id": 4242, "index": 0})).is_err());
-    assert!(s.execute("arrange.reorder", &json!({"id": a})).is_err());
-}
-
-#[test]
-fn eye_show_all_and_hide_all() {
-    let (mut s, ids) = deck();
-    let (a, b, d, e, g) = (ids[0], ids[1], ids[3], ids[4], ids[7]);
-    s.execute("shape.visible", &json!({"id": b, "visible": false})).unwrap();
-    assert!(flags(&s, b).0);
-    // Hiding a group hides only the group; its children keep their own flags.
-    s.execute("shape.visible", &json!({"id": g})).unwrap();
-    assert!(flags(&s, g).0 && !flags(&s, d).0);
-    s.execute("shape.visible", &json!({"id": e, "visible": false})).unwrap();
-    // Hide All hides the top level only.
-    s.execute("selection.hideAll", &json!({})).unwrap();
-    assert!(flags(&s, a).0 && flags(&s, g).0 && !flags(&s, d).0 && flags(&s, e).0);
-    // Show All shows everything, children included.
-    s.execute("selection.showAll", &json!({})).unwrap();
-    for id in &ids {
-        assert!(!flags(&s, *id).0, "{id} still hidden");
-    }
-    let n = s.doc().unwrap().history.undo.len();
-    s.execute("selection.showAll", &json!({})).unwrap();
-    assert_eq!(s.doc().unwrap().history.undo.len(), n, "nothing to show: no undo step");
-    undo(&mut s);
-    assert!(flags(&s, a).0 && flags(&s, e).0);
-    undo(&mut s);
-    assert!(!flags(&s, a).0 && flags(&s, g).0 && flags(&s, e).0);
-}
-
-#[test]
-fn lock_cascades_through_groups_and_undoes() {
-    let (mut s, ids) = deck();
-    let (a, d, e, h, g) = (ids[0], ids[3], ids[4], ids[6], ids[7]);
-    s.execute("shape.lock", &json!({"id": a})).unwrap();
-    assert!(flags(&s, a).1);
-    s.execute("shape.lock", &json!({"id": a})).unwrap();
-    assert!(!flags(&s, a).1, "toggles");
-    // Locking a group locks everything in it.
-    s.execute("shape.lock", &json!({"id": g, "locked": true})).unwrap();
-    assert!(flags(&s, g).1 && flags(&s, d).1 && flags(&s, h).1 && flags(&s, e).1);
-    // A child can be unlocked on its own.
-    s.execute("shape.lock", &json!({"id": d, "locked": false})).unwrap();
-    assert!(flags(&s, g).1 && !flags(&s, d).1);
-    // Unlocking the group unlocks everything in it.
-    s.execute("shape.lock", &json!({"id": g})).unwrap();
-    assert!(!flags(&s, g).1 && !flags(&s, h).1 && !flags(&s, e).1);
-    undo(&mut s);
-    assert!(flags(&s, g).1 && !flags(&s, d).1 && flags(&s, e).1);
-    undo(&mut s);
-    undo(&mut s);
-    assert!(!flags(&s, g).1 && !flags(&s, e).1);
-}
-
-#[test]
-fn locked_objects_refuse_moving_sizing_rotating_but_take_formatting() {
-    let (mut s, ids) = deck();
-    let (a, b) = (ids[0], ids[1]);
-    s.execute("shape.lock", &json!({"id": a, "locked": true})).unwrap();
-    let before = bx(&mut s, a);
-    for (cmd, p) in [
-        ("shape.move", json!({"ids": [a], "dx": 10})),
-        ("shape.resize", json!({"ids": [a], "w": 300})),
-        ("shape.setBounds", json!({"ids": [a], "x": 1, "y": 1, "w": 2, "h": 2})),
-        ("shape.rotate", json!({"ids": [a], "deg": 45})),
-        ("shape.flip", json!({"ids": [a], "axis": "vertical"})),
-        ("arrange.align", json!({"ids": [a], "edge": "right"})),
-        ("shape.change", json!({"ids": [a], "preset": "ellipse"})),
-    ] {
-        assert!(s.execute(cmd, &p).is_err(), "{cmd} changed a locked shape");
-    }
-    assert_eq!(bx(&mut s, a), before);
-    // Mixed selections: the unlocked ones move, the locked one stays.
-    let bb = bx(&mut s, b);
-    s.execute("shape.move", &json!({"ids": [a, b], "dx": 10})).unwrap();
-    assert_eq!(bx(&mut s, a), before);
-    assert_eq!(bx(&mut s, b)["x"].as_f64().unwrap(), bb["x"].as_f64().unwrap() + 10.0);
-    // Formatting and the name still change.
-    s.execute("shape.fill", &json!({"ids": [a], "color": "#00ff00"})).unwrap();
-    s.execute("shape.rename", &json!({"id": a, "name": "Anchor"})).unwrap();
-    assert_eq!(s.doc().unwrap().shape(deckcraft_model::ShapeId(a)).unwrap().name, "Anchor");
-    // The arrow keys don't nudge it.
-    s.execute("edit.select", &json!({"ids": [a]})).unwrap();
-    let _ = s.key("ArrowRight", Mods::default());
-    assert_eq!(bx(&mut s, a), before);
-}
-
-#[test]
-fn locked_objects_are_picked_on_the_canvas_but_not_dragged() {
-    let (mut s, ids) = deck();
-    let a = ids[0];
-    s.prefs.snap_to_grid = false;
-    s.prefs.smart_guides = false;
-    s.execute("shape.lock", &json!({"id": a, "locked": true})).unwrap();
-    s.execute("edit.select", &json!({"ids": []})).unwrap();
-    let n = s.doc().unwrap().history.undo.len();
-    let ev = |kind, x, y| PointerEvent { kind, x, y, mods: Mods::default(), tol: 3.0 };
-    // A: x 20..120, y 50..130.
-    s.pointer(ev(PointerKind::Down, 60.0, 90.0)).unwrap();
-    assert_eq!(selected(&s), vec![a], "a click selects a locked object");
-    s.pointer(ev(PointerKind::Drag, 160.0, 190.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, 160.0, 190.0)).unwrap();
-    assert_eq!(bx(&mut s, a)["x"], 20.0);
-    // No resize handle: pressing on the SE corner and dragging doesn't size it.
-    s.pointer(ev(PointerKind::Down, 120.0, 130.0)).unwrap();
-    s.pointer(ev(PointerKind::Drag, 200.0, 200.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, 200.0, 200.0)).unwrap();
-    assert_eq!(bx(&mut s, a)["w"], 100.0);
-    assert_eq!(s.doc().unwrap().history.undo.len(), n, "no undo steps for gestures that changed nothing");
-}
-
-#[test]
-fn select_from_the_pane() {
-    let (mut s, ids) = deck();
-    let (a, b, c, d, e, g) = (ids[0], ids[1], ids[2], ids[3], ids[4], ids[7]);
-    s.execute("selection.select", &json!({"id": b})).unwrap();
-    assert_eq!(selected(&s), vec![b]);
-    s.execute("selection.select", &json!({"id": c, "toggle": true})).unwrap();
-    assert_eq!(selected(&s), vec![b, c]);
-    s.execute("selection.select", &json!({"id": b, "toggle": true})).unwrap();
-    assert_eq!(selected(&s), vec![c]);
-    s.execute("selection.select", &json!({"ids": [a, b], "add": true})).unwrap();
-    assert_eq!(selected(&s), vec![c, a, b]);
-    // A child inside a group; children across nesting levels go together.
-    s.execute("selection.select", &json!({"id": d})).unwrap();
-    assert_eq!(selected(&s), vec![d]);
-    s.execute("selection.select", &json!({"id": e, "toggle": true})).unwrap();
-    assert_eq!(selected(&s), vec![d, e]);
-    // ...but not with top-level objects: Ctrl+click on one is ignored.
-    s.execute("selection.select", &json!({"id": g, "toggle": true})).unwrap();
-    assert_eq!(selected(&s), vec![d, e]);
-    s.execute("selection.select", &json!({"id": a})).unwrap();
-    s.execute("selection.select", &json!({"id": d, "toggle": true})).unwrap();
-    assert_eq!(selected(&s), vec![a]);
-    // Picking makes no undo step...
-    let n = s.doc().unwrap().history.undo.len();
-    s.execute("selection.select", &json!({"id": b})).unwrap();
-    assert_eq!(s.doc().unwrap().history.undo.len(), n);
-    // ...unless it shows a hidden object again.
-    s.execute("shape.visible", &json!({"id": c, "visible": false})).unwrap();
-    s.execute("selection.select", &json!({"id": c})).unwrap();
-    assert_eq!(selected(&s), vec![c]);
-    assert!(!flags(&s, c).0, "picking a hidden object shows it");
-    undo(&mut s);
-    assert!(flags(&s, c).0);
-    assert!(s.execute("selection.select", &json!({"id": 4242})).is_err());
-}
-
-#[test]
-fn rename_from_the_pane_undoes() {
-    let (mut s, ids) = deck();
-    let e = ids[4];
-    s.execute("shape.rename", &json!({"id": e, "name": "Eagle"})).unwrap();
-    assert_eq!(s.doc().unwrap().shape(deckcraft_model::ShapeId(e)).unwrap().name, "Eagle");
-    undo(&mut s);
-    assert_eq!(s.doc().unwrap().shape(deckcraft_model::ShapeId(e)).unwrap().name, "E");
-}

crates/engine/src/cmd/shape.rs

@@ -76,15 +76,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("shape.rename", "Rename", ["Selection Pane"], None, "{name, id?}", has_selection, rename),
         cmd!("shape.altText", "Alt Text", ["Shape Format", "Accessibility"], None, "{text, decorative?: bool, ids?}", has_selection, alt_text),
         cmd!("shape.visible", "Show/Hide", ["Selection Pane"], None, "{visible?: bool, ids?}", has_selection, visible),
-        cmd!(
-            "shape.lock",
-            "Lock",
-            ["Selection Pane"],
-            None,
-            "{locked?: bool (default: toggle), ids?} (a group locks or unlocks with everything in it)",
-            has_selection,
-            lock
-        ),
+        cmd!("shape.lock", "Lock", [], None, "{locked?: bool, ids?}", has_selection, lock),
         cmd!("shape.setDefault", "Set as Default Shape", [], None, "{}", has_selection, set_default),
         cmd!("picture.crop", "Crop", ["Picture Format", "Size"], None, "{left?, top?, right?, bottom?: fraction 0..1, ids?}", has_selection, crop),
         cmd!(
@@ -121,7 +113,7 @@ pub fn specs() -> Vec<CommandSpec> {
 fn move_by(s: &mut Session, p: &Value) -> Result<Value> {
     let (dx, dy) = (f64_param(p, "dx"), f64_param(p, "dy"));
     let (ax, ay) = (f64_param(p, "x"), f64_param(p, "y"));
-    edit_geometry(s, p, "shape.move", |sh| {
+    edit_shapes(s, p, "shape.move", |sh| {
         if let Some(x) = sh.xfrm.as_mut() {
             x.x = ax.unwrap_or(x.x) + dx.unwrap_or(0.0);
             x.y = ay.unwrap_or(x.y) + dy.unwrap_or(0.0);
@@ -133,7 +125,7 @@ fn move_by(s: &mut Session, p: &Value) -> Result<Value> {
 fn resize(s: &mut Session, p: &Value) -> Result<Value> {
     let (w, h) = (f64_param(p, "w").map(|v| v.max(0.0)), f64_param(p, "h").map(|v| v.max(0.0)));
     let lock = bool_or(p, "lockAspect", false);
-    edit_geometry(s, p, "shape.resize", |sh| {
+    edit_shapes(s, p, "shape.resize", |sh| {
         if let Some(x) = sh.xfrm.as_mut() {
             let ar = if x.h > 0.0 { x.w / x.h } else { 1.0 };
             let (cx, cy) = (x.x + x.w / 2.0, x.y + x.h / 2.0);
@@ -162,7 +154,7 @@ fn resize(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
-    edit_geometry(s, p, "shape.setBounds", |sh| {
+    edit_shapes(s, p, "shape.setBounds", |sh| {
         if let Some(x) = sh.xfrm.as_mut() {
             x.x = f64_param(p, "x").unwrap_or(x.x);
             x.y = f64_param(p, "y").unwrap_or(x.y);
@@ -175,7 +167,7 @@ fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn rotate(s: &mut Session, p: &Value) -> Result<Value> {
     let (abs, by) = (f64_param(p, "deg"), f64_param(p, "by"));
-    edit_geometry(s, p, "shape.rotate", |sh| {
+    edit_shapes(s, p, "shape.rotate", |sh| {
         if let Some(x) = sh.xfrm.as_mut() {
             let r = abs.unwrap_or(x.rot) + by.unwrap_or(0.0);
             x.rot = ((r % 360.0) + 360.0) % 360.0;
@@ -186,7 +178,7 @@ fn rotate(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn flip(s: &mut Session, p: &Value) -> Result<Value> {
     let v = str_param(p, "axis").unwrap_or("horizontal").starts_with('v');
-    edit_geometry(s, p, "shape.flip", |sh| {
+    edit_shapes(s, p, "shape.flip", |sh| {
         if let Some(x) = sh.xfrm.as_mut() {
             if v {
                 x.flip_v = !x.flip_v;
@@ -201,7 +193,7 @@ fn flip(s: &mut Session, p: &Value) -> Result<Value> {
 fn adjust(s: &mut Session, p: &Value) -> Result<Value> {
     let i = usize_param(p, "index").unwrap_or(0).min(16);
     let v = f64_param(p, "value").ok_or_else(|| bad("shape.adjust", "missing `value`"))?;
-    edit_geometry(s, p, "shape.adjust", |sh| {
+    edit_shapes(s, p, "shape.adjust", |sh| {
         if let Geom::Preset { name, adj } = &mut sh.geom {
             let defaults = deckcraft_geom::preset::info(name).map(|x| x.defaults).unwrap_or(&[]);
             while adj.len() <= i {
@@ -219,7 +211,7 @@ fn adjust(s: &mut Session, p: &Value) -> Result<Value> {
 fn change(s: &mut Session, p: &Value) -> Result<Value> {
     let name = str_param(p, "preset").ok_or_else(|| bad("shape.change", "missing `preset`"))?;
     let info = deckcraft_geom::preset::info(name).ok_or_else(|| bad("shape.change", format!("unknown preset `{name}`")))?;
-    edit_geometry(s, p, "shape.change", |sh| {
+    edit_shapes(s, p, "shape.change", |sh| {
         sh.geom = Geom::preset(info.name);
         Ok(())
     })
@@ -261,7 +253,7 @@ pub(crate) fn gradient_param(v: &Value) -> Option<Gradient> {
             scaled: false,
         },
     };
-    Some(Gradient { tile: [0.0; 4], stops, shape, rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true) })
+    Some(Gradient { stops, shape, rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true) })
 }
 
 fn fill(s: &mut Session, p: &Value) -> Result<Value> {
@@ -578,30 +570,14 @@ fn visible(s: &mut Session, p: &Value) -> Result<Value> {
     })
 }
 
-/// Lock: a locked object can be selected, formatted and typed in, but not moved, sized, rotated,
-/// flipped, reshaped or cropped. Locking or unlocking a group does the same to everything in it
-/// (a child can still be unlocked on its own afterwards), as PowerPoint does.
 fn lock(s: &mut Session, p: &Value) -> Result<Value> {
     let v = bool_param(p, "locked");
     edit_shapes(s, p, "shape.lock", |sh| {
-        let to = v.unwrap_or(!sh.locked);
-        set_locked(sh, to, 0);
+        sh.locked = v.unwrap_or(!sh.locked);
         Ok(())
     })
 }
 
-fn set_locked(sh: &mut deckcraft_model::Shape, to: bool, depth: usize) {
-    sh.locked = to;
-    if depth > 64 {
-        return;
-    }
-    if let Some(children) = sh.children_mut() {
-        for c in children {
-            set_locked(c, to, depth + 1);
-        }
-    }
-}
-
 fn set_default(s: &mut Session, _p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let Some(sh) = st.selected_shapes().first().map(|x| (*x).clone()) else { return ok() };
@@ -619,7 +595,7 @@ fn set_default(s: &mut Session, _p: &Value) -> Result<Value> {
 
 fn crop(s: &mut Session, p: &Value) -> Result<Value> {
     let c = [f64_param(p, "left"), f64_param(p, "top"), f64_param(p, "right"), f64_param(p, "bottom")];
-    edit_geometry(s, p, "picture.crop", |sh| {
+    edit_shapes(s, p, "picture.crop", |sh| {
         if let deckcraft_model::ShapeKind::Picture { fill } = &mut sh.kind {
             for (i, v) in c.iter().enumerate() {
                 if let (Some(v), Some(slot)) = (v, fill.crop.get_mut(i)) {

crates/engine/src/cmd/text.rs

@@ -17,38 +17,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "text.exit", "Stop Editing Text", [], None, "{}", has_doc, exit),
         cmd!("text.insert", "Type Text", [], None, "{text} (\\n = new paragraph, \\u000b = line break)", has_text, insert),
         cmd!("text.delete", "Delete Text", [], Some("Backspace"), "{dir?: backward|forward|wordBackward|wordForward}", has_text, delete),
-        // The input method's composition: shown in place, an undo step only once committed.
-        CommandSpec {
-            id: "text.compose",
-            label: "Compose Text",
-            menu: &[],
-            shortcut: None,
-            params: "{text, active?: [start, end]} — an input method's composition (preedit) at the insertion point; empty text cancels it",
-            enabled: has_text,
-            run: compose,
-            journal: false,
-            undoable: false,
-        },
-        cmd!(
-            noundo "text.commit",
-            "Commit Composition",
-            [],
-            None,
-            "{text} — the input method's result replaces its composition, as one undo step",
-            has_text,
-            commit
-        ),
         cmd!(noundo "text.move", "Move Insertion Point", [], None, "{to: left|right|up|down|wordLeft|wordRight|lineStart|lineEnd|paraStart|paraEnd|start|end, extend?: bool}", has_text, move_caret),
-        cmd!(
-            "text.delete",
-            "Delete Text",
-            [],
-            Some("Backspace"),
-            "{dir?: backward|forward|wordBackward|wordForward} — the word directions are Ctrl+Backspace/Delete: they work from the start of a selection without deleting it",
-            has_text,
-            delete
-        ),
-        cmd!(noundo "text.move", "Move Insertion Point", [], None, "{to: left|right|up|down|wordLeft|wordRight|lineStart|lineEnd|paraStart|paraEnd|paraUp|paraDown|start|end, extend?: bool} — left/right are on screen: in a right-to-left paragraph left goes forward", has_text, move_caret),
         cmd!(noundo "text.select", "Select Text", [], None, "{anchor: [p, c], caret: [p, c]}", has_text, select),
         cmd!(noundo "text.selectAll", "Select All Text", [], None, "{}", has_text, select_all),
         cmd!(noundo "text.selectWord", "Select Word", [], None, "{at?: [p, c]}", has_text, select_word),
@@ -175,35 +144,6 @@ pub fn layout_for(st: &DocState, t: &TextSel) -> Option<deckcraft_text::TextLayo
     ))
 }
 
-/// The insertion point on the slide: its line from top to bottom, in slide coordinates (flips and
-/// vertical text as drawn). Text with no paragraph yet (a placeholder about to be typed in) is
-/// measured as one empty paragraph, so the caret shows where typing begins. `None` for notes and
-/// table cells, which aren't laid out on the slide here.
-pub fn caret_line(st: &DocState, t: &TextSel) -> Option<(deckcraft_geom::Point, deckcraft_geom::Point)> {
-    if t.notes || t.cell.is_some() {
-        return None;
-    }
-    let sh = st.shape(t.shape)?;
-    let ctx = ctx_for(&st.doc, &st.selection)?;
-    let x = xfrm_of(&st.doc, &st.selection, sh);
-    let geo = deckcraft_render::shape_geometry(sh, x.w, x.h);
-    let mut body = sh.text.clone().unwrap_or_default();
-    if body.paragraphs.is_empty() {
-        body.paragraphs.push(deckcraft_model::text::Paragraph::default());
-    }
-    let l = deckcraft_text::layout(
-        &ctx,
-        sh,
-        &body,
-        &deckcraft_text::Opts { rect: geo.text_rect, fields: &deckcraft_text::NoFields, prompt_color: None, no_shrink: false },
-    );
-    // After End on a wrapped line the caret is drawn at that line's end.
-    let aff = if t.at_line_end() { deckcraft_text::Affinity::Upstream } else { deckcraft_text::Affinity::Downstream };
-    let (cx, top, bot) = l.caret_drawn(deckcraft_text::Pos { para: t.caret.0, ch: t.caret.1 }, aff)?;
-    let m = deckcraft_render::text_transform(x.affine(), geo.text_rect, l.rotation);
-    Some((m * deckcraft_geom::Point::new(cx, top), m * deckcraft_geom::Point::new(cx, bot)))
-}
-
 fn pos_param(p: &Value, key: &str) -> Option<Pos> {
     let a = p.get(key)?.as_array()?;
     Some((a.first()?.as_u64()? as usize, a.get(1)?.as_u64()? as usize))
@@ -244,7 +184,7 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {
     }
     s.select(|_, sel| {
         sel.shapes = vec![id];
-        sel.text = Some(TextSel { shape: id, anchor: at, caret: at, cell, notes: false, line_end: None });
+        sel.text = Some(TextSel { shape: id, anchor: at, caret: at, cell, notes: false });
     })?;
     Ok(json!({"id": id, "at": [at.0, at.1]}))
 }
@@ -400,112 +340,6 @@ pub(crate) fn insert_field(s: &mut Session, field: &str, text: &str) -> Result<V
     ok()
 }
 
-/// Text an input method sends: no paragraph or line breaks (Enter is a key of its own).
-fn ime_text(s: &str) -> String {
-    s.chars().filter(|c| !c.is_control()).collect()
-}
-
-/// Is the composition still where it was put (the paragraph holds all of it)?
-fn composition_fits(st: &DocState, c: &crate::Composition) -> bool {
-    let Some(t) = &st.selection.text else { return false };
-    let Some(body) = body_of(st, t) else { return false };
-    body.paragraphs.get(c.start.0).is_some_and(|p| c.start.1.saturating_add(c.len) <= p.char_len())
-}
-
-/// `text.compose`: put an input method's preedit at the insertion point (replacing the selection)
-/// or replace the composition with the new preedit. An empty preedit cancels: the presentation
-/// goes back to how it was before the composition began.
-fn compose(s: &mut Session, p: &Value) -> Result<Value> {
-    let text = ime_text(str_param(p, "text").ok_or_else(|| bad("text.compose", "missing `text`"))?);
-    let n = text.chars().count();
-    let active = p.get("active").and_then(Value::as_array).and_then(|a| {
-        let (x, y) = (a.first()?.as_u64()? as usize, a.get(1)?.as_u64()? as usize);
-        (x < y).then_some((x.min(n), y.min(n)))
-    });
-    let current = s.doc()?.composition.clone();
-    // A composition whose text was changed under it is kept as it is; a new one starts.
-    let current = match current {
-        Some(c) if !composition_fits(s.doc()?, &c) => {
-            s.end_composition();
-            None
-        }
-        c => c,
-    };
-    match current {
-        None if text.is_empty() => Ok(json!({"composing": false})),
-        None => {
-            let st = s.doc()?;
-            let (before, before_selection) = (st.doc.clone(), st.selection.clone());
-            let (start, props) = edit_text(s, |body, t| {
-                let (a, b) = t.ordered();
-                let at = ed::delete(body, a, b);
-                let props = if a != b { Some(ed::props_at(body, at)) } else { unlinked_at_link_end(body, at) };
-                let c = ed::insert(body, at, &text, props.clone());
-                t.anchor = c;
-                t.caret = c;
-                (at, props)
-            })?;
-            s.doc_mut()?.composition = Some(crate::Composition { start, len: n, active, props, before, before_selection });
-            Ok(json!({"composing": true, "start": [start.0, start.1], "len": n}))
-        }
-        Some(c) if text.is_empty() => {
-            let st = s.doc_mut()?;
-            st.doc = c.before;
-            st.selection = c.before_selection;
-            st.composition = None;
-            st.revision += 1;
-            Ok(json!({"composing": false}))
-        }
-        Some(c) => {
-            let (start, len, props) = (c.start, c.len, c.props.clone());
-            edit_text(s, |body, t| {
-                ed::delete(body, start, (start.0, start.1 + len));
-                let e = ed::insert(body, start, &text, props);
-                t.anchor = e;
-                t.caret = e;
-            })?;
-            s.doc_mut()?.composition = Some(crate::Composition { len: n, active, ..c });
-            Ok(json!({"composing": true, "start": [start.0, start.1], "len": n}))
-        }
-    }
-}
-
-/// `text.commit`: the input method's result replaces the composition (or is typed at the
-/// insertion point when there is none) and the whole composition becomes one undo step.
-fn commit(s: &mut Session, p: &Value) -> Result<Value> {
-    let text = ime_text(str_param(p, "text").ok_or_else(|| bad("text.commit", "missing `text`"))?);
-    if s.doc()?.composition.is_some() || !text.is_empty() {
-        compose(s, &json!({"text": text}))?;
-    }
-    s.end_composition();
-    let caret = s.doc()?.selection.text.as_ref().map(|t| t.caret).unwrap_or_default();
-    Ok(json!({"caret": [caret.0, caret.1]}))
-}
-
-/// Underlines under an input method's composition (#101), in slide coordinates: `(from, to,
-/// thick)` per line, thick under the part being converted. Empty without a composition or when
-/// the edited text isn't laid out on the slide (notes, table cells).
-pub fn composition_underlines(st: &DocState) -> Vec<(deckcraft_geom::Point, deckcraft_geom::Point, bool)> {
-    let (Some(c), Some(t)) = (&st.composition, &st.selection.text) else { return vec![] };
-    let Some(sh) = st.shape(t.shape) else { return vec![] };
-    let Some(l) = layout_for(st, t) else { return vec![] };
-    let x = xfrm_of(&st.doc, &st.selection, sh);
-    let tr = deckcraft_render::shape_geometry(sh, x.w, x.h).text_rect;
-    let m = deckcraft_render::text_transform(x.affine(), tr, l.rotation);
-    let pos = |ch: usize| deckcraft_text::Pos { para: c.start.0, ch: c.start.1 + ch };
-    let mut out = vec![];
-    let mut add = |a: usize, b: usize, thick: bool| {
-        for (x0, x1, y) in l.composition_underlines(pos(a), pos(b)) {
-            out.push((m * deckcraft_geom::Point::new(x0, y), m * deckcraft_geom::Point::new(x1, y), thick));
-        }
-    };
-    add(0, c.len, false);
-    if let Some((a, b)) = c.active {
-        add(a, b.min(c.len), true);
-    }
-    out
-}
-
 fn insert(s: &mut Session, p: &Value) -> Result<Value> {
     let text = str_param(p, "text").ok_or_else(|| bad("text.insert", "missing `text`"))?.to_string();
     insert_text(s, &text, None)
@@ -515,15 +349,13 @@ pub(crate) fn delete_dir(s: &mut Session, dir: &str) -> Result<Value> {
     let dir = dir.to_string();
     edit_text(s, move |body, t| {
         let (a, b) = t.ordered();
-        let at = if dir == "wordBackward" || dir == "wordForward" {
-            // Ctrl+Backspace/Delete work from the start of a selection and leave the rest of it
-            // (PowerPoint for Windows).
-            ed::delete_word(body, a, dir == "wordForward")
-        } else if a != b {
+        let at = if a != b {
             ed::delete(body, a, b)
         } else {
             let other = match dir.as_str() {
                 "forward" => ed::char_move(body, a, true),
+                "wordBackward" => ed::word_move(body, a, false),
+                "wordForward" => ed::word_move(body, a, true),
                 _ => {
                     // Backspace at the start of an indented/bulleted paragraph outdents first.
                     if a.1 == 0
@@ -550,16 +382,7 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
     delete_dir(s, str_param(p, "dir").unwrap_or("backward"))
 }
 
-/// Is paragraph `para` right-to-left (its lines run from the right)?
-fn para_rtl(layout: Option<&deckcraft_text::TextLayout>, body: &TextBody, para: usize) -> bool {
-    match layout.and_then(|l| l.lines.iter().find(|x| x.para == para)) {
-        Some(line) => line.rtl,
-        None => body.paragraphs.get(para).and_then(|x| x.props.rtl).unwrap_or(false),
-    }
-}
-
 fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {
-    use deckcraft_text::Affinity;
     let to = str_param(p, "to").unwrap_or("right").to_string();
     let extend = bool_or(p, "extend", false);
     let st = s.doc()?;
@@ -568,44 +391,27 @@ fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {
     let layout = layout_for(st, &t);
     let lp = |c: Pos| deckcraft_text::Pos { para: c.0, ch: c.1 };
     let caret = t.caret;
-    let aff = if t.at_line_end() { Affinity::Upstream } else { Affinity::Downstream };
-    // Left and right are on screen: in a right-to-left paragraph left goes forward in the text.
-    let rtl = para_rtl(layout.as_ref(), &body, caret.0);
-    let to = match (to.as_str(), rtl) {
-        ("left", true) => "right",
-        ("right", true) => "left",
-        ("wordLeft", true) => "wordRight",
-        ("wordRight", true) => "wordLeft",
-        (x, _) => x,
-    }
-    .to_string();
     let collapse_to = |left: bool| if left { t.ordered().0 } else { t.ordered().1 };
-    let mut upstream = false;
     let new = match to.as_str() {
         "left" if t.is_range() && !extend => collapse_to(true),
         "right" if t.is_range() && !extend => collapse_to(false),
         "left" => ed::char_move(&body, caret, false),
         "right" => ed::char_move(&body, caret, true),
-        // Ctrl+arrows with a selection go on from its start (left) or end (right).
-        "wordLeft" => ed::word_move(&body, if extend { caret } else { collapse_to(true) }, false),
-        "wordRight" => ed::word_move(&body, if extend { caret } else { collapse_to(false) }, true),
+        "wordLeft" => ed::word_move(&body, caret, false),
+        "wordRight" => ed::word_move(&body, caret, true),
         "paraStart" => (caret.0, 0),
         "paraEnd" => (caret.0, body.paragraphs.get(caret.0).map(|x| x.char_len()).unwrap_or(0)),
-        "paraUp" => ed::para_up(&body, caret),
-        "paraDown" => ed::para_down(&body, caret),
         "start" => (0, 0),
         "end" => ed::end(&body),
         "up" | "down" | "lineStart" | "lineEnd" => match &layout {
             Some(l) => {
-                let x = l.caret_drawn(lp(caret), aff).map(|c| c.0).unwrap_or(0.0);
-                let (r, a) = match to.as_str() {
-                    "up" => l.vertical_affine(lp(caret), aff, false, x),
-                    "down" => l.vertical_affine(lp(caret), aff, true, x),
-                    "lineStart" => (l.line_bounds_affine(lp(caret), aff).0, Affinity::Downstream),
-                    // End stays on its line: after a soft wrap the caret sits at the line's end.
-                    _ => l.line_end_caret(lp(caret), aff),
+                let x = l.caret(lp(caret)).map(|c| c.0).unwrap_or(0.0);
+                let r = match to.as_str() {
+                    "up" => l.vertical(lp(caret), false, x),
+                    "down" => l.vertical(lp(caret), true, x),
+                    "lineStart" => l.line_bounds(lp(caret)).0,
+                    _ => l.line_bounds(lp(caret)).1,
                 };
-                upstream = a == Affinity::Upstream;
                 (r.para, r.ch)
             }
             None => match to.as_str() {
@@ -621,13 +427,12 @@ fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {
     s.select(|_, sel| {
         if let Some(tt) = sel.text.as_mut() {
             tt.caret = new;
-            tt.line_end = if upstream { Some(new) } else { None };
             if !extend {
                 tt.anchor = new;
             }
         }
     })?;
-    Ok(json!({"caret": [new.0, new.1], "lineEnd": upstream}))
+    Ok(json!({"caret": [new.0, new.1]}))
 }
 
 fn select(s: &mut Session, p: &Value) -> Result<Value> {
@@ -674,14 +479,11 @@ fn select_para(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let t = st.selection.text.clone().ok_or_else(|| bad("text.selectParagraph", "not editing text"))?;
     let at = pos_param(p, "at").unwrap_or(t.caret);
-    let body = body_of(st, &t);
-    let n = body.and_then(|b| b.paragraphs.get(at.0)).map(|x| x.char_len()).unwrap_or(0);
-    // The paragraph mark is part of the paragraph (PowerPoint's triple-click selects it too).
-    let end = if body.is_some_and(|b| at.0 + 1 < b.paragraphs.len()) { (at.0 + 1, 0) } else { (at.0, n) };
+    let n = body_of(st, &t).and_then(|b| b.paragraphs.get(at.0)).map(|x| x.char_len()).unwrap_or(0);
     s.select(|_, sel| {
         if let Some(t) = sel.text.as_mut() {
             t.anchor = (at.0, 0);
-            t.caret = end;
+            t.caret = (at.0, n);
         }
     })?;
     ok()

crates/engine/src/fonts.rs

@@ -1,65 +0,0 @@
-//! Fonts a presentation uses that this machine doesn't have, so opening it can say so (its text
-//! draws in a stand-in; see `FontDb::document_face`).
-
-use deckcraft_fonts::FontDb;
-use deckcraft_model::resolve::{self, Ctx};
-use deckcraft_model::text::{Bullet, TextBody};
-use deckcraft_model::{Presentation, Shape, ShapeKind};
-
-/// The font families the slides' text is drawn in (theme fonts resolved, bullet fonts included)
-/// that aren't installed or bundled, sorted, without duplicates (case-insensitive).
-pub fn missing_fonts(p: &Presentation) -> Vec<String> {
-    let db = FontDb::global();
-    let mut out: Vec<String> = Vec::new();
-    for family in used_fonts(p) {
-        if !db.has_family(&family) && !out.iter().any(|f| f.eq_ignore_ascii_case(&family)) {
-            out.push(family);
-        }
-    }
-    out.sort_by_key(|f| f.to_lowercase());
-    out
-}
-
-/// The families the slides' text runs and bullets are drawn in.
-fn used_fonts(p: &Presentation) -> Vec<String> {
-    let mut out: Vec<String> = Vec::new();
-    let mut add = |f: String| {
-        let f = f.trim().to_string();
-        if !f.is_empty() && !out.iter().any(|o| o.eq_ignore_ascii_case(&f)) {
-            out.push(f);
-        }
-    };
-    for slide in &p.slides {
-        let Some(ctx) = Ctx::for_slide(p, slide) else { continue };
-        deckcraft_model::walk(&slide.shapes, &mut |s, _| {
-            if let Some(body) = &s.text {
-                body_fonts(&ctx, s, body, &mut add);
-            }
-            if let ShapeKind::Table(t) = &s.kind {
-                for cell in t.rows.iter().flat_map(|r| &r.cells) {
-                    body_fonts(&ctx, s, &cell.text, &mut add);
-                }
-            }
-        });
-    }
-    out
-}
-
-fn body_fonts(ctx: &Ctx, s: &Shape, body: &TextBody, add: &mut dyn FnMut(String)) {
-    for para in &body.paragraphs {
-        let has_text = para.runs.iter().any(|r| !r.text.trim().is_empty());
-        if !has_text {
-            continue;
-        }
-        for run in para.runs.iter().filter(|r| !r.text.trim().is_empty()) {
-            let r = resolve::run(ctx, s, para, &run.props);
-            add(resolve::font_family(ctx, &r));
-        }
-        let pp = resolve::para(ctx, s, para);
-        if matches!(pp.bullet, Some(Bullet::Char { .. }))
-            && let Some(f) = pp.bullet_font.as_deref()
-        {
-            add(ctx.master.theme.font(f));
-        }
-    }
-}

crates/engine/src/keys.rs

@@ -20,49 +20,28 @@ pub fn shortcut_matches(shortcut: &str, key: &str, mods: Mods) -> bool {
     k.eq_ignore_ascii_case(key) && (has("cmd") || has("ctrl")) == mods.cmd && has("shift") == mods.shift && (has("alt") || has("option")) == mods.alt
 }
 
-/// A key name in one spelling: lower case, `ArrowLeft` → `left`, and egui's names for
-/// punctuation keys (`Period`, `CloseBracket`…) → the character, so `Cmd+Shift+.` matches the
-/// key egui reports for Ctrl+Shift+> and `Cmd+]` the one for Ctrl+].
-pub fn key_token(key: &str) -> String {
-    let k = key.to_ascii_lowercase();
-    let k = k.trim_start_matches("arrow");
-    match k {
-        "period" | ">" => ".",
-        "comma" | "<" => ",",
-        "openbracket" | "{" => "[",
-        "closebracket" | "}" => "]",
-        "equals" => "=",
-        "minus" => "-",
-        "plus" => "+",
-        "slash" => "/",
-        "backslash" => "\\",
-        "semicolon" => ";",
-        "quote" => "'",
-        "backtick" => "`",
-        other => other,
-    }
-    .to_string()
-}
-
 impl Session {
     /// Handle one key press. `key` is a name (`Enter`, `Escape`, `Backspace`, `Delete`, `Tab`,
     /// `ArrowLeft`…, `Home`, `End`, `PageUp`, `PageDown`, `F5`) or a character (`b`, `]`).
     /// Returns `{handled: bool, …}`.
     pub fn key(&mut self, key: &str, mods: Mods) -> Result<Value> {
-        self.end_composition();
         let editing = self.active().is_some_and(|d| d.selection.text.is_some());
         let has_shapes = self.active().is_some_and(|d| !d.selection.shapes.is_empty());
-        let k = key_token(key);
-        let k = k.as_str();
+        let k = key.to_ascii_lowercase();
+        let k = k.trim_start_matches("arrow");
         if self.tool.drawing_freeform() && matches!(k, "enter" | "return" | "escape") {
             return self.finish_freeform(false);
         }
-        if editing && let Some((id, params)) = self.text_key(k, mods) {
-            let r = self.execute(id, &params)?;
-            return Ok(json!({"handled": true, "command": id, "result": r}));
-        }
         if editing && !mods.cmd {
             let r = match k {
+                "left" => Some(self.execute("text.move", &json!({"to": if mods.alt { "wordLeft" } else { "left" }, "extend": mods.shift}))),
+                "right" => Some(self.execute("text.move", &json!({"to": if mods.alt { "wordRight" } else { "right" }, "extend": mods.shift}))),
+                "up" => Some(self.execute("text.move", &json!({"to": if mods.alt { "paraStart" } else { "up" }, "extend": mods.shift}))),
+                "down" => Some(self.execute("text.move", &json!({"to": if mods.alt { "paraEnd" } else { "down" }, "extend": mods.shift}))),
+                "home" => Some(self.execute("text.move", &json!({"to": "lineStart", "extend": mods.shift}))),
+                "end" => Some(self.execute("text.move", &json!({"to": "lineEnd", "extend": mods.shift}))),
+                "backspace" => Some(self.execute("text.delete", &json!({"dir": if mods.alt { "wordBackward" } else { "backward" }}))),
+                "delete" => Some(self.execute("text.delete", &json!({"dir": if mods.alt { "wordForward" } else { "forward" }}))),
                 "enter" | "return" => Some(self.execute("text.insert", &json!({"text": if mods.shift { "\u{b}" } else { "\n" }}))),
                 "escape" | "esc" => Some(self.execute("text.exit", &json!({}))),
                 "tab" => {
@@ -137,10 +116,6 @@ impl Session {
         }
         // Shortcuts from the registry.
         let key_name = match k {
-            "left" => "Left",
-            "right" => "Right",
-            "up" => "Up",
-            "down" => "Down",
             "enter" | "return" => "Enter",
             "escape" | "esc" => "Escape",
             "delete" => "Delete",
@@ -151,7 +126,7 @@ impl Session {
             "end" => "End",
             "tab" => "Tab",
             "space" | " " => "Space",
-            _ => k,
+            _ => key,
         };
         let found = crate::command_specs().iter().find(|c| c.shortcut.is_some_and(|s| shortcut_matches(s, key_name, mods))).map(|c| c.id);
         if let Some(id) = found {
@@ -161,50 +136,6 @@ impl Session {
         Ok(json!({"handled": false}))
     }
 
-    /// The text-editing command for a navigation or deletion key while editing text, by
-    /// platform: Ctrl (Windows, Linux) or Option (Mac) moves and deletes by word; Ctrl+Up/Down
-    /// moves by paragraph; Ctrl+Home/End (Cmd+Up/Down on the Mac) go to the ends of the text and
-    /// Cmd+Left/Right on the Mac to the ends of the line. Shift extends the selection.
-    fn text_key(&self, k: &str, mods: Mods) -> Option<(&'static str, Value)> {
-        let word = if self.mac_keys { mods.alt && !mods.cmd } else { mods.cmd && !mods.alt };
-        let mac_cmd = self.mac_keys && mods.cmd && !mods.alt;
-        if mods.cmd && !mods.alt && !mods.shift {
-            // Ctrl+] / Ctrl+[ grow and shrink the font, like Ctrl+Shift+> / <.
-            match k {
-                "]" => return Some(("format.grow", json!({}))),
-                "[" => return Some(("format.shrink", json!({}))),
-                _ => {}
-            }
-        }
-        let plain = !mods.cmd && !mods.alt;
-        let to = match k {
-            "left" if word => "wordLeft",
-            "right" if word => "wordRight",
-            "left" if mac_cmd => "lineStart",
-            "right" if mac_cmd => "lineEnd",
-            "left" if plain => "left",
-            "right" if plain => "right",
-            "up" if mac_cmd => "start",
-            "down" if mac_cmd => "end",
-            "up" if word && self.mac_keys => "paraStart",
-            "down" if word && self.mac_keys => "paraEnd",
-            "up" if word => "paraUp",
-            "down" if word => "paraDown",
-            "up" if plain => "up",
-            "down" if plain => "down",
-            "home" if mods.cmd && !mods.alt => "start",
-            "end" if mods.cmd && !mods.alt => "end",
-            "home" if plain => "lineStart",
-            "end" if plain => "lineEnd",
-            "backspace" if word => return Some(("text.delete", json!({"dir": "wordBackward"}))),
-            "delete" if word => return Some(("text.delete", json!({"dir": "wordForward"}))),
-            "backspace" if plain => return Some(("text.delete", json!({"dir": "backward"}))),
-            "delete" if plain => return Some(("text.delete", json!({"dir": "forward"}))),
-            _ => return None,
-        };
-        Some(("text.move", json!({"to": to, "extend": mods.shift})))
-    }
-
     /// Type text: into the text being edited, or (a shape selected) start editing it.
     pub fn type_text(&mut self, text: &str) -> Result<Value> {
         let st = self.doc()?;
@@ -220,45 +151,6 @@ impl Session {
         self.execute("text.insert", &json!({"text": text}))
     }
 
-    /// An input method's preedit (#101). On a selected shape that isn't being edited, the first
-    /// one starts editing its text and replaces it, as typing does ([`Session::type_text`]).
-    /// `active` is the part being converted, in characters of `text`.
-    pub fn compose_text(&mut self, text: &str, active: Option<(usize, usize)>) -> Result<Value> {
-        if !self.start_typing(text)? {
-            return Ok(json!({"handled": false}));
-        }
-        let mut p = json!({"text": text});
-        if let Some((a, b)) = active {
-            p["active"] = json!([a, b]);
-        }
-        self.execute("text.compose", &p)
-    }
-
-    /// An input method's result (#101): replaces the composition as one undo step.
-    pub fn commit_text(&mut self, text: &str) -> Result<Value> {
-        if !self.start_typing(text)? {
-            return Ok(json!({"handled": false}));
-        }
-        self.execute("text.commit", &json!({"text": text}))
-    }
-
-    /// Ready to take typed `text`: editing text already, or one selected shape whose text editing
-    /// starts with everything selected. False when there is nowhere to type (or nothing to type
-    /// and nothing being edited).
-    fn start_typing(&mut self, text: &str) -> Result<bool> {
-        let st = self.doc()?;
-        if st.selection.text.is_some() {
-            return Ok(true);
-        }
-        let Some(id) = st.selection.shapes.first().copied() else { return Ok(false) };
-        if st.selection.shapes.len() != 1 || text.is_empty() {
-            return Ok(false);
-        }
-        self.execute("text.edit", &json!({"id": id}))?;
-        self.execute("text.selectAll", &json!({}))?;
-        Ok(true)
-    }
-
     fn cycle_selection(&mut self, forward: bool) -> Result<()> {
         let st = self.doc()?;
         let ids: Vec<_> = st.shapes().iter().filter(|s| !s.hidden).map(|s| s.id).collect();

crates/engine/src/lib.rs

@@ -9,7 +9,6 @@
 
 pub mod cmd;
 pub mod connect;
-pub mod fonts;
 pub mod guard;
 pub mod keys;
 pub mod links;
@@ -68,10 +67,6 @@ pub struct TextSel {
     /// Editing the slide's speaker notes (shape is ignored).
     #[serde(default)]
     pub notes: bool,
-    /// The caret position that sits at the end of a wrapped line (after End) rather than at the
-    /// start of the next line. Ignored once the caret moves anywhere else.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub line_end: Option<(usize, usize)>,
 }
 
 impl TextSel {
@@ -81,10 +76,6 @@ impl TextSel {
     pub fn ordered(&self) -> ((usize, usize), (usize, usize)) {
         if self.anchor <= self.caret { (self.anchor, self.caret) } else { (self.caret, self.anchor) }
     }
-    /// Is the caret drawn at the end of the line before (upstream), not the start of the next?
-    pub fn at_line_end(&self) -> bool {
-        self.line_end == Some(self.caret)
-    }
 }
 
 /// Which shape tree is being edited: slides (normal), or a master/layout (Slide Master view).
@@ -139,24 +130,6 @@ pub struct Interaction {
     pub selection: Selection,
 }
 
-/// Text an input method is composing (#101): its preedit sits in the edited text body, at `start`
-/// for `len` characters, until it is committed, replaced or cancelled. The presentation from
-/// before it began makes the whole composition one undo step.
-#[derive(Clone, Debug)]
-pub struct Composition {
-    /// Where the composed text starts: (paragraph, char).
-    pub start: (usize, usize),
-    /// Its length in characters (it never spans paragraphs).
-    pub len: usize,
-    /// The part the input method is converting, relative to `start` (drawn with a thicker line).
-    pub active: Option<(usize, usize)>,
-    /// The formatting the composed text is typed with (as `text.insert` would choose).
-    pub props: Option<deckcraft_model::text::RunProps>,
-    /// The presentation and selection before the composition began.
-    pub before: Arc<Presentation>,
-    pub before_selection: Selection,
-}
-
 #[derive(Clone, Debug)]
 pub struct DocState {
     pub doc: Arc<Presentation>,
@@ -168,11 +141,6 @@ pub struct DocState {
     pub interaction: Option<Interaction>,
     pub uid: u64,
     pub title: String,
-    /// Fonts the file's text uses that aren't installed, found when it was opened (empty for new
-    /// documents); the app mentions them once.
-    pub missing_fonts: Vec<String>,
-    /// An input method's composition in progress ([`Composition`]).
-    pub composition: Option<Composition>,
 }
 
 static NEXT_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -190,8 +158,6 @@ impl DocState {
             interaction: None,
             uid: NEXT_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
             title,
-            missing_fonts: Vec::new(),
-            composition: None,
         }
     }
     pub fn is_dirty(&self) -> bool {
@@ -347,10 +313,6 @@ pub struct Session {
     pub media_status: std::collections::HashMap<ShapeId, MediaStatus>,
     /// Animated GIF pictures paused with `media.gifPlay` (the others play).
     pub gif_paused: std::collections::HashSet<ShapeId>,
-    /// Text keys follow the Mac (Option+arrows move by word, Cmd+arrows to the line or text
-    /// ends) instead of Windows and Linux (Ctrl+arrows by word or paragraph). Defaults to the
-    /// platform DeckCraft was built for.
-    pub mac_keys: bool,
 }
 
 impl Default for Session {
@@ -378,7 +340,6 @@ impl Session {
             recovery_dir: None,
             media_status: Default::default(),
             gif_paused: Default::default(),
-            mac_keys: cfg!(target_os = "macos"),
         }
     }
     /// A session with one new presentation open.
@@ -437,10 +398,6 @@ impl Session {
 
     fn execute_unguarded(&mut self, id: &str, params: &Value) -> Result<Value> {
         let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.into()))?;
-        // Any other edit (or a click, a key, undo) settles an input method's composition first.
-        if self.depth == 0 && (spec.journal || spec.undoable) && !matches!(id, "text.compose" | "text.commit") {
-            self.end_composition();
-        }
         if let Err(e) = (spec.enabled)(self) {
             let named = (e == cmd::NOTHING_SELECTED || e == cmd::SELECT_TWO) && (params.get("ids").is_some() || params.get("id").is_some());
             if !named {
@@ -491,24 +448,10 @@ impl Session {
         Ok(r)
     }
 
-    /// Keep an input method's composition as it stands (#101): its text stays and the whole
-    /// composition becomes one undo step. Nothing happens without one.
-    pub fn end_composition(&mut self) {
-        let Some(st) = self.active_mut() else { return };
-        let Some(c) = st.composition.take() else { return };
-        if !Arc::ptr_eq(&c.before, &st.doc) {
-            push_undo(st, HistoryEntry { label: "Type Text".into(), doc: c.before, selection: c.before_selection });
-        }
-    }
-
     /// Change only the selection (no undo step).
     pub fn select(&mut self, f: impl FnOnce(&Presentation, &mut Selection)) -> Result<()> {
         let st = self.doc_mut()?;
         let doc = st.doc.clone();
-        // A caret placed anywhere starts downstream; only End puts it back at a line's end.
-        if let Some(t) = st.selection.text.as_mut() {
-            t.line_end = None;
-        }
         f(&doc, &mut st.selection);
         clamp_selection(st);
         st.revision += 1;
@@ -553,5 +496,3 @@ pub(crate) fn push_undo(st: &mut DocState, e: HistoryEntry) {
 
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_keys;

crates/engine/src/tests.rs

@@ -504,30 +504,6 @@ fn hyperlink_on_a_word_or_shape_links_it() {
     assert!(s.doc().unwrap().current_slide().unwrap().shapes[0].click.is_some(), "a selected shape gets the link as its click action");
 }
 
-/// A .pptx (base64) whose first slide's title is set in `font`.
-fn deck_in_font(font: &str) -> String {
-    let mut p = deckcraft_model::Presentation::default();
-    let slide = std::sync::Arc::make_mut(&mut p.slides[0]);
-    let mut body = deckcraft_model::text::TextBody::from_text("Hello");
-    body.paragraphs[0].runs[0].props.font = Some(font.into());
-    slide.shapes[0].text = Some(body);
-    crate::cmd::base64_encode(&crate::cmd::file::save_bytes(&p, "pptx").unwrap())
-}
-
-#[test]
-fn opening_a_file_lists_the_fonts_it_uses_that_are_missing() {
-    let mut s = Session::with_new();
-    let r = s.execute("file.openBytes", &json!({"name": "a.pptx", "data": deck_in_font("Qqq Nonexistent Sans")})).unwrap();
-    assert_eq!(r["missingFonts"], json!(["Qqq Nonexistent Sans"]));
-    assert_eq!(s.doc().unwrap().missing_fonts, vec!["Qqq Nonexistent Sans".to_string()]);
-    // A font that is there (bundled or installed) isn't listed; new documents list nothing.
-    let have = deckcraft_fonts::FontDb::global().face(deckcraft_fonts::FALLBACK_FAMILY, "Regular").family.clone();
-    let r = s.execute("file.openBytes", &json!({"name": "b.pptx", "data": deck_in_font(&have)})).unwrap();
-    assert_eq!(r["missingFonts"], json!([]));
-    s.execute("file.new", &json!({})).unwrap();
-    assert!(s.doc().unwrap().missing_fonts.is_empty());
-}
-
 #[test]
 fn clicks_in_flipped_shapes_hit_the_text_where_it_is_drawn() {
     // Flips don't mirror text, so a click lands on the character drawn under it.
@@ -567,271 +543,3 @@ fn inserted_hyperlinks_look_like_links() {
     s.execute("format.underline", &json!({})).unwrap();
     assert_eq!(s.execute("format.state", &json!({})).unwrap()["underline"], false);
 }
-
-/// #270: shapes off the slide (in the editor's pasteboard) are hit, selected, moved and marqueed
-/// like any other; one can be dragged back onto the slide or out of it.
-#[test]
-fn shapes_off_the_slide_can_be_selected_and_moved() {
-    let mut s = session();
-    s.prefs.snap_to_grid = false;
-    s.prefs.smart_guides = false;
-    let off = s.execute("shape.insert", &json!({"preset": "rect", "rect": [1000.0, 100.0, 120.0, 80.0]})).unwrap()["id"].as_u64().unwrap();
-    let half = s.execute("shape.insert", &json!({"preset": "ellipse", "rect": [-60.0, 300.0, 120.0, 80.0]})).unwrap()["id"].as_u64().unwrap();
-    // Inserting off the slide keeps the box where it was asked for.
-    assert_eq!(s.execute("shape.inspect", &json!({"id": off})).unwrap()["box"]["x"], 1000.0);
-    s.execute("edit.select", &json!({"ids": []})).unwrap();
-    let ev = |kind, x, y| PointerEvent { kind, x, y, mods: Mods::default(), tol: 3.0 };
-    // Hover and click wholly off the slide.
-    assert!(matches!(s.hit_test(deckcraft_geom::Point::new(1060.0, 140.0), 3.0), Some(tools::Hit::Shape { id, .. }) if id.0 as u64 == off));
-    s.pointer(ev(PointerKind::Down, 1060.0, 140.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, 1060.0, 140.0)).unwrap();
-    assert_eq!(s.doc().unwrap().selection.shapes.iter().map(|i| i.0 as u64).collect::<Vec<_>>(), vec![off]);
-    // Drag it further off, then back onto the slide.
-    s.pointer(ev(PointerKind::Down, 1060.0, 140.0)).unwrap();
-    s.pointer(ev(PointerKind::Drag, 1110.0, 160.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, 1110.0, 160.0)).unwrap();
-    let v = s.execute("shape.inspect", &json!({"id": off})).unwrap();
-    assert_eq!((v["box"]["x"].as_f64(), v["box"]["y"].as_f64()), (Some(1050.0), Some(120.0)));
-    s.pointer(ev(PointerKind::Down, 1110.0, 160.0)).unwrap();
-    s.pointer(ev(PointerKind::Drag, 500.0, 160.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, 500.0, 160.0)).unwrap();
-    assert_eq!(s.execute("shape.inspect", &json!({"id": off})).unwrap()["box"]["x"], 440.0);
-    // The off-slide half of a straddling shape is hit too.
-    s.pointer(ev(PointerKind::Down, -30.0, 340.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, -30.0, 340.0)).unwrap();
-    assert_eq!(s.doc().unwrap().selection.shapes.iter().map(|i| i.0 as u64).collect::<Vec<_>>(), vec![half]);
-    // A marquee started on the pasteboard selects what it encloses there.
-    s.pointer(ev(PointerKind::Down, -100.0, 250.0)).unwrap();
-    s.pointer(ev(PointerKind::Drag, 80.0, 420.0)).unwrap();
-    s.pointer(ev(PointerKind::Up, 80.0, 420.0)).unwrap();
-    assert_eq!(s.doc().unwrap().selection.shapes.iter().map(|i| i.0 as u64).collect::<Vec<_>>(), vec![half]);
-}
-
-fn title_text(s: &Session) -> String {
-    let sh = &s.doc().unwrap().current_slide().unwrap().shapes[0];
-    sh.text.as_ref().map(|t| t.paragraphs.iter().map(|p| p.text()).collect::<Vec<_>>().join("\n")).unwrap_or_default()
-}
-
-/// #101: Korean typed through an input method arrives as preedit updates (ㅎ → 하 → 한 → 한ㄱ →
-/// 한그 → 한글) and a commit. The preedit is shown in place and replaced on each update; the
-/// committed text is one undo step, and nothing on the way is an undo step of its own.
-#[test]
-fn ime_composition_replaces_its_preedit_and_commits_as_one_undo_step() {
-    let mut s = session();
-    let title = s.doc().unwrap().current_slide().unwrap().shapes[0].id.0;
-    s.execute("text.edit", &json!({"id": title})).unwrap();
-    s.execute("text.insert", &json!({"text": "A "})).unwrap();
-    let undo0 = s.doc().unwrap().history.undo.len();
-    for pre in ["ㅎ", "하", "한", "한ㄱ", "한그", "한글"] {
-        s.compose_text(pre, None).unwrap();
-        assert_eq!(title_text(&s), format!("A {pre}"), "the preedit is shown in place");
-        let c = s.doc().unwrap().composition.clone().unwrap();
-        assert_eq!((c.start, c.len), ((0, 2), pre.chars().count()));
-        assert_eq!(s.doc().unwrap().selection.text.as_ref().unwrap().caret, (0, 2 + pre.chars().count()), "caret after the preedit");
-        assert_eq!(s.doc().unwrap().history.undo.len(), undo0, "no undo step while composing");
-    }
-    s.commit_text("한글").unwrap();
-    assert_eq!(title_text(&s), "A 한글");
-    assert!(s.doc().unwrap().composition.is_none());
-    assert_eq!(s.doc().unwrap().history.undo.len(), undo0 + 1, "one undo step for the composition");
-    assert_eq!(s.doc().unwrap().history.undo.last().unwrap().label, "Type Text");
-    s.execute("edit.undo", &json!({})).unwrap();
-    assert_eq!(title_text(&s), "A ");
-    s.execute("edit.redo", &json!({})).unwrap();
-    assert_eq!(title_text(&s), "A 한글");
-
-    // Windows' Korean IME commits a syllable when the next begins: an empty preedit, the commit,
-    // then a new preedit.
-    s.compose_text("ㄴ", None).unwrap();
-    s.compose_text("", None).unwrap();
-    s.commit_text("ㄴ").unwrap();
-    s.compose_text("ㅁ", None).unwrap();
-    assert_eq!(title_text(&s), "A 한글ㄴㅁ");
-    s.commit_text("마").unwrap();
-    assert_eq!(title_text(&s), "A 한글ㄴ마");
-    s.execute("edit.undo", &json!({})).unwrap();
-    assert_eq!(title_text(&s), "A 한글ㄴ");
-}
-
-/// #101: an empty preedit cancels the composition (Escape, or Backspace over its last jamo):
-/// the text and the selection it replaced are as they were, with no undo step.
-#[test]
-fn ime_cancel_restores_the_text_and_selection() {
-    let mut s = session();
-    let title = s.doc().unwrap().current_slide().unwrap().shapes[0].id.0;
-    s.execute("text.edit", &json!({"id": title})).unwrap();
-    s.execute("text.insert", &json!({"text": "Hello world"})).unwrap();
-    s.execute("text.select", &json!({"anchor": [0, 6], "caret": [0, 11]})).unwrap();
-    let undo0 = s.doc().unwrap().history.undo.len();
-    let rev = s.doc().unwrap().revision;
-    s.compose_text("せかい", Some((0, 3))).unwrap();
-    assert_eq!(title_text(&s), "Hello せかい", "the preedit replaces the selection");
-    assert_eq!(s.doc().unwrap().composition.as_ref().unwrap().active, Some((0, 3)));
-    s.compose_text("世界", Some((0, 9))).unwrap();
-    assert_eq!(s.doc().unwrap().composition.as_ref().unwrap().active, Some((0, 2)), "clamped to the preedit");
-    s.compose_text("", None).unwrap();
-    assert_eq!(title_text(&s), "Hello world");
-    let t = s.doc().unwrap().selection.text.clone().unwrap();
-    assert_eq!((t.anchor, t.caret), ((0, 6), (0, 11)), "the selection is back");
-    assert_eq!(s.doc().unwrap().history.undo.len(), undo0);
-    assert!(s.doc().unwrap().revision > rev, "redrawn");
-    // A commit of nothing without a composition is nothing.
-    s.commit_text("").unwrap();
-    assert_eq!(s.doc().unwrap().history.undo.len(), undo0);
-    // A commit without a preedit (some input methods send only the result) is one step.
-    s.commit_text("世界").unwrap();
-    assert_eq!(title_text(&s), "Hello 世界");
-    assert_eq!(s.doc().unwrap().history.undo.len(), undo0 + 1);
-}
-
-/// #101: anything else settles the composition first: its text stays and is its own undo step.
-#[test]
-fn ime_composition_is_kept_by_a_key_a_click_or_another_command() {
-    let mut s = session();
-    let title = s.doc().unwrap().current_slide().unwrap().shapes[0].id.0;
-    s.execute("text.edit", &json!({"id": title})).unwrap();
-    let undo0 = s.doc().unwrap().history.undo.len();
-    s.compose_text("안", None).unwrap();
-    s.key("Right", Mods::default()).unwrap();
-    assert!(s.doc().unwrap().composition.is_none());
-    assert_eq!(title_text(&s), "안");
-    assert_eq!(s.doc().unwrap().history.undo.len(), undo0 + 1);
-
-    s.compose_text("녕", None).unwrap();
-    s.pointer(PointerEvent { kind: PointerKind::Move, x: 5.0, y: 5.0, mods: Mods::default(), tol: 4.0 }).unwrap();
-    assert!(s.doc().unwrap().composition.is_some(), "hovering keeps composing");
-    s.pointer(PointerEvent { kind: PointerKind::Down, x: 5.0, y: 5.0, mods: Mods::default(), tol: 4.0 }).unwrap();
-    assert!(s.doc().unwrap().composition.is_none(), "a click settles it");
-    assert_eq!(title_text(&s), "안녕");
-
-    s.execute("text.edit", &json!({"id": title})).unwrap();
-    s.compose_text("하", None).unwrap();
-    s.execute("text.get", &json!({"id": title})).unwrap();
-    assert!(s.doc().unwrap().composition.is_some(), "a query doesn't");
-    s.execute("text.insert", &json!({"text": "!"})).unwrap();
-    assert_eq!(title_text(&s), "안녕하!");
-    s.execute("edit.undo", &json!({})).unwrap();
-    assert_eq!(title_text(&s), "안녕하");
-    s.execute("edit.undo", &json!({})).unwrap();
-    assert_eq!(title_text(&s), "안녕");
-
-    // Text changed under the composition (here behind its back): a new one starts, no panic.
-    s.compose_text("ㄱ", None).unwrap();
-    s.doc_mut().unwrap().composition.as_mut().unwrap().len = 99;
-    s.compose_text("가", None).unwrap();
-    assert!(title_text(&s).ends_with('가'));
-    // Control characters (an Enter sent as text) never split the paragraph.
-    s.commit_text("가\n\r\u{b}").unwrap();
-    assert_eq!(s.doc().unwrap().current_slide().unwrap().shapes[0].text.as_ref().unwrap().paragraphs.len(), 1);
-}
-
-/// #101: the first preedit on a selected shape starts editing it and replaces its text, as typing
-/// does; with nothing selected there is nowhere to compose.
-#[test]
-fn ime_on_a_selected_shape_replaces_its_text() {
-    let mut s = session();
-    let r = s.execute("shape.insert", &json!({"preset": "rect", "rect": [100, 100, 200, 100], "text": "Old"})).unwrap();
-    let id = r["id"].as_u64().unwrap();
-    s.select(|_, sel| {
-        sel.text = None;
-        sel.shapes = vec![ShapeId(id as u32)];
-    })
-    .unwrap();
-    assert_eq!(s.compose_text("", None).unwrap()["handled"], false, "an empty preedit doesn't start editing");
-    s.compose_text("新", None).unwrap();
-    s.commit_text("新しい").unwrap();
-    let v = s.execute("text.get", &json!({"id": id})).unwrap();
-    assert_eq!(v["text"], "新しい");
-    s.select(|_, sel| {
-        sel.text = None;
-        sel.shapes.clear();
-    })
-    .unwrap();
-    assert_eq!(s.compose_text("x", None).unwrap()["handled"], false);
-    assert_eq!(s.commit_text("x").unwrap()["handled"], false);
-}
-
-/// #101: the composition is underlined in place, under the composed characters, with a thicker
-/// line under the part being converted.
-#[test]
-fn ime_composition_underlines_follow_the_text() {
-    let mut s = session();
-    let title = s.doc().unwrap().current_slide().unwrap().shapes[0].id.0;
-    s.execute("text.edit", &json!({"id": title})).unwrap();
-    assert!(cmd::text::composition_underlines(s.doc().unwrap()).is_empty());
-    s.compose_text("にほんご", Some((2, 4))).unwrap();
-    let u = cmd::text::composition_underlines(s.doc().unwrap());
-    let thin: Vec<_> = u.iter().filter(|x| !x.2).collect();
-    let thick: Vec<_> = u.iter().filter(|x| x.2).collect();
-    assert_eq!((thin.len(), thick.len()), (1, 1), "{u:?}");
-    let sh = s.doc().unwrap().current_slide().unwrap().shapes[0].clone();
-    let x = cmd::xfrm_of(&s.doc().unwrap().doc, &s.doc().unwrap().selection, &sh);
-    for (a, b, _) in &u {
-        assert!(b.x > a.x && (a.y - b.y).abs() < 1e-9, "a horizontal line: {a:?} {b:?}");
-        assert!(a.x >= x.x - 1.0 && b.x <= x.x + x.w + 1.0 && a.y > x.y && a.y < x.y + x.h, "inside the title box");
-    }
-    assert!(thick[0].0.x > thin[0].0.x && (thick[0].1.x - thin[0].1.x).abs() < 1e-6, "the converted part is the end");
-    s.commit_text("日本語").unwrap();
-    assert!(cmd::text::composition_underlines(s.doc().unwrap()).is_empty());
-}
-
-/// File › Info (#76): the active presentation's name, location, counts and properties.
-#[test]
-fn file_info_reports_the_presentation() {
-    let mut s = session();
-    s.execute("slide.new", &json!({})).unwrap();
-    s.execute("slide.new", &json!({})).unwrap();
-    s.execute("slide.go", &json!({"index": 1})).unwrap();
-    s.execute("slide.hide", &json!({})).unwrap();
-    s.execute("file.properties", &json!({"title": "Quarterly", "author": "Ada"})).unwrap();
-    let v = s.execute("file.info", &json!({})).unwrap();
-    assert_eq!(v["slides"], 3);
-    assert_eq!(v["hiddenSlides"], 1);
-    assert_eq!(v["path"], serde_json::Value::Null);
-    assert_eq!(v["dirty"], true);
-    assert_eq!(v["properties"]["title"], "Quarterly");
-    assert_eq!(v["properties"]["author"], "Ada");
-    assert!(v["title"].as_str().is_some_and(|t| !t.is_empty()));
-    // A query: no undo step, and nothing changes.
-    let before = s.doc().unwrap().history.undo.len();
-    s.execute("file.info", &json!({})).unwrap();
-    assert_eq!(s.doc().unwrap().history.undo.len(), before);
-    // Saved to disk, it reports where and how big.
-    let dir = std::env::temp_dir().join(format!("deckcraft-info-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let path = dir.join("Info test.pptx").to_string_lossy().to_string();
-    s.execute("file.saveAs", &json!({"path": path})).unwrap();
-    let v = s.execute("file.info", &json!({})).unwrap();
-    assert_eq!(v["path"], path.as_str());
-    assert_eq!(v["format"], "pptx");
-    assert_eq!(v["dirty"], false);
-    assert!(v["bytes"].as_u64().is_some_and(|b| b > 0));
-    let _ = std::fs::remove_dir_all(&dir);
-    // Nothing open: an error, not a panic.
-    let mut empty = Session::new();
-    assert!(empty.execute("file.info", &json!({})).is_err());
-}
-
-/// The Print page's Slides box (#76): PowerPoint-style ranges, 1-based.
-#[test]
-fn slide_ranges_parse_like_powerpoints_print_box() {
-    use cmd::file::parse_slide_range as r;
-    assert_eq!(r("1-3, 5", 6).unwrap(), vec![0, 1, 2, 4]);
-    assert_eq!(r("3-1;2", 6).unwrap(), vec![0, 1, 2], "reversed ranges and repeats");
-    assert_eq!(r(" 6 ", 6).unwrap(), vec![5]);
-    assert!(r("7", 6).is_err(), "past the last slide");
-    assert!(r("0", 6).is_err());
-    assert!(r("a-b", 6).is_err());
-    assert!(r(" , ", 6).is_err());
-    assert!(r("1-99999999999999999999999", 6).is_err(), "hostile numbers are refused");
-    // file.export takes the same text for a PDF.
-    let mut s = session();
-    s.execute("slide.new", &json!({})).unwrap();
-    let doc = s.doc().unwrap().doc.clone();
-    let one = cmd::file::pdf_bytes(&doc, &json!({"slides": "2"})).unwrap();
-    let both = cmd::file::pdf_bytes(&doc, &json!({"slides": "1-2"})).unwrap();
-    assert!(one.len() < both.len());
-    assert!(cmd::file::pdf_bytes(&doc, &json!({"slides": "5"})).is_err());
-    let opts = cmd::file::pdf_options(&json!({"slides": [0, 7, 1]}), 2).unwrap();
-    assert_eq!(opts.slides, Some(vec![0, 1]), "indices past the end are dropped");
-}

crates/engine/src/tests_keys.rs

@@ -1,404 +0,0 @@
-//! Text-editing keys driven through `Session::key`, as the keyboard, control channel and MCP
-//! send them. Every expectation is PowerPoint for Windows' observed behaviour unless it says Mac.
-
-use serde_json::{Value, json};
-
-use crate::Session;
-use crate::tools::Mods;
-
-const NONE: Mods = Mods { shift: false, alt: false, cmd: false };
-const CTRL: Mods = Mods { shift: false, alt: false, cmd: true };
-const CTRL_SHIFT: Mods = Mods { shift: true, alt: false, cmd: true };
-const SHIFT: Mods = Mods { shift: true, alt: false, cmd: false };
-const ALT: Mods = Mods { shift: false, alt: true, cmd: false };
-
-type Pos = (usize, usize);
-
-/// A session editing a new text box holding `text` (Windows keys), caret at `at`.
-fn editing(text: &str, at: Pos) -> (Session, u32) {
-    editing_in(text, at, [60.0, 60.0, 600.0, 300.0])
-}
-
-fn editing_in(text: &str, at: Pos, rect: [f64; 4]) -> (Session, u32) {
-    let mut s = Session::with_new();
-    s.mac_keys = false;
-    s.prefs.autocorrect = false;
-    s.prefs.smart_quotes = false;
-    s.execute("insert.textBox", &json!({"rect": rect, "text": "x"})).unwrap();
-    let id = s.doc().unwrap().selection.shapes[0].0;
-    s.execute("text.set", &json!({"id": id, "text": text})).unwrap();
-    s.execute("text.edit", &json!({"id": id, "at": [at.0, at.1]})).unwrap();
-    (s, id)
-}
-
-fn sel(s: &Session) -> (Pos, Pos) {
-    let t = s.doc().unwrap().selection.text.clone().unwrap();
-    (t.anchor, t.caret)
-}
-
-fn caret(s: &Session) -> Pos {
-    sel(s).1
-}
-
-fn press(s: &mut Session, key: &str, mods: Mods) -> Value {
-    let r = s.key(key, mods).unwrap();
-    assert_eq!(r["handled"], true, "{key} {mods:?} not handled");
-    r
-}
-
-fn text(s: &mut Session, id: u32) -> String {
-    s.execute("text.get", &json!({"id": id})).unwrap()["text"].as_str().unwrap().to_string()
-}
-
-/// Press `key` until the caret stops moving; the carets visited (in the first paragraph).
-fn walk(s: &mut Session, key: &str, mods: Mods) -> Vec<usize> {
-    let mut out = vec![caret(s).1];
-    for _ in 0..200 {
-        let before = caret(s);
-        press(s, key, mods);
-        if caret(s) == before {
-            break;
-        }
-        out.push(caret(s).1);
-    }
-    out
-}
-
-#[test]
-fn ctrl_arrows_stop_where_powerpoint_does() {
-    let t = "Hello, world!  Foo...bar baz-qux it's 3.14 e.g. a_b x@y.com (end) \"q\" end.";
-    let stops = vec![0, 5, 7, 12, 15, 18, 21, 25, 33, 38, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 60, 61, 64, 66, 67, 68, 70, 73, 74];
-    let (mut s, _) = editing(t, (0, 0));
-    assert_eq!(walk(&mut s, "ArrowRight", CTRL), stops);
-    let mut back = stops.clone();
-    back.reverse();
-    assert_eq!(walk(&mut s, "ArrowLeft", CTRL), back);
-}
-
-#[test]
-fn ctrl_arrows_over_cjk_rtl_emoji_and_marks() {
-    let (mut s, _) = editing("日本語のテキスト abc 한국어", (0, 0));
-    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 1, 2, 3, 4, 5, 6, 7, 9, 13, 14, 15, 16]);
-    // Arabic and Hebrew words inside a left-to-right paragraph: in logical order.
-    let (mut s, _) = editing("Hello مرحبا بالعالم world שלום end", (0, 0));
-    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 6, 12, 20, 26, 31, 34]);
-    // An emoji ZWJ sequence and a combining mark are never split.
-    let (mut s, _) = editing("e\u{301}te 👨\u{200d}👩\u{200d}👧 x", (0, 0));
-    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 5, 11, 12]);
-    assert_eq!(walk(&mut s, "Left", CTRL), vec![12, 11, 5, 0]);
-}
-
-#[test]
-fn ctrl_arrows_cross_paragraphs_line_breaks_and_tabs() {
-    let (mut s, id) = editing("One two\nThree four\n\nFive", (0, 0));
-    let mut seen = vec![caret(&s)];
-    for _ in 0..9 {
-        press(&mut s, "Right", CTRL);
-        seen.push(caret(&s));
-    }
-    assert_eq!(seen, vec![(0, 0), (0, 4), (0, 7), (1, 0), (1, 6), (1, 10), (2, 0), (3, 0), (3, 4), (3, 4)]);
-    // A line break and a tab are stops of their own.
-    s.execute("text.set", &json!({"id": id, "text": "x"})).unwrap();
-    s.execute("text.edit", &json!({"id": id, "at": [0, 0]})).unwrap();
-    s.execute("text.selectAll", &json!({})).unwrap();
-    s.execute("text.insert", &json!({"text": "Five\u{b}six seven\tTab   x"})).unwrap();
-    s.execute("text.move", &json!({"to": "start"})).unwrap();
-    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 4, 5, 9, 14, 15, 21, 22]);
-}
-
-#[test]
-fn ctrl_shift_arrows_extend_by_words() {
-    let (mut s, _) = editing("Hello world  foo, bar\nnext para", (0, 2));
-    let mut carets = vec![];
-    for _ in 0..6 {
-        press(&mut s, "Right", CTRL_SHIFT);
-        carets.push(sel(&s));
-    }
-    let a = (0, 2);
-    assert_eq!(carets.iter().map(|x| x.1).collect::<Vec<_>>(), vec![(0, 6), (0, 13), (0, 16), (0, 18), (0, 21), (1, 0)]);
-    assert!(carets.iter().all(|x| x.0 == a));
-    let mut back = vec![];
-    for _ in 0..7 {
-        press(&mut s, "Left", CTRL_SHIFT);
-        back.push(caret(&s));
-    }
-    assert_eq!(back, vec![(0, 21), (0, 18), (0, 16), (0, 13), (0, 6), (0, 0), (0, 0)]);
-    assert_eq!(sel(&s).0, a);
-    // From a caret inside a word going left: the word's start, then on.
-    let (mut s, _) = editing("Hello world  foo, bar\nnext para", (1, 2));
-    press(&mut s, "Left", CTRL_SHIFT);
-    press(&mut s, "Left", CTRL_SHIFT);
-    assert_eq!(sel(&s), ((1, 2), (0, 21)));
-}
-
-#[test]
-fn ctrl_arrows_leave_a_selection_from_its_ends() {
-    for (anchor, caret_at) in [((0, 2), (0, 7)), ((0, 7), (0, 2))] {
-        let (mut s, _) = editing("Hello world  foo, bar", anchor);
-        s.execute("text.select", &json!({"anchor": [anchor.0, anchor.1], "caret": [caret_at.0, caret_at.1]})).unwrap();
-        press(&mut s, "Right", CTRL);
-        assert_eq!(sel(&s), ((0, 13), (0, 13)));
-        s.execute("text.select", &json!({"anchor": [anchor.0, anchor.1], "caret": [caret_at.0, caret_at.1]})).unwrap();
-        press(&mut s, "Left", CTRL);
-        assert_eq!(sel(&s), ((0, 0), (0, 0)));
-    }
-}
-
-#[test]
-fn ctrl_backspace_and_delete() {
-    let (mut s, id) = editing("Hello world  foo, bar\nnext para", (0, 13));
-    press(&mut s, "Backspace", CTRL);
-    assert_eq!(text(&mut s, id), "Hello foo, bar\nnext para");
-    assert_eq!(caret(&s), (0, 6));
-    press(&mut s, "Delete", CTRL);
-    assert_eq!(text(&mut s, id), "Hello , bar\nnext para".replace(" ,", ","));
-    assert_eq!(caret(&s), (0, 5));
-    // At a paragraph's ends they join paragraphs.
-    s.execute("text.move", &json!({"to": "paraEnd"})).unwrap();
-    press(&mut s, "Delete", CTRL);
-    assert_eq!(text(&mut s, id), "Hello, barnext para");
-    // A selection is not deleted: the word goes from its start (PowerPoint for Windows).
-    let (mut s, id) = editing("Hello world", (0, 2));
-    s.execute("text.select", &json!({"anchor": [0, 2], "caret": [0, 7]})).unwrap();
-    press(&mut s, "Backspace", CTRL);
-    assert_eq!((text(&mut s, id), sel(&s)), ("llo world".into(), ((0, 0), (0, 0))));
-    let (mut s, id) = editing("Hello world", (0, 7));
-    s.execute("text.select", &json!({"anchor": [0, 7], "caret": [0, 2]})).unwrap();
-    press(&mut s, "Delete", CTRL);
-    assert_eq!((text(&mut s, id), sel(&s)), ("He world".into(), ((0, 2), (0, 2))));
-    // It is one undo step.
-    s.execute("edit.undo", &json!({})).unwrap();
-    assert_eq!(text(&mut s, id), "Hello world");
-}
-
-#[test]
-fn ctrl_up_down_move_by_paragraph() {
-    let t = "First paragraph that is long enough to wrap in this box.\nSecond\n\nFourth para";
-    let (mut s, _) = editing_in(t, (0, 5), [60.0, 60.0, 200.0, 300.0]);
-    let mut seen = vec![];
-    for _ in 0..5 {
-        press(&mut s, "Down", CTRL);
-        seen.push(caret(&s));
-    }
-    assert_eq!(seen, vec![(1, 0), (2, 0), (3, 0), (3, 11), (3, 11)]);
-    s.execute("text.move", &json!({"to": "end"})).unwrap();
-    press(&mut s, "Left", NONE);
-    let mut seen = vec![];
-    for _ in 0..5 {
-        press(&mut s, "Up", CTRL);
-        seen.push(caret(&s));
-    }
-    assert_eq!(seen, vec![(3, 0), (2, 0), (1, 0), (0, 0), (0, 0)]);
-    // With Shift they extend; back past the anchor the selection flips.
-    s.execute("text.edit", &json!({"at": [0, 5]})).unwrap();
-    press(&mut s, "Down", CTRL_SHIFT);
-    press(&mut s, "Down", CTRL_SHIFT);
-    assert_eq!(sel(&s), ((0, 5), (2, 0)));
-    press(&mut s, "Up", CTRL_SHIFT);
-    press(&mut s, "Up", CTRL_SHIFT);
-    assert_eq!(sel(&s), ((0, 5), (0, 0)));
-}
-
-#[test]
-fn home_end_and_ctrl_home_end() {
-    let t = "First paragraph that is long enough to wrap across several lines in this narrow box.\nSecond";
-    let (mut s, _) = editing_in(t, (0, 0), [60.0, 60.0, 160.0, 300.0]);
-    let st = s.doc().unwrap();
-    let ts = st.selection.text.clone().unwrap();
-    let layout = crate::cmd::text::layout_for(st, &ts).unwrap();
-    let lines: Vec<(usize, usize)> = layout.lines.iter().filter(|l| l.para == 0).map(|l| (l.start, l.end)).collect();
-    assert!(lines.len() >= 3, "{lines:?}");
-    let (l1, l2) = (lines[1], lines[2]);
-    // End goes past a wrapped line's trailing space, to where the next line starts, as in
-    // PowerPoint, and the caret stays drawn on the line it ended.
-    let next = lines[2].0;
-    s.execute("text.edit", &json!({"at": [0, l1.0 + 2]})).unwrap();
-    press(&mut s, "Home", NONE);
-    assert_eq!(caret(&s), (0, l1.0));
-    press(&mut s, "End", NONE);
-    assert_eq!(caret(&s), (0, next));
-    assert!(s.doc().unwrap().selection.text.as_ref().unwrap().at_line_end());
-    let drawn = |s: &Session| {
-        let st = s.doc().unwrap();
-        let ts = st.selection.text.clone().unwrap();
-        let l = crate::cmd::text::layout_for(st, &ts).unwrap();
-        let aff = if ts.at_line_end() { deckcraft_text::Affinity::Upstream } else { deckcraft_text::Affinity::Downstream };
-        l.caret_drawn(deckcraft_text::Pos { para: ts.caret.0, ch: ts.caret.1 }, aff).unwrap()
-    };
-    let line1_top = layout.lines.iter().filter(|l| l.para == 0).nth(1).unwrap().top;
-    assert_eq!(drawn(&s).1, line1_top);
-    // End again stays on the line; Home goes back to its start, not the next line's.
-    press(&mut s, "End", NONE);
-    assert_eq!(caret(&s), (0, next));
-    press(&mut s, "Home", SHIFT);
-    assert_eq!(sel(&s), ((0, next), (0, l1.0)));
-    press(&mut s, "End", SHIFT);
-    assert_eq!(sel(&s), ((0, next), (0, next)));
-    assert_eq!(drawn(&s).1, line1_top);
-    // Down from a line's end lands on the next line, not two lines down.
-    press(&mut s, "Down", NONE);
-    let c = caret(&s);
-    assert!(c.1 > l2.0 && c.1 <= l2.1, "{c:?} not on line {l2:?}");
-    // The caret is drawn at the end of the line it belongs to.
-    s.execute("text.move", &json!({"to": "lineEnd"})).unwrap();
-    let ts = s.doc().unwrap().selection.text.clone().unwrap();
-    assert!(ts.at_line_end());
-    // Ctrl+Home / Ctrl+End, with Shift extending.
-    press(&mut s, "End", CTRL);
-    assert_eq!(caret(&s), (1, 6));
-    press(&mut s, "Home", CTRL_SHIFT);
-    assert_eq!(sel(&s), ((1, 6), (0, 0)));
-    press(&mut s, "Home", CTRL);
-    press(&mut s, "End", CTRL_SHIFT);
-    assert_eq!(sel(&s), ((0, 0), (1, 6)));
-    // A caret placed anywhere else is drawn at the start of its line again.
-    s.execute("text.select", &json!({"anchor": [0, next], "caret": [0, next]})).unwrap();
-    assert!(!s.doc().unwrap().selection.text.as_ref().unwrap().at_line_end());
-    assert!(drawn(&s).1 > line1_top);
-}
-
-#[test]
-fn right_to_left_paragraphs_swap_left_and_right() {
-    let (mut s, _) = editing("مرحبا بالعالم hello world", (0, 0));
-    s.execute("format.rtl", &json!({"on": true})).unwrap();
-    // Ctrl+Left goes forward in a right-to-left paragraph, Ctrl+Right back.
-    assert_eq!(walk(&mut s, "Left", CTRL), vec![0, 6, 14, 20, 25]);
-    assert_eq!(walk(&mut s, "Right", CTRL), vec![25, 20, 14, 6, 0]);
-    press(&mut s, "Left", NONE);
-    assert_eq!(caret(&s), (0, 1));
-    press(&mut s, "Left", CTRL_SHIFT);
-    assert_eq!(sel(&s), ((0, 1), (0, 6)));
-}
-
-#[test]
-fn mac_keys() {
-    let (mut s, id) = editing("Hello world foo\nnext", (0, 8));
-    s.mac_keys = true;
-    press(&mut s, "Right", ALT);
-    assert_eq!(caret(&s), (0, 12));
-    press(&mut s, "Left", ALT);
-    assert_eq!(caret(&s), (0, 6));
-    press(&mut s, "Right", CTRL);
-    assert_eq!(caret(&s), (0, 15));
-    press(&mut s, "Left", CTRL);
-    assert_eq!(caret(&s), (0, 0));
-    press(&mut s, "Down", CTRL);
-    assert_eq!(caret(&s), (1, 4));
-    press(&mut s, "Up", CTRL);
-    assert_eq!(caret(&s), (0, 0));
-    s.execute("text.edit", &json!({"id": id, "at": [0, 11]})).unwrap();
-    press(&mut s, "Backspace", ALT);
-    assert_eq!(text(&mut s, id), "Hello  foo\nnext");
-    // Ctrl+arrows aren't word moves on the Mac, nor Alt+arrows on Windows.
-    s.mac_keys = false;
-    let before = caret(&s);
-    let r = s.key("Right", ALT).unwrap();
-    assert_eq!((r["handled"].as_bool(), caret(&s)), (Some(false), before));
-}
-
-#[test]
-fn font_size_keys() {
-    let (mut s, _) = editing("hello wOrld. foo bar", (0, 0));
-    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [0, 5]})).unwrap();
-    let size = |s: &mut Session| s.execute("format.state", &json!({})).unwrap()["size"].as_f64();
-    let base = size(&mut s).unwrap_or(18.0);
-    // egui names the keys `Period`, `Comma`, `CloseBracket`, `OpenBracket`.
-    press(&mut s, "Period", CTRL_SHIFT);
-    let up = size(&mut s).unwrap();
-    assert!(up > base);
-    press(&mut s, "Comma", CTRL_SHIFT);
-    assert_eq!(size(&mut s), Some(base));
-    press(&mut s, "CloseBracket", CTRL);
-    assert_eq!(size(&mut s), Some(up));
-    press(&mut s, "OpenBracket", CTRL);
-    assert_eq!(size(&mut s), Some(base));
-    press(&mut s, ">", CTRL_SHIFT);
-    assert_eq!(size(&mut s), Some(up));
-}
-
-#[test]
-fn bold_italic_underline_and_clear_on_a_caret_in_a_word() {
-    let (mut s, id) = editing("hello wOrld. foo bar", (0, 8));
-    let r = press(&mut s, "b", CTRL);
-    assert_eq!(r["command"], "format.bold");
-    let body = |s: &Session| s.doc().unwrap().shape(deckcraft_model::ShapeId(id)).unwrap().text.clone().unwrap();
-    let runs: Vec<(String, Option<bool>)> = body(&s).paragraphs[0].runs.iter().map(|r| (r.text.clone(), r.props.bold)).collect();
-    assert_eq!(runs.iter().find(|r| r.1 == Some(true)).map(|r| r.0.as_str()), Some("wOrld"));
-    // At a word boundary nothing visible changes.
-    s.execute("text.edit", &json!({"id": id, "at": [0, 5]})).unwrap();
-    press(&mut s, "i", CTRL);
-    assert!(body(&s).paragraphs[0].runs.iter().all(|r| r.props.italic != Some(true)));
-    // Ctrl+Space clears the word's formatting.
-    s.execute("text.edit", &json!({"id": id, "at": [0, 8]})).unwrap();
-    press(&mut s, "Space", CTRL);
-    assert!(body(&s).paragraphs[0].runs.iter().all(|r| r.props.bold != Some(true)));
-    press(&mut s, "u", CTRL);
-    let under: String = body(&s).paragraphs[0].runs.iter().filter(|r| r.props.underline.is_some()).map(|r| r.text.clone()).collect();
-    assert_eq!(under, "wOrld");
-}
-
-#[test]
-fn alignment_keys() {
-    let (mut s, _) = editing("one\ntwo", (0, 1));
-    for (k, want) in [("e", "ctr"), ("r", "r"), ("j", "just"), ("l", "l")] {
-        press(&mut s, k, CTRL);
-        let st = s.execute("format.state", &json!({})).unwrap();
-        assert_eq!(st["align"], want, "Ctrl+{k}");
-    }
-}
-
-#[test]
-fn shift_f3_cycles_case() {
-    let (mut s, id) = editing("hello world", (0, 0));
-    s.execute("text.selectAll", &json!({})).unwrap();
-    let mut seen = vec![];
-    for _ in 0..3 {
-        press(&mut s, "F3", SHIFT);
-        seen.push(text(&mut s, id));
-    }
-    assert_eq!(seen, vec!["Hello World", "HELLO WORLD", "hello world"]);
-    s.execute("text.set", &json!({"id": id, "text": "hello wOrld. foo"})).unwrap();
-    s.execute("text.edit", &json!({"id": id, "at": [0, 8]})).unwrap();
-    press(&mut s, "F3", SHIFT);
-    assert_eq!(text(&mut s, id), "hello WORLD. foo");
-    assert_eq!(sel(&s), ((0, 6), (0, 6)));
-    press(&mut s, "F3", SHIFT);
-    assert_eq!(text(&mut s, id), "hello world. foo");
-}
-
-#[test]
-fn shift_enter_and_word_and_paragraph_selection() {
-    let (mut s, id) = editing("Hello world,  foo bar\nnext", (0, 7));
-    s.execute("text.selectWord", &json!({})).unwrap();
-    assert_eq!(sel(&s), ((0, 6), (0, 11)));
-    s.execute("text.selectWord", &json!({"at": [0, 12]})).unwrap();
-    assert_eq!(sel(&s), ((0, 11), (0, 12)));
-    // Triple-click: the paragraph and its mark.
-    s.execute("text.selectParagraph", &json!({"at": [0, 3]})).unwrap();
-    assert_eq!(sel(&s), ((0, 0), (1, 0)));
-    s.execute("text.selectParagraph", &json!({"at": [1, 1]})).unwrap();
-    assert_eq!(sel(&s), ((1, 0), (1, 4)));
-    s.execute("text.edit", &json!({"id": id, "at": [1, 2]})).unwrap();
-    press(&mut s, "Enter", SHIFT);
-    let b = s.doc().unwrap().shape(deckcraft_model::ShapeId(id)).unwrap().text.clone().unwrap();
-    assert_eq!(b.paragraphs.len(), 2);
-    assert_eq!(b.paragraphs[1].text(), "ne\u{b}xt");
-}
-
-#[test]
-fn keys_never_panic_on_any_text() {
-    let texts = ["", " ", "\u{b}", "\t\t", "👨\u{200d}👩\u{200d}👧", "e\u{301}", "日本", "مرحبا", "a\n\nb", "  x  \n  "];
-    let keys = ["Left", "Right", "Up", "Down", "Home", "End", "Backspace", "Delete"];
-    for t in texts {
-        for k in keys {
-            for m in [CTRL, CTRL_SHIFT, NONE, SHIFT, ALT] {
-                for at in [(0, 0), (0, 1), (5, 5)] {
-                    let (mut s, _) = editing(t, at);
-                    for _ in 0..3 {
-                        let _ = s.key(k, m).unwrap();
-                    }
-                }
-            }
-        }
-    }
-}

crates/engine/src/tools.rs

@@ -219,10 +219,6 @@ impl Session {
         if st.selection.text.is_none() || st.selection.shapes.len() == 1 {
             for id in st.selection.shapes.iter().rev() {
                 let Some(sh) = st.shape(*id) else { continue };
-                // A locked object shows no live handles: it can't be sized, rotated or reshaped.
-                if sh.locked {
-                    continue;
-                }
                 let x = xfrm_of(&st.doc, &st.selection, sh);
                 if sh.is_line() {
                     let a = x.affine();
@@ -251,9 +247,8 @@ impl Session {
             }
         }
         // Shapes, topmost first.
-        // Locked objects are still picked (to format them or type in them); they just don't move.
         for sh in st.shapes().iter().rev() {
-            if sh.hidden {
+            if sh.hidden || sh.locked {
                 continue;
             }
             if let Some(h) = hit_shape(st, sh, p, tol) {
@@ -270,10 +265,6 @@ impl Session {
         if !(p.x.is_finite() && p.y.is_finite()) {
             return Ok(Value::Null);
         }
-        // A press (not a hover) settles an input method's composition, as clicking does in PowerPoint.
-        if !matches!(ev.kind, PointerKind::Move) {
-            self.end_composition();
-        }
         match ev.kind {
             PointerKind::Move => {
                 if let Some(Drag::Freeform { points, mode, .. }) = &self.tool.drag {
@@ -428,9 +419,7 @@ impl Session {
                 } else {
                     vec![id]
                 };
-                // Locked objects stay put when the selection is dragged.
-                let origs: Vec<(ShapeId, Xfrm)> =
-                    ids.iter().filter_map(|i| st.shape(*i).filter(|s| !s.locked).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
+                let origs: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|i| st.shape(*i).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
                 // A click (no drag) on text puts the caret there; unselected text boxes and
                 // placeholders take the caret straight away like PowerPoint.
                 let enter_text = (text && !toggle && (selected || is_text_first(st, id))).then_some((id, p));
@@ -440,8 +429,7 @@ impl Session {
                     sel.text = None;
                     sel.cells = None;
                 })?;
-                let duplicate = mods.alt && origs.len() == ids.len();
-                self.tool.drag = Some(Drag::Move { ids, start: p, origs, moved: false, duplicate, enter_text });
+                self.tool.drag = Some(Drag::Move { ids, start: p, origs, moved: false, duplicate: mods.alt, enter_text });
                 // Format Painter applies on click.
                 if self.painter.is_some() && !toggle {
                     let _ = self.execute("format.painterApply", &json!({"ids": [id]}));
@@ -472,7 +460,7 @@ impl Session {
         match drag {
             Drag::Move { ids, start, origs, moved, duplicate, enter_text } => {
                 let mut d = p - start;
-                if !moved && (d.hypot() < tol.max(1.0) || origs.is_empty()) {
+                if !moved && d.hypot() < tol.max(1.0) {
                     return Ok(Value::Null);
                 }
                 if !moved {

crates/fonts/src/fallback.rs

@@ -17,11 +17,6 @@ use skrifa::raw::TableProvider;
 use crate::script::{ScriptTag, script_of};
 use crate::{CRAFT_FONTS, FontDb, FontFace};
 
-/// Variation selector 15: text presentation.
-const TEXT_SELECTOR: char = '\u{FE0E}';
-/// Combining enclosing keycap.
-const KEYCAP: char = '\u{20E3}';
-
 /// Characters that never decide a face: they're drawn by whatever face the cluster gets.
 fn ignorable(c: char) -> bool {
     c.is_whitespace()
@@ -29,74 +24,6 @@ fn ignorable(c: char) -> bool {
         || matches!(c as u32, 0x200B..=0x200F | 0x202A..=0x202E | 0x2060..=0x2069 | 0xFE00..=0xFE0F | 0xFEFF | 0xE0100..=0xE01EF)
 }
 
-/// Is the cluster an emoji drawn in colour: a pictograph that defaults to emoji presentation
-/// (Unicode's Emoji_Presentation, including BMP ones such as ⭐ ✅ ☔ ⌚ ⏩), or a sequence with an
-/// emoji presentation selector (U+FE0F), a zero-width joiner between pictographs, a skin tone
-/// modifier or regional indicators (flags)? Keycaps ("1️⃣") are not: PowerPoint draws them as text
-/// (an outlined key), as it draws ♥ ✔ ☎ ⬆ ▶ without a selector.
-pub fn is_emoji_cluster(cluster: &[char]) -> bool {
-    if cluster.contains(&'\u{FE0E}') || cluster.contains(&'\u{20E3}') {
-        return false;
-    }
-    let pictographic = |c: char| matches!(c as u32, 0x1F000..=0x1FAFF | 0x2600..=0x27BF | 0x2B00..=0x2BFF | 0x2190..=0x21FF | 0x2300..=0x23FF);
-    let default_emoji = |c: char| {
-        matches!(
-            c as u32,
-            0x1F300..=0x1F64F
-                | 0x1F680..=0x1F6FF
-                | 0x1F900..=0x1F9FF
-                | 0x1FA70..=0x1FAFF
-                | 0x1F1E6..=0x1F1FF
-                | 0x1F004
-                | 0x1F0CF
-                | 0x1F18E
-                | 0x1F191..=0x1F19A
-                | 0x1F201
-                | 0x1F21A
-                | 0x1F22F
-                | 0x1F232..=0x1F236
-                | 0x1F238..=0x1F23A
-                | 0x1F250..=0x1F251
-                | 0x231A..=0x231B
-                | 0x23E9..=0x23EC
-                | 0x23F0
-                | 0x23F3
-                | 0x25FD..=0x25FE
-                | 0x2614..=0x2615
-                | 0x2648..=0x2653
-                | 0x267F
-                | 0x2693
-                | 0x26A1
-                | 0x26AA..=0x26AB
-                | 0x26BD..=0x26BE
-                | 0x26C4..=0x26C5
-                | 0x26CE
-                | 0x26D4
-                | 0x26EA
-                | 0x26F2..=0x26F3
-                | 0x26F5
-                | 0x26FA
-                | 0x26FD
-                | 0x2705
-                | 0x270A..=0x270B
-                | 0x2728
-                | 0x274C
-                | 0x274E
-                | 0x2753..=0x2755
-                | 0x2757
-                | 0x2795..=0x2797
-                | 0x27B0
-                | 0x27BF
-                | 0x2B1B..=0x2B1C
-                | 0x2B50
-                | 0x2B55
-        )
-    };
-    cluster.iter().any(|&c| default_emoji(c))
-        || (cluster.contains(&'\u{FE0F}') && cluster.iter().any(|&c| pictographic(c)))
-        || (cluster.contains(&'\u{200D}') && cluster.iter().any(|&c| pictographic(c)))
-}
-
 /// Does `face` draw every character of the cluster?
 pub fn covers_cluster(face: &FontFace, cluster: &[char]) -> bool {
     cluster.iter().all(|c| ignorable(*c) || face.covers(*c))
@@ -128,29 +55,9 @@ impl FontDb {
     /// bundled face for its script, else an installed face for the script, else any loaded
     /// face that draws it, else `chain[0]` (or the default face if `chain` is empty).
     pub fn cascade(&self, cluster: &[char], chain: &[Arc<FontFace>], style: &str) -> Arc<FontFace> {
-        // Emoji take a colour face (with its ZWJ sequences, skin tones and flags) before the
-        // document's fonts, as PowerPoint draws them, even when a text font has a plain glyph.
-        if is_emoji_cluster(cluster) {
-            if let Some(f) = chain.iter().find(|f| f.is_color() && covers_cluster(f, cluster)) {
-                return f.clone();
-            }
-            if let Some(key) = cluster.iter().copied().find(|c| !ignorable(*c))
-                && let Some(f) = self.color_face_for(key, cluster)
-            {
-                return f;
-            }
-        }
         if let Some(f) = chain.iter().find(|f| covers_cluster(f, cluster)) {
             return f.clone();
         }
-        // Text presentation (U+FE0E) and keycaps: a plain face, not a colour emoji one.
-        let text_style = cluster.contains(&TEXT_SELECTOR) || cluster.contains(&KEYCAP);
-        if text_style
-            && let Some(key) = cluster.iter().copied().find(|c| !ignorable(*c))
-            && let Some(f) = self.plain_face_for(key, cluster)
-        {
-            return f;
-        }
         let first = || chain.first().cloned().unwrap_or_else(|| self.face(crate::DEFAULT_FAMILY, style));
         let Some(key) = cluster.iter().copied().find(|c| !ignorable(*c)) else { return first() };
         let script = cluster.iter().find_map(|c| script_of(*c));
@@ -182,23 +89,11 @@ impl FontDb {
             }
         }
         let exclude = chain.first().map(|f| f.id()).unwrap_or(u32::MAX);
-        let f = match self.fallback_for(key, exclude) {
+        match self.fallback_for(key, exclude) {
             Some(f) if covers_cluster(&f, cluster) => f,
             Some(f) if chain.iter().all(|c| !c.covers(key)) => f,
-            // A letter with marks the run's font lacks (stacked combining marks): a loaded plain
-            // face that draws the whole cluster, as PowerPoint draws the marks, before the run's
-            // font with missing-glyph boxes.
-            _ => self.read_faces().iter().find(|f| !f.is_color() && covers_cluster(f, cluster)).cloned().unwrap_or_else(first),
-        };
-        // A pictograph that defaults to text presentation (⚠ ♥ ⬆ ▶) whose first fallback is the
-        // colour emoji font: PowerPoint draws it from a plain symbol font.
-        if f.is_color()
-            && !is_emoji_cluster(cluster)
-            && let Some(plain) = self.plain_face_for(key, cluster)
-        {
-            return plain;
+            _ => first(),
         }
-        f
     }
 
     /// An installed (non-bundled) face covering the cluster, loading one from the system catalog

crates/fonts/src/fontdb.rs

@@ -52,53 +52,6 @@ pub fn substitutes(family: &str) -> &'static [&'static str] {
     }
 }
 
-/// Families whose open substitutes ([`substitutes`]) keep their metrics, so text drawn with
-/// them breaks into the same lines.
-fn has_metric_twin(family: &str) -> bool {
-    matches!(
-        family.to_ascii_lowercase().as_str(),
-        "calibri" | "calibri light" | "cambria" | "cambria math" | "arial" | "helvetica" | "times new roman" | "times" | "courier new" | "courier"
-    )
-}
-
-/// The installed family PowerPoint draws a missing `family` with instead of Calibri: Liberation
-/// Sans and Serif as Arial and Times New Roman (observed in PowerPoint; Liberation Mono, Carlito,
-/// Caladea, Arimo and Tinos are not mapped and draw in Calibri), and Windows' standard font
-/// substitutes (Arial CE, Times New Roman CYR…).
-fn office_twin(family: &str) -> Option<&'static str> {
-    let f = family.to_ascii_lowercase();
-    Some(match f.as_str() {
-        "liberation sans" | "helvetica" | "helv" => "Arial",
-        "liberation serif" | "times" | "tms rmn" => "Times New Roman",
-        _ => {
-            let base = f
-                .strip_suffix(" baltic")
-                .or(f.strip_suffix(" ce"))
-                .or(f.strip_suffix(" cyr"))
-                .or(f.strip_suffix(" greek"))
-                .or(f.strip_suffix(" tur"))?;
-            match base {
-                "arial" => "Arial",
-                "courier new" => "Courier New",
-                "times new roman" => "Times New Roman",
-                _ => return None,
-            }
-        }
-    })
-}
-
-/// Office's downloadable (cloud) families: PowerPoint fetches them when a document uses them, so
-/// they draw as themselves there, not as Calibri. Without them DeckCraft keeps their closest open
-/// substitute ([`substitutes`]; Aptos as Inter).
-fn is_office_cloud_font(family: &str) -> bool {
-    let f = family.to_ascii_lowercase();
-    f.starts_with("aptos") || ["bierstadt", "grandview", "seaford", "skeena", "tenorite"].iter().any(|c| f.starts_with(c))
-}
-
-/// The family PowerPoint draws a document's Latin text in when the font it names isn't installed,
-/// whatever the theme, `panose` or `pitchFamily` say.
-pub const MISSING_FONT_FAMILY: &str = "Calibri";
-
 #[derive(Clone)]
 enum FontBytes {
     Static(&'static [u8]),
@@ -112,10 +65,6 @@ pub struct FontFace {
     pub family: String,
     /// Typographic style name (e.g. "Semibold", "Italic").
     pub style: String,
-    /// The Windows (GDI) family and style names (`name` IDs 1 and 2) when the family differs from
-    /// the typographic one: "Segoe UI Semibold" / "Regular" for Segoe UI Semibold. Documents name
-    /// fonts this way.
-    pub legacy: Option<(String, String)>,
     /// usWeightClass-style weight (400 = regular).
     pub weight: f32,
     pub italic: bool,
@@ -130,16 +79,6 @@ pub struct FontFace {
     /// values).
     pub cap_height: f64,
     pub x_height: f64,
-    /// Where the baseline sits in a line, as a share of the line's height from its top: the
-    /// Windows ascent over the Windows ascent plus descent (OS/2 `usWinAscent`/`usWinDescent`),
-    /// the split PowerPoint uses (computed by `line_split`).
-    pub line_split: f64,
-    /// Underline position (top edge, below the baseline) and thickness in font units (`post`
-    /// table; 0.1 and 0.05 em when the font has none). PowerPoint draws single underlines there.
-    pub underline: (f64, f64),
-    /// Strikethrough position (top edge, above the baseline) and thickness in font units (OS/2;
-    /// 0.26 and 0.05 em when the font has none). PowerPoint draws single strikethroughs there.
-    pub strikeout: (f64, f64),
     pub shaper: harfrust::ShaperData,
     /// Variable fonts: the named instance's axis settings (user units; empty = default instance),
     /// the normalised location and the shaper's view of it.
@@ -148,8 +87,6 @@ pub struct FontFace {
     pub instance: Option<harfrust::ShaperInstance>,
     /// Basic Multilingual Plane coverage bitset, built on first use.
     bmp: std::sync::OnceLock<Box<[u64]>>,
-    /// Colour glyph tables present (`is_color`), looked up on first use.
-    color: std::sync::OnceLock<bool>,
 }
 
 /// A cheap `Copy` handle to a face. Faces are never unloaded, so the handle lives for the rest of
@@ -217,11 +154,6 @@ impl FontFace {
     pub fn skrifa(&self) -> Option<skrifa::FontRef<'_>> {
         skrifa::FontRef::from_index(self.data(), self.index).ok()
     }
-    /// Does the face draw colour glyphs (a `COLR`, `CBDT`, `sbix` or `SVG ` table, as colour emoji
-    /// fonts have)?
-    pub fn is_color(&self) -> bool {
-        *self.color.get_or_init(|| has_color_tables(self.data(), self.index))
-    }
     pub fn hb(&self) -> Option<harfrust::FontRef<'_>> {
         harfrust::FontRef::from_index(self.data(), self.index).ok()
     }
@@ -310,11 +242,6 @@ pub struct FontDb {
     /// scan, so what they find doesn't depend on what ran before them.
     #[cfg(not(target_arch = "wasm32"))]
     cataloged: std::sync::OnceLock<()>,
-    /// Families (lower case) whose cataloged files have all been loaded: a family's files load
-    /// together, so a lookup never settles for the one face another name loaded ("Segoe UI
-    /// Semibold" loads a face of the family "Segoe UI").
-    #[cfg(not(target_arch = "wasm32"))]
-    loaded_families: Mutex<std::collections::HashSet<String>>,
     /// System fallback state: enabled, and characters no system font covers.
     #[cfg(not(target_arch = "wasm32"))]
     sys: Mutex<SysFallback>,
@@ -327,13 +254,6 @@ struct SysFallback {
     misses: std::collections::HashSet<char>,
 }
 
-/// Does face `index` of `data` carry colour glyph tables?
-fn has_color_tables(data: &[u8], index: u32) -> bool {
-    use skrifa::raw::types::Tag;
-    let Ok(f) = skrifa::FontRef::from_index(data, index) else { return false };
-    [b"COLR", b"CBDT", b"sbix", b"SVG "].iter().any(|t| f.table_data(Tag::new(t)).is_some())
-}
-
 /// Families tried (when installed) for characters the loaded fonts lack: CJK, symbols, emoji.
 #[cfg(not(target_arch = "wasm32"))]
 const SYSTEM_FALLBACKS: &[&str] = &[
@@ -378,16 +298,6 @@ fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {
     Some((family, style))
 }
 
-/// A face's Windows (GDI) family and style (`name` IDs 1 and 2) when that family differs from the
-/// typographic `family`.
-fn legacy_names(f: &skrifa::FontRef<'_>, family: &str) -> Option<(String, String)> {
-    let legacy = name(f, &[StringId::FAMILY_NAME])?;
-    if legacy.eq_ignore_ascii_case(family) {
-        return None;
-    }
-    Some((legacy, name(f, &[StringId::SUBFAMILY_NAME]).unwrap_or_else(|| "Regular".into())))
-}
-
 /// (family, style) of every face in the font file at `path`, reading only its table directories
 /// and `name` tables: a scan opens hundreds of font files, many of them megabytes long. A
 /// variable font is cataloged under its default style; its named instances appear once it loads.
@@ -434,13 +344,8 @@ fn file_face_names(path: &std::path::Path) -> Vec<(String, String)> {
                 font.extend_from_slice(&u32::to_be_bytes(v));
             }
             font.extend_from_slice(&table);
-            let f = skrifa::FontRef::new(&font).ok()?;
-            let (family, style) = face_names(&f)?;
-            // Cataloged under its Windows family too, so "Segoe UI Semibold" finds the file.
-            let legacy = legacy_names(&f, &family);
-            Some(std::iter::once((family, style)).chain(legacy))
+            face_names(&skrifa::FontRef::new(&font).ok()?)
         })
-        .flatten()
         .collect()
 }
 
@@ -456,12 +361,6 @@ pub fn system_font_dirs() -> Vec<std::path::PathBuf> {
         dirs.extend(["/System/Library/Fonts", "/Library/Fonts"].map(Into::into));
         if let Some(h) = &home {
             dirs.push(h.join("Library/Fonts"));
-            // Fonts Microsoft Office downloads on demand (Aptos…), used where Office put them.
-            dirs.push(h.join("Library/Group Containers/UBF8T346G9.Office/FontCache/4/CloudFonts"));
-        }
-        // Fonts Office installs inside its apps.
-        for app in ["Microsoft PowerPoint", "Microsoft Word", "Microsoft Excel"] {
-            dirs.push(std::path::PathBuf::from(format!("/Applications/{app}.app/Contents/Resources/DFonts")));
         }
         // Fonts macOS ships as assets (PingFang, Yu Mincho, …): com_apple_MobileAsset_Font<N>.
         for parent in ["/System/Library/AssetsV2", "/System/Library/AssetsV2/PreinstalledAssetsV2/InstallWithOs"] {
@@ -476,11 +375,7 @@ pub fn system_font_dirs() -> Vec<std::path::PathBuf> {
         let root = std::env::var_os("WINDIR").map(std::path::PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());
         dirs.push(root.join("Fonts"));
         if let Some(l) = std::env::var_os("LOCALAPPDATA") {
-            let l = std::path::PathBuf::from(l);
-            dirs.push(l.join("Microsoft\\Windows\\Fonts"));
-            // Fonts Microsoft Office downloads on demand (Aptos…), used where Office put them;
-            // DeckCraft never ships or needs them.
-            dirs.push(l.join("Microsoft\\FontCache\\4\\CloudFonts"));
+            dirs.push(std::path::PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));
         }
     } else {
         dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(Into::into));
@@ -541,23 +436,6 @@ pub(crate) fn last_resort_face() -> Arc<FontFace> {
     .clone()
 }
 
-/// The share of a line above the baseline (`FontFace::line_split`): OS/2 `usWinAscent` over
-/// `usWinAscent + usWinDescent`, else the ascent over ascent plus descent. Fonts whose Windows
-/// extent is huge (Gabriola, Cambria Math: over 1.5 em) get 0.81, where PowerPoint puts their
-/// baseline (observed).
-fn line_split(f: &skrifa::FontRef, ascent: f64, descent: f64, upem: f64) -> f64 {
-    use skrifa::raw::TableProvider;
-    let (a, d) = match f.os2() {
-        Ok(os2) if os2.us_win_ascent() > 0 => (os2.us_win_ascent() as f64, os2.us_win_descent() as f64),
-        _ => (ascent, descent),
-    };
-    let total = a + d;
-    if !total.is_finite() || total <= 0.0 || a < 0.0 || d < 0.0 {
-        return 0.8;
-    }
-    if total > upem * 1.5 { 0.81 } else { (a / total).clamp(0.5, 1.0) }
-}
-
 fn make_face(bytes: FontBytes, index: u32, family: String, style: String, coords: Vec<([u8; 4], f32)>) -> Option<FontFace> {
     let data: &[u8] = match &bytes {
         FontBytes::Static(b) => b,
@@ -578,12 +456,10 @@ fn make_face(bytes: FontBytes, index: u32, family: String, style: String, coords
         .map(|v| v >= 0.5)
         .or(axis(b"slnt").map(|v| v.abs() > 0.1))
         .unwrap_or(!matches!(a.style, skrifa::attribute::Style::Normal) || style_italic(&style));
-    let legacy = if coords.is_empty() { legacy_names(&f, &family) } else { None };
     Some(FontFace {
         id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
         family,
         style,
-        legacy,
         weight,
         italic,
         upem: m.units_per_em.max(1) as f64,
@@ -591,9 +467,6 @@ fn make_face(bytes: FontBytes, index: u32, family: String, style: String, coords
         descent: -(m.descent as f64),
         cap_height: m.cap_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.72),
         x_height: m.x_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.5),
-        line_split: line_split(&f, m.ascent as f64, -(m.descent as f64), m.units_per_em.max(1) as f64),
-        underline: underline_metrics(m.underline, m.units_per_em.max(1) as f64),
-        strikeout: strikeout_metrics(m.strikeout, m.units_per_em.max(1) as f64),
         shaper,
         coords,
         location,
@@ -601,34 +474,9 @@ fn make_face(bytes: FontBytes, index: u32, family: String, style: String, coords
         bytes,
         index,
         bmp: std::sync::OnceLock::new(),
-        color: std::sync::OnceLock::new(),
     })
 }
 
-/// The underline's top edge below the baseline and its thickness, font units, from the `post`
-/// table (its position is the top edge: Arial's -217/2048 is where PowerPoint's underline starts,
-/// 10 px below the baseline at 96 pt); fonts without a usable one get 0.1 em and 0.05 em.
-fn underline_metrics(d: Option<skrifa::metrics::Decoration>, upem: f64) -> (f64, f64) {
-    match d {
-        Some(d) if d.thickness > 0.0 && (d.thickness as f64) < upem * 0.3 && (d.offset as f64).abs() < upem * 0.5 => {
-            (-(d.offset as f64), d.thickness as f64)
-        }
-        _ => (upem * 0.1, upem * 0.05),
-    }
-}
-
-/// The strikethrough's top edge above the baseline and its thickness, font units, from OS/2 (its
-/// position is the top edge: Arial's 530/2048 is where PowerPoint's strikethrough starts, 25 px
-/// above the baseline at 96 pt); fonts without a usable one get 0.26 em and 0.05 em.
-fn strikeout_metrics(d: Option<skrifa::metrics::Decoration>, upem: f64) -> (f64, f64) {
-    match d {
-        Some(d) if d.thickness > 0.0 && (d.thickness as f64) < upem * 0.3 && d.offset > 0.0 && (d.offset as f64) < upem => {
-            (d.offset as f64, d.thickness as f64)
-        }
-        _ => (upem * 0.26, upem * 0.05),
-    }
-}
-
 /// The named style part of a style with axis settings (`Bold {wght:650}` → `Bold`).
 pub fn base_style(style: &str) -> &str {
     style.split('{').next().unwrap_or(style).trim()
@@ -686,8 +534,6 @@ impl FontDb {
             #[cfg(not(target_arch = "wasm32"))]
             cataloged: std::sync::OnceLock::new(),
             #[cfg(not(target_arch = "wasm32"))]
-            loaded_families: Mutex::new(std::collections::HashSet::new()),
-            #[cfg(not(target_arch = "wasm32"))]
             sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),
         }
     }
@@ -793,8 +639,6 @@ impl FontDb {
     /// Returns the number of faces cataloged.
     #[cfg(not(target_arch = "wasm32"))]
     pub fn load_system_fonts(&self) -> usize {
-        // Families load again from the new catalog when next looked up.
-        self.loaded_families.lock().unwrap_or_else(|e| e.into_inner()).clear();
         // The first scan, or a rescan once it is done (never both at once).
         let mut first = None;
         self.cataloged.get_or_init(|| first = Some(self.scan_font_dirs()));
@@ -875,35 +719,17 @@ impl FontDb {
             .unwrap_or_else(last_resort_face)
     }
 
-    /// The face a document's text in `family` is drawn with, as PowerPoint draws it: the family
-    /// when it is installed or bundled, or a metric-compatible stand-in (Carlito for Calibri,
-    /// Liberation Sans for Arial…), or the family PowerPoint maps it to (Liberation Sans as Arial,
-    /// see `office_twin`); any other missing family is drawn in Calibri (or Carlito).
-    /// DeckCraft's own default family keeps [`FontDb::face`]'s fallbacks.
-    pub fn document_face(&self, family: &str, style: &str) -> Arc<FontFace> {
-        if family.eq_ignore_ascii_case(FALLBACK_FAMILY) || has_metric_twin(family) || is_office_cloud_font(family) || self.has_family(family) {
-            return self.face(family, style);
-        }
-        if let Some(twin) = office_twin(family) {
-            return self.face(twin, style);
-        }
-        self.face(MISSING_FONT_FAMILY, style)
-    }
-
     fn try_family(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {
-        // Every installed file of the family first, so the best style is among the candidates. The
-        // lock is held while the files load, so another thread looking up the family waits for
-        // them rather than finding none and falling back to another family.
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let mut loaded = self.loaded_families.lock().unwrap_or_else(|e| e.into_inner());
-            let key = family.to_lowercase();
-            if !loaded.contains(&key) {
-                self.load_cataloged(family);
-                loaded.insert(key);
-            }
+        if let Some(f) = self.find(family, style) {
+            return Some(f);
         }
-        self.find(family, style)
+        #[cfg(not(target_arch = "wasm32"))]
+        if self.load_cataloged(family)
+            && let Some(f) = self.find(family, style)
+        {
+            return Some(f);
+        }
+        None
     }
 
     /// Is `family` available (loaded, or installed on the system)?
@@ -919,9 +745,7 @@ impl FontDb {
     }
 
     pub(crate) fn is_loaded(&self, family: &str) -> bool {
-        self.read_faces()
-            .iter()
-            .any(|f| f.family.eq_ignore_ascii_case(family) || f.legacy.as_ref().is_some_and(|(lf, _)| lf.eq_ignore_ascii_case(family)))
+        self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(family))
     }
 
     /// A variable font's axes: (tag, name, min, default, max), empty for static fonts.
@@ -976,27 +800,11 @@ impl FontDb {
             return self.instance(family, style);
         }
         let faces = self.read_faces();
-        let mut cands: Vec<&Arc<FontFace>> = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family)).collect();
-        let ns = norm(style);
-        if cands.is_empty() {
-            // A Windows family name ("Segoe UI Semibold", "Arial Black"): its faces, matched by
-            // their Windows style ("Regular", "Bold"…).
-            cands = faces.iter().filter(|f| f.legacy.as_ref().is_some_and(|(lf, _)| lf.eq_ignore_ascii_case(family))).collect();
-            if let Some(f) = cands.iter().find(|f| f.legacy.as_ref().is_some_and(|(_, ls)| norm(ls) == ns)) {
-                return Some((*f).clone());
-            }
-            // Bold of a family that is itself a weight (Semibold, Light): the face, made bolder
-            // by the caller, as Windows does, rather than a face of another weight.
-            if let Some(f) = cands
-                .iter()
-                .find(|f| f.legacy.as_ref().is_some_and(|(_, ls)| norm(ls) == norm(if style_italic(style) { "Italic" } else { "Regular" })))
-            {
-                return Some((*f).clone());
-            }
-        }
+        let cands: Vec<&Arc<FontFace>> = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family)).collect();
         if cands.is_empty() {
             return None;
         }
+        let ns = norm(style);
         if let Some(f) = cands.iter().find(|f| norm(&f.style) == ns) {
             return Some((*f).clone());
         }
@@ -1072,134 +880,6 @@ impl FontDb {
         false
     }
 
-    /// A loaded colour face drawing all of `cluster`, loading an installed colour font that covers
-    /// `key` if none is loaded yet. Misses are remembered.
-    pub(crate) fn color_face_for(&self, key: char, cluster: &[char]) -> Option<Arc<FontFace>> {
-        let pick = |db: &FontDb| {
-            let faces = db.read_faces();
-            let mut v: Vec<&Arc<FontFace>> = faces.iter().filter(|f| crate::covers_cluster(f, cluster) && f.is_color()).collect();
-            v.sort_by_key(|f| (f.italic, (f.weight - 400.0).abs() as i32));
-            v.first().map(|f| (*f).clone())
-        };
-        if let Some(f) = pick(self) {
-            return Some(f);
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        if self.system_color_fallback(key) {
-            return pick(self);
-        }
-        let _ = key;
-        None
-    }
-
-    /// A loaded plain (not colour) face drawing all of `cluster`, loading an installed plain font
-    /// that covers `key` if none is loaded yet. Misses are remembered.
-    pub(crate) fn plain_face_for(&self, key: char, cluster: &[char]) -> Option<Arc<FontFace>> {
-        // Symbol fonts first (PowerPoint draws ⚠ ♥ ⬆ from the system's symbol font), then the
-        // usual fallback families in order, then any other.
-        let rank = |f: &FontFace| {
-            if f.family.contains("Symbol") {
-                return 0;
-            }
-            #[cfg(not(target_arch = "wasm32"))]
-            if let Some(i) = SYSTEM_FALLBACKS.iter().position(|s| s.eq_ignore_ascii_case(&f.family)) {
-                return i + 1;
-            }
-            1000
-        };
-        let pick = |db: &FontDb| {
-            let faces = db.read_faces();
-            let mut v: Vec<&Arc<FontFace>> = faces.iter().filter(|f| !f.is_color() && crate::covers_cluster(f, cluster)).collect();
-            v.sort_by_key(|f| (rank(f), f.italic, (f.weight - 400.0).abs() as i32));
-            v.first().map(|f| (*f).clone())
-        };
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let cataloged: Vec<String> = self.read_catalog().iter().map(|e| e.family.clone()).collect();
-            for fam in SYSTEM_FALLBACKS.iter().filter(|f| f.contains("Symbol")) {
-                if !self.is_loaded(fam) && cataloged.iter().any(|f| f.eq_ignore_ascii_case(fam)) {
-                    self.load_cataloged(fam);
-                }
-            }
-        }
-        if let Some(f) = pick(self) {
-            return Some(f);
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        if self.system_plain_fallback(key) {
-            return pick(self);
-        }
-        let _ = key;
-        None
-    }
-
-    /// Load an installed font without colour tables covering `c`. True if one was loaded.
-    #[cfg(not(target_arch = "wasm32"))]
-    fn system_plain_fallback(&self, c: char) -> bool {
-        static MISSES: Mutex<Option<std::collections::HashSet<char>>> = Mutex::new(None);
-        if c.is_control() || c.is_whitespace() {
-            return false;
-        }
-        if !self.sys.lock().unwrap_or_else(|e| e.into_inner()).enabled {
-            return false;
-        }
-        if MISSES.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert_with(Default::default).contains(&c) {
-            return false;
-        }
-        let mut paths: Vec<std::path::PathBuf> = self.read_catalog().iter().map(|e| e.path.clone()).collect();
-        paths.sort();
-        paths.dedup();
-        for p in paths {
-            if std::fs::metadata(&p).map(|m| m.len() > 40 << 20).unwrap_or(true) {
-                continue;
-            }
-            let Ok(data) = std::fs::read(&p) else { continue };
-            let hit = enumerate_faces(&data).iter().any(|(i, _, _, _)| {
-                !has_color_tables(&data, *i) && skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some())
-            });
-            if hit && self.add_font(data) > 0 {
-                return true;
-            }
-        }
-        MISSES.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert_with(Default::default).insert(c);
-        false
-    }
-
-    /// Load an installed colour font covering `c`. True if one was loaded.
-    #[cfg(not(target_arch = "wasm32"))]
-    fn system_color_fallback(&self, c: char) -> bool {
-        static MISSES: Mutex<Option<std::collections::HashSet<char>>> = Mutex::new(None);
-        if c.is_control() || c.is_whitespace() {
-            return false;
-        }
-        {
-            let sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());
-            if !sys.enabled {
-                return false;
-            }
-        }
-        if MISSES.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert_with(Default::default).contains(&c) {
-            return false;
-        }
-        let mut paths: Vec<std::path::PathBuf> = self.read_catalog().iter().map(|e| e.path.clone()).collect();
-        paths.sort();
-        paths.dedup();
-        for p in paths {
-            if std::fs::metadata(&p).map(|m| m.len() > 64 << 20).unwrap_or(true) {
-                continue;
-            }
-            let Ok(data) = std::fs::read(&p) else { continue };
-            let hit = enumerate_faces(&data).iter().any(|(i, _, _, _)| {
-                has_color_tables(&data, *i) && skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some())
-            });
-            if hit && self.add_font(data) > 0 {
-                return true;
-            }
-        }
-        MISSES.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert_with(Default::default).insert(c);
-        false
-    }
-
     /// Glyph outline in font units, y-down (flipped), cached per (face, glyph).
     pub fn outline(&self, face: &FontFace, gid: u32) -> Arc<BezPath> {
         let key = (face.id, gid);

crates/fonts/src/lib.rs

@@ -13,10 +13,8 @@ mod fontdb;
 pub mod script;
 mod shape;
 
-pub use fallback::{bundled_families, covers_cluster, is_emoji_cluster, ligature_carets};
-pub use fontdb::{
-    FALLBACK_FAMILY, FaceRef, FontDb, FontFace, LAST_RESORT_FAMILY, MISSING_FONT_FAMILY, base_style, bundled, substitutes, system_font_dirs,
-};
+pub use fallback::{bundled_families, covers_cluster, ligature_carets};
+pub use fontdb::{FALLBACK_FAMILY, FaceRef, FontDb, FontFace, LAST_RESORT_FAMILY, base_style, bundled, substitutes, system_font_dirs};
 pub use harfrust::Feature;
 use harfrust::Tag;
 pub use kurbo::BezPath;
@@ -138,30 +136,6 @@ mod tests {
         FontDb::global().face(DEFAULT_FAMILY, "Regular")
     }
 
-    #[test]
-    fn emoji_clusters_are_recognised() {
-        let c = |s: &str| s.chars().collect::<Vec<char>>();
-        // As PowerPoint draws them: emoji-presentation characters (⭐ ✅ ☔ ⌚ ⏩) in colour even
-        // without a selector, text-presentation ones (♥ ✔ ☎ ⬆ ▶) as text unless U+FE0F asks, and
-        // keycaps always as text.
-        for yes in ["😀", "👍🏽", "❤\u{FE0F}", "👨\u{200D}👩\u{200D}👧", "🇯🇵", "🏳\u{FE0F}\u{200D}🌈", "⭐", "✅", "☔", "⌚", "⏩", "🀄"]
-        {
-            assert!(is_emoji_cluster(&c(yes)), "{yes:?}");
-        }
-        for no in ["a", "1", "❤", "☺\u{FE0E}", "😀\u{FE0E}", "字", "→", "♥", "✔", "☎", "⬆", "▶", "1\u{FE0F}\u{20E3}", "#\u{20E3}"]
-        {
-            assert!(!is_emoji_cluster(&c(no)), "{no:?}");
-        }
-    }
-
-    #[test]
-    fn colour_fonts_are_recognised() {
-        let db = FontDb::with_font_dirs(Vec::new());
-        assert!(db.add_font(include_bytes!("../../render/tests/fixtures/colr-squares.ttf").to_vec()) > 0);
-        assert!(db.face("DeckCraft Colr Squares", "Regular").is_color());
-        assert!(!fontdb::last_resort_face().is_color());
-    }
-
     #[test]
     fn last_resort_face_parses() {
         let f = fontdb::last_resort_face();
@@ -169,17 +143,6 @@ mod tests {
         assert!(f.upem > 0.0);
     }
 
-    #[test]
-    fn line_split_follows_the_windows_ascent_and_descent() {
-        use skrifa::raw::TableProvider;
-        let f = fontdb::last_resort_face();
-        let font = skrifa::FontRef::new(f.data()).unwrap();
-        let os2 = font.os2().unwrap();
-        let (a, d) = (os2.us_win_ascent() as f64, os2.us_win_descent() as f64);
-        assert!((f.line_split - a / (a + d)).abs() < 1e-9, "{} vs {}", f.line_split, a / (a + d));
-        assert!(f.line_split > 0.5 && f.line_split < 1.0);
-    }
-
     #[test]
     fn some_face_always_resolves() {
         let db = FontDb::with_font_dirs(Vec::new());
@@ -189,65 +152,6 @@ mod tests {
         assert!(!shape(&f, "Hello", &[], |c| c).is_empty());
     }
 
-    #[test]
-    fn windows_family_names_find_their_faces() {
-        // Documents name fonts by their Windows family ("Segoe UI Semibold"); the font's
-        // typographic family is "Segoe UI" with a "Semibold" style. The fixture is named the same way.
-        let check = |db: &FontDb| {
-            assert!(db.has_family("DeckCraft Legacy Semibold"));
-            for style in ["Regular", "Bold"] {
-                let f = db.face("DeckCraft Legacy Semibold", style);
-                assert_eq!((f.family.as_str(), f.style.as_str()), ("DeckCraft Legacy", "Semibold"), "{style}");
-            }
-            assert_eq!(db.document_face("DeckCraft Legacy Semibold", "Regular").family, "DeckCraft Legacy", "installed, so not Calibri");
-            // The typographic name still works.
-            assert_eq!(db.face("DeckCraft Legacy", "Semibold").style, "Semibold");
-        };
-        // Loaded directly…
-        let db = FontDb::with_font_dirs(Vec::new());
-        db.set_system_fallback(false);
-        assert_eq!(db.add_font(include_bytes!("../tests/fixtures/legacy-semibold.ttf").to_vec()), 1);
-        check(&db);
-        // …and found by the system font scan under its Windows name, then loaded.
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
-            let db = FontDb::with_font_dirs(vec![dir.clone()]);
-            db.set_system_fallback(false);
-            check(&db);
-            // Looking up the Windows name loads the Semibold file only; a later lookup of the
-            // family's Regular must still load and pick the Regular file, not settle for Semibold.
-            let db = FontDb::with_font_dirs(vec![dir]);
-            db.set_system_fallback(false);
-            assert_eq!(db.face("DeckCraft Legacy Semibold", "Regular").style, "Semibold");
-            let regular = db.face("DeckCraft Legacy", "Regular");
-            assert_eq!((regular.style.as_str(), regular.weight), ("Regular", 400.0));
-        }
-    }
-
-    #[test]
-    fn missing_document_fonts_are_drawn_in_calibri() {
-        // PowerPoint draws a missing family in Calibri, whatever its panose or the theme says.
-        let db = FontDb::global();
-        for missing in ["Qqq Nonexistent", "Avenir Next Qqq", "", "Arimo Qqq"] {
-            let f = db.document_face(missing, "Bold");
-            assert_eq!(f.family, db.face(MISSING_FONT_FAMILY, "Bold").family, "{missing:?}");
-        }
-        // PowerPoint's own twins and Windows' substitutes, when the font itself is missing.
-        for (missing, twin) in
-            [("Liberation Sans", "Arial"), ("Liberation Serif", "Times New Roman"), ("Arial CE", "Arial"), ("Times New Roman CYR", "Times New Roman")]
-        {
-            if !db.has_family(missing) {
-                assert_eq!(db.document_face(missing, "Regular").family, db.face(twin, "Regular").family, "{missing}");
-            }
-        }
-        // Metric-compatible stand-ins and DeckCraft's default keep their own fallbacks.
-        // So do Office's cloud fonts, which PowerPoint downloads and draws as themselves.
-        for kept in ["Arial", "Times New Roman", "Cambria", "Courier New", FALLBACK_FAMILY, "Aptos", "Aptos Display", "Grandview"] {
-            assert_eq!(db.document_face(kept, "Regular").family, db.face(kept, "Regular").family, "{kept}");
-        }
-    }
-
     #[test]
     fn office_fonts_have_substitutes() {
         assert!(substitutes("Calibri").contains(&"Carlito"));

crates/fonts/tests/fixtures/make_legacy_font.py

@@ -1,55 +0,0 @@
-"""Build the legacy-name test font: DeckCraft Legacy Semibold (contributor-original, CC0-1.0).
-
-Usage: python make_legacy_font.py legacy-semibold.ttf legacy-regular.ttf  (needs fontTools)
-
-legacy-semibold.ttf: typographic family "DeckCraft Legacy", style "Semibold" (name IDs 16/17,
-weight 600); Windows family "DeckCraft Legacy Semibold", style "Regular" (name IDs 1/2), as fonts
-like Segoe UI Semibold are named. legacy-regular.ttf: the family's Regular ("DeckCraft Legacy",
-"Regular", weight 400), named only by IDs 1/2 as Segoe UI's regular file is. Glyphs: .notdef and
-a square for "A".
-"""
-import sys
-
-from fontTools.fontBuilder import FontBuilder
-from fontTools.pens.ttGlyphPen import TTGlyphPen
-
-
-def square():
-    pen = TTGlyphPen(None)
-    pen.moveTo((100, 0))
-    pen.lineTo((100, 700))
-    pen.lineTo((600, 700))
-    pen.lineTo((600, 0))
-    pen.closePath()
-    return pen.glyph()
-
-
-def build(path, names, weight):
-    fb = FontBuilder(1000, isTTF=True)
-    fb.setupGlyphOrder([".notdef", "A"])
-    fb.setupCharacterMap({ord("A"): "A"})
-    fb.setupGlyf({".notdef": TTGlyphPen(None).glyph(), "A": square()})
-    fb.setupHorizontalMetrics({".notdef": (500, 0), "A": (700, 100)})
-    fb.setupHorizontalHeader(ascent=800, descent=-200)
-    fb.setupNameTable(names)
-    fb.setupOS2(usWeightClass=weight, sTypoAscender=800, sTypoDescender=-200, usWinAscent=800, usWinDescent=200)
-    fb.setupPost()
-    fb.save(path)
-
-
-build(sys.argv[1], {
-    "familyName": "DeckCraft Legacy Semibold",
-    "styleName": "Regular",
-    "typographicFamily": "DeckCraft Legacy",
-    "typographicSubfamily": "Semibold",
-    "uniqueFontIdentifier": "DeckCraft Legacy Semibold",
-    "fullName": "DeckCraft Legacy Semibold",
-    "psName": "DeckCraftLegacy-Semibold",
-}, 600)
-build(sys.argv[2], {
-    "familyName": "DeckCraft Legacy",
-    "styleName": "Regular",
-    "uniqueFontIdentifier": "DeckCraft Legacy Regular",
-    "fullName": "DeckCraft Legacy",
-    "psName": "DeckCraftLegacy-Regular",
-}, 400)

crates/geom/src/lib.rs

@@ -8,7 +8,6 @@
 
 pub mod morph;
 pub mod preset;
-pub mod warp;
 
 pub use kurbo::{Affine, BezPath, PathEl, Point, Rect, Shape as KurboShape, Size, Vec2};
 use serde::{Deserialize, Serialize};

crates/geom/src/preset/extra.rs

@@ -1,796 +0,0 @@
-//! More preset outlines: line callouts, arrow callouts, curved and circular arrows, curved
-//! ribbons, gears, tabs and chart markers. Like the rest of `preset`, every outline is our own
-//! construction, fitted to how the shapes look and to what their adjust values mean.
-
-use super::*;
-
-/// Builds the presets this module knows; `None` for any other name.
-pub(super) fn build(name: &str, w: f64, h: f64, a: &dyn Fn(usize) -> f64) -> Option<Geometry> {
-    let ss = w.min(h);
-    let full = Rect::new(0.0, 0.0, w, h);
-    let mut b = Pb::new();
-    let g = match name {
-        "lineInv" => {
-            let l = b.m(0.0, h).l(w, 0.0).take();
-            Geometry { paths: vec![stroke_only(l)], text_rect: full, handles: vec![], sites: vec![Point::new(0.0, h), Point::new(w, 0.0)] }
-        }
-        "nonIsoscelesTrapezoid" => {
-            let max = 50000.0 * w / ss.max(1e-9);
-            let (v1, v2) = (a(0).clamp(0.0, max), a(1).clamp(0.0, max));
-            let (d1, d2) = (ss * v1 / 1e5, ss * v2 / 1e5);
-            let mut g = simple(b.poly(&[(0.0, h), (d1, 0.0), (w - d2, 0.0), (w, h)]).take(), Rect::new(d1 * 0.66, h * 0.2, w - d2 * 0.66, h), w, h);
-            g.handles.push(Handle::new(0, Point::ZERO, Vec2::new(ss / 1e5, 0.0), v1, 0.0, max));
-            g.handles.push(Handle::new(1, Point::new(w, 0.0), Vec2::new(-ss / 1e5, 0.0), v2, 0.0, max));
-            g
-        }
-        "pieWedge" => {
-            b.m(0.0, h).arc(w, h, 180.0, 90.0).l(w, h).z();
-            simple(b.take(), Rect::new(w * 0.29289, h * 0.29289, w, h), w, h)
-        }
-        "flowChartOfflineStorage" => {
-            let tri = b.poly(&[(0.0, 0.0), (w, 0.0), (w / 2.0, h)]).take();
-            let bar = Pb::new().m(w * 0.4, h * 0.8).l(w * 0.6, h * 0.8).take();
-            Geometry {
-                paths: vec![fill(tri), stroke_only(bar)],
-                text_rect: Rect::new(w / 4.0, 0.0, w * 0.75, h * 0.8),
-                handles: vec![],
-                sites: vec![Point::new(w / 2.0, 0.0), Point::new(w / 4.0, h / 2.0), Point::new(w / 2.0, h), Point::new(w * 0.75, h / 2.0)],
-            }
-        }
-        "chartX" | "chartStar" | "chartPlus" => {
-            let body = corner_rect(w, h, [Corner::Square; 4]);
-            let mut l = Pb::new();
-            if name != "chartPlus" {
-                l.m(0.0, 0.0).l(w, h).m(0.0, h).l(w, 0.0);
-            }
-            if name != "chartX" {
-                l.m(w / 2.0, 0.0).l(w / 2.0, h);
-            }
-            if name == "chartPlus" {
-                l.m(0.0, h / 2.0).l(w, h / 2.0);
-            }
-            Geometry { paths: vec![fill_only(body), stroke_only(l.take())], text_rect: full, handles: vec![], sites: mid_sites(w, h) }
-        }
-        "cornerTabs" | "squareTabs" | "plaqueTabs" => {
-            // Each tab's size is a twentieth of the diagonal.
-            let d = (w.hypot(h) / 20.0).min(w / 2.0).min(h / 2.0);
-            match name {
-                "cornerTabs" => {
-                    b.poly(&[(0.0, 0.0), (d, 0.0), (0.0, d)]);
-                    b.poly(&[(w - d, 0.0), (w, 0.0), (w, d)]);
-                    b.poly(&[(w, h - d), (w, h), (w - d, h)]);
-                    b.poly(&[(0.0, h - d), (d, h), (0.0, h)]);
-                }
-                "squareTabs" => {
-                    b.poly(&[(0.0, 0.0), (d, 0.0), (d, d), (0.0, d)]);
-                    b.poly(&[(w - d, 0.0), (w, 0.0), (w, d), (w - d, d)]);
-                    b.poly(&[(w - d, h - d), (w, h - d), (w, h), (w - d, h)]);
-                    b.poly(&[(0.0, h - d), (d, h - d), (d, h), (0.0, h)]);
-                }
-                _ => {
-                    if d > 0.0 {
-                        b.m(0.0, 0.0).l(d, 0.0).arc(d, d, 0.0, 90.0).z();
-                        b.m(w, 0.0).l(w, d).arc(d, d, 90.0, 90.0).z();
-                        b.m(w, h).l(w - d, h).arc(d, d, 180.0, 90.0).z();
-                        b.m(0.0, h).l(0.0, h - d).arc(d, d, 270.0, 90.0).z();
-                    } else {
-                        b.m(0.0, 0.0).z();
-                    }
-                }
-            }
-            Geometry { paths: vec![fill(b.take())], text_rect: full.inset(-d), handles: vec![], sites: mid_sites(w, h) }
-        }
-        "callout1"
-        | "callout2"
-        | "callout3"
-        | "accentCallout1"
-        | "accentCallout2"
-        | "accentCallout3"
-        | "borderCallout2"
-        | "borderCallout3"
-        | "accentBorderCallout1"
-        | "accentBorderCallout2"
-        | "accentBorderCallout3" => {
-            let n = match name.chars().last() {
-                Some('2') => 2,
-                Some('3') => 3,
-                _ => 1,
-            };
-            line_callout(w, h, a, n + 1, name.starts_with("accent"), name.contains("order"))
-        }
-        "leftRightArrowCallout" | "upDownArrowCallout" => {
-            let vertical = name == "upDownArrowCallout";
-            let (l, t) = if vertical { (h, w) } else { (w, h) };
-            let ss = l.min(t);
-            let head = (ss * a(1).max(0.0) / 1e5).min(t / 2.0);
-            let shaft = (ss * a(0).max(0.0) / 1e5).min(head * 2.0);
-            let hl = (ss * a(2).max(0.0) / 1e5).min(l / 2.0);
-            let boxl = (l * a(3).max(0.0) / 1e5).min(l - 2.0 * hl);
-            let (c, b0, b1) = (t / 2.0, (l - boxl) / 2.0, (l + boxl) / 2.0);
-            let pts = [
-                (0.0, c),
-                (hl, c - head),
-                (hl, c - shaft / 2.0),
-                (b0, c - shaft / 2.0),
-                (b0, 0.0),
-                (b1, 0.0),
-                (b1, c - shaft / 2.0),
-                (l - hl, c - shaft / 2.0),
-                (l - hl, c - head),
-                (l, c),
-                (l - hl, c + head),
-                (l - hl, c + shaft / 2.0),
-                (b1, c + shaft / 2.0),
-                (b1, t),
-                (b0, t),
-                (b0, c + shaft / 2.0),
-                (hl, c + shaft / 2.0),
-                (hl, c + head),
-            ];
-            let d = if vertical { Dir::Down } else { Dir::Right };
-            let pts = orient(d, w, h, &pts);
-            let tr = orient(d, w, h, &[(b0, 0.0), (b1, t)]);
-            simple(b.poly(&pts).take(), Rect::from_points(Point::new(tr[0].0, tr[0].1), Point::new(tr[1].0, tr[1].1)).abs(), w, h)
-        }
-        "quadArrowCallout" => {
-            let head = (ss * a(1).max(0.0) / 1e5).min(ss / 2.0);
-            let shaft = (ss * a(0).max(0.0) / 1e5).min(head * 2.0);
-            let hl = (ss * a(2).max(0.0) / 1e5).min(ss / 2.0);
-            let k = a(3).clamp(0.0, 100000.0) / 1e5;
-            let (bw, bh) = ((w * k).min(w - 2.0 * hl).max(shaft), (h * k).min(h - 2.0 * hl).max(shaft));
-            let (cx, cy) = (w / 2.0, h / 2.0);
-            let (bx0, bx1, by0, by1) = (cx - bw / 2.0, cx + bw / 2.0, cy - bh / 2.0, cy + bh / 2.0);
-            let (s2, hd) = (shaft / 2.0, head);
-            let pts = [
-                (0.0, cy),
-                (hl, cy - hd),
-                (hl, cy - s2),
-                (bx0, cy - s2),
-                (bx0, by0),
-                (cx - s2, by0),
-                (cx - s2, hl),
-                (cx - hd, hl),
-                (cx, 0.0),
-                (cx + hd, hl),
-                (cx + s2, hl),
-                (cx + s2, by0),
-                (bx1, by0),
-                (bx1, cy - s2),
-                (w - hl, cy - s2),
-                (w - hl, cy - hd),
-                (w, cy),
-                (w - hl, cy + hd),
-                (w - hl, cy + s2),
-                (bx1, cy + s2),
-                (bx1, by1),
-                (cx + s2, by1),
-                (cx + s2, h - hl),
-                (cx + hd, h - hl),
-                (cx, h),
-                (cx - hd, h - hl),
-                (cx - s2, h - hl),
-                (cx - s2, by1),
-                (bx0, by1),
-                (bx0, cy + s2),
-                (hl, cy + s2),
-                (hl, cy + hd),
-            ];
-            simple(b.poly(&pts).take(), Rect::new(bx0, by0, bx1, by1), w, h)
-        }
-        "curvedRightArrow" | "curvedLeftArrow" | "curvedUpArrow" | "curvedDownArrow" => curved_arrow(name, w, h, a(0), a(1), a(2)),
-        "swooshArrow" => swoosh(w, h, a(0), a(1)),
-        "ellipseRibbon" | "ellipseRibbon2" => ellipse_ribbon(name == "ellipseRibbon2", w, h, a(0), a(1), a(2)),
-        "leftRightRibbon" => left_right_ribbon(w, h, a(0), a(1), a(2)),
-        "gear6" | "gear9" => gear(if name == "gear6" { 6 } else { 9 }, w, h, a(0), a(1)),
-        "funnel" => funnel(w, h),
-        "circularArrow" | "leftCircularArrow" | "leftRightCircularArrow" => circular_arrow(name, w, h, [a(0), a(1), a(2), a(3), a(4)]),
-        _ => return None,
-    };
-    Some(g)
-}
-
-/// An ellipse-centred frame for the circular arrows: the band's middle runs on the ellipse
-/// `(rx, ry)`, its edges `th/2` either side.
-struct Ring {
-    c: Point,
-    rx: f64,
-    ry: f64,
-    th: f64,
-    hw: f64,
-}
-
-impl Ring {
-    /// The point at visual angle `deg` on the ellipse grown by `d`.
-    fn at(&self, deg: f64, d: f64) -> Point {
-        let (ax, ay) = ((self.rx + d).max(0.0), (self.ry + d).max(0.0));
-        let t = vis(deg, ax, ay).to_radians();
-        Point::new(self.c.x + ax * t.cos(), self.c.y + ay * t.sin())
-    }
-    /// Parametric angle (degrees) of `p` on the ellipse grown by `d`.
-    fn param(&self, p: Point, d: f64) -> f64 {
-        let (ax, ay) = ((self.rx + d).max(1e-9), (self.ry + d).max(1e-9));
-        ((p.y - self.c.y) / ay).atan2((p.x - self.c.x) / ax).to_degrees()
-    }
-    /// Where the line `b + s·u` meets the ellipse grown by `d`, taking the crossing nearest `b`
-    /// on the side `sign` (+1 outwards, −1 inwards).
-    fn cross(&self, b: Point, u: Vec2, d: f64, sign: f64) -> Point {
-        let (ax, ay) = ((self.rx + d).max(1e-9), (self.ry + d).max(1e-9));
-        let (px, py) = ((b.x - self.c.x) / ax, (b.y - self.c.y) / ay);
-        let (ux, uy) = (u.x / ax, u.y / ay);
-        let qa = ux * ux + uy * uy;
-        let qb = 2.0 * (px * ux + py * uy);
-        let qc = px * px + py * py - 1.0;
-        let disc = qb * qb - 4.0 * qa * qc;
-        if qa < 1e-18 || disc < 0.0 {
-            // The line misses (a long head on a thin ring): the edge then carries on from the
-            // base centre itself, as the reference does.
-            return b;
-        }
-        let r = disc.sqrt();
-        let (s0, s1) = ((-qb - r) / (2.0 * qa), (-qb + r) / (2.0 * qa));
-        let s = if sign > 0.0 {
-            if s0 >= 0.0 { s0 } else { s1 }
-        } else if s1 <= 0.0 {
-            s1
-        } else {
-            s0
-        };
-        b + u * s
-    }
-    /// An arrow head whose base centre sits on the middle ellipse at `base` degrees and whose tip
-    /// sits there at `base + sweep`. The base runs along the line from the centre to the tip.
-    /// Returns (band outer edge, outer wing, tip, inner wing, band inner edge).
-    fn head(&self, base: f64, sweep: f64) -> [Point; 5] {
-        let b = self.at(base, 0.0);
-        let tip = self.at(base + sweep, 0.0);
-        let d = tip - self.c;
-        let u = if d.hypot() > 1e-12 { d / d.hypot() } else { Vec2::new(1.0, 0.0) };
-        let half = self.th / 2.0;
-        [self.cross(b, u, half, 1.0), b + u * self.hw, tip, b - u * self.hw, self.cross(b, u, -half, -1.0)]
-    }
-}
-
-/// Sweep (degrees) from `a` to `b` turning one way: positive when `dir > 0`.
-fn turn(a: f64, b: f64, dir: f64) -> f64 {
-    if dir > 0.0 { (b - a).rem_euclid(360.0) } else { -(a - b).rem_euclid(360.0) }
-}
-
-/// The circular arrows: a band along an ellipse with one head (`circularArrow` clockwise,
-/// `leftCircularArrow` anticlockwise) or a head at each end (`leftRightCircularArrow`).
-/// Adjusts: band thickness, head sweep (degrees), end angle, start angle, head half-width.
-fn circular_arrow(name: &str, w: f64, h: f64, a: [f64; 5]) -> Geometry {
-    let ss = w.min(h);
-    if ss <= 0.0 {
-        return simple(corner_rect(w, h, [Corner::Square; 4]), Rect::new(0.0, 0.0, w, h), w, h);
-    }
-    let a5 = a[4].clamp(0.0, 25000.0);
-    let hw = ss * a5 / 1e5;
-    let th = ss * a[0].clamp(0.0, 2.0 * a5) / 1e5;
-    let ring = Ring { c: Point::new(w / 2.0, h / 2.0), rx: (w / 2.0 - hw).max(th / 2.0), ry: (h / 2.0 - hw).max(th / 2.0), th, hw };
-    let deg = |v: f64| (v / 60000.0) % 360.0;
-    let (sweep, end, start) = (deg(a[1]), deg(a[2]), deg(a[3]));
-    let half = th / 2.0;
-    let mut b = Pb::new();
-    // Arcs of the ellipse grown by `d`, drawn on from the current point (which is on it except in
-    // the degenerate case above, where the arc shifts with it like the reference's).
-    let edge_arc = |b: &mut Pb, from: Point, to: Point, d: f64, dir: f64| {
-        let (ax, ay) = ((ring.rx + d).max(0.0), (ring.ry + d).max(0.0));
-        let (s, e) = (ring.param(from, d), ring.param(to, d));
-        b.arc(ax, ay, s, turn(s, e, dir));
-    };
-    let outer_arc = |b: &mut Pb, from: Point, to: Point, dir: f64| edge_arc(b, from, to, half, dir);
-    let inner_arc = |b: &mut Pb, from: Point, to: Point, dir: f64| edge_arc(b, from, to, -half, dir);
-    if name == "leftRightCircularArrow" {
-        let hs = ring.head(start, -sweep);
-        let he = ring.head(end, sweep);
-        b.m(hs[0].x, hs[0].y);
-        outer_arc(&mut b, hs[0], he[0], 1.0);
-        b.l(he[1].x, he[1].y).l(he[2].x, he[2].y).l(he[3].x, he[3].y).l(he[4].x, he[4].y);
-        inner_arc(&mut b, he[4], hs[4], -1.0);
-        b.l(hs[3].x, hs[3].y).l(hs[2].x, hs[2].y).l(hs[1].x, hs[1].y).z();
-    } else {
-        let dir = if name == "circularArrow" { 1.0 } else { -1.0 };
-        let he = ring.head(end, sweep);
-        let (o0, i0) = (ring.at(start, half), ring.at(start, -half));
-        b.m(o0.x, o0.y);
-        outer_arc(&mut b, o0, he[0], dir);
-        b.l(he[1].x, he[1].y).l(he[2].x, he[2].y).l(he[3].x, he[3].y).l(he[4].x, he[4].y);
-        inner_arc(&mut b, he[4], i0, -dir);
-        b.z();
-    }
-    simple(b.take(), Rect::new(0.0, 0.0, w, h), w, h)
-}
-
-/// A funnel: an elliptical rim (with an open mouth) across the top quarter, and straight sides
-/// down to a small rounded spout. The side lines leave the rim and meet the spout at fixed
-/// angles, fitted to the reference look.
-fn funnel(w: f64, h: f64) -> Geometry {
-    const RIM: f64 = 173.0; // where the left side leaves the rim, degrees on the rim ellipse
-    const SPOUT: f64 = 163.4; // where it meets the spout, degrees on the spout ellipse
-    let ss = w.min(h);
-    let (cx, rim_y) = (w / 2.0, h / 4.0);
-    let (sx, sy) = (w / 8.0, h / 15.0);
-    let spout_y = h - sy;
-    let at = |rx: f64, ry: f64, cy: f64, deg: f64| {
-        let t = deg.to_radians();
-        Point::new(cx + rx * t.cos(), cy + ry * t.sin())
-    };
-    let p0 = at(cx, rim_y, rim_y, RIM);
-    let p1 = at(sx, sy, spout_y, 180.0 - SPOUT);
-    let mut b = Pb::new();
-    b.m(p0.x, p0.y).arc(cx, rim_y, RIM, 540.0 - 2.0 * RIM);
-    b.l(p1.x, p1.y).arc(sx, sy, 180.0 - SPOUT, 2.0 * SPOUT - 180.0).z();
-    let d = ss / 20.0;
-    b.ellipse(cx, rim_y, (cx - d).max(0.0), (rim_y - d).max(0.0));
-    Geometry { paths: vec![fill_eo(b.take())], text_rect: Rect::new(w / 4.0, h / 2.0, w * 0.75, h - sy), handles: vec![], sites: mid_sites(w, h) }
-}
-
-/// A gear: an elliptical body with `n` teeth, the first pointing straight up. Each tooth leaves
-/// the body at two points an equal angle either side of its centre, and its tip corners sit a
-/// tooth height further out along the body's normal and a flank lean further in.
-fn gear(n: usize, w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
-    let ss = w.min(h);
-    let th = ss * a0.clamp(0.0, 20000.0) / 1e5; // tooth height
-    let lean_max = if n == 6 { 5380.0 } else { 2730.0 };
-    let l = ss * a1.clamp(0.0, a0.clamp(0.0, 20000.0).min(lean_max)) / 1e5; // flank lean
-    let (cx, cy) = (w / 2.0, h / 2.0);
-    let (rx, ry) = ((cx - th).max(0.0), (cy - th).max(0.0));
-    let r = (ss / 2.0 - th).max(1e-9);
-    let half = ((th + l) / 2.0 / r).atan();
-    let step = std::f64::consts::TAU / n as f64;
-    let on_body = |t: f64| Point::new(cx + rx * t.cos(), cy + ry * t.sin());
-    let mut b = Pb::new();
-    for k in 0..n {
-        let t = -std::f64::consts::FRAC_PI_2 + step * k as f64;
-        // The tooth stands along the body's normal at its centre.
-        let nrm = Vec2::new(t.cos() * ry, t.sin() * rx);
-        let u = if nrm.hypot() > 1e-12 { nrm / nrm.hypot() } else { Vec2::new(t.cos(), t.sin()) };
-        let v = Vec2::new(-u.y, u.x);
-        let (r0, r1) = (on_body(t - half), on_body(t + half));
-        let (c0, c1) = (r0 + u * th + v * l, r1 + u * th - v * l);
-        if k == 0 {
-            b.m(r0.x, r0.y);
-        } else {
-            b.arc(rx, ry, (t - step + half).to_degrees(), (step - 2.0 * half).to_degrees());
-        }
-        b.l(c0.x, c0.y).l(c1.x, c1.y).l(r1.x, r1.y);
-    }
-    let t_last = -std::f64::consts::FRAC_PI_2 + step * (n - 1) as f64;
-    b.arc(rx, ry, (t_last + half).to_degrees(), (step - 2.0 * half).to_degrees()).z();
-    let k = std::f64::consts::FRAC_1_SQRT_2;
-    let text = Rect::new(cx - rx * k, cy - ry * k, cx + rx * k, cy + ry * k);
-    simple(b.take(), text, w, h)
-}
-
-/// Two arrows on a band that steps down in the middle: the left arrow sits high, the right one low,
-/// and the band rolls over between them in a shaded half-ellipse curl.
-fn left_right_ribbon(w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
-    let ss = w.min(h);
-    let sh = h * a2.clamp(0.0, 33333.0) / 1e5; // step between the two halves
-    let bt = (h * a0.max(0.0) / 1e5).min(h - sh); // band thickness
-    let cx = w / 2.0;
-    let (rx, ry) = (w / 32.0, (sh / 4.0).min(w / 24.0));
-    let hb = (ss * a1.max(0.0) / 1e5).min(cx - rx); // head length
-    let yc = (h - sh) / 2.0;
-    let (lt, lb) = (yc - bt / 2.0, yc + bt / 2.0);
-    let (rt, rb) = (lt + sh, lb + sh);
-    // The left half: filled as a closed outline, stroked only where it can show.
-    let mut edge = Pb::new();
-    edge.m(cx - rx, lb).l(hb, lb).l(hb, h - sh).l(0.0, yc).l(hb, 0.0).l(hb, lt).l(cx, lt);
-    edge.arc(rx, ry, 270.0, 180.0).arc(rx, ry, 270.0, -90.0);
-    let edge = edge.take();
-    let mut left = Pb::new();
-    left.m(0.0, yc).l(hb, 0.0).l(hb, lt).l(cx, lt).arc(rx, ry, 270.0, 180.0).arc(rx, ry, 270.0, -180.0);
-    left.l(cx, lb.max(lt + 4.0 * ry)).l(hb, lb).l(hb, h - sh).z();
-    let left = left.take();
-    let mut curl = Pb::new();
-    curl.m(cx + rx, lt + ry).l(cx + rx, rt).l(cx, lt + 4.0 * ry).arc(rx, ry, 90.0, 180.0).arc(rx, ry, 90.0, -90.0).z();
-    let mut right = Pb::new();
-    right.m(w, yc + sh).l(w - hb, h).l(w - hb, rb).l(cx, rb).arc(rx, ry, 90.0, 90.0).l(cx - rx, rt - ry).arc(rx, ry, 180.0, -90.0);
-    right.l(w - hb, rt).l(w - hb, sh).z();
-    Geometry {
-        paths: vec![fill_only(left), stroke_only(edge), shade(curl.take(), FillMode::DarkenLess), fill(right.take())],
-        text_rect: Rect::new(hb.min(cx - rx), rt, (w - hb).max(cx + rx), lb.max(rt)),
-        handles: vec![],
-        sites: vec![Point::new(0.0, yc), Point::new(cx, rt), Point::new(w, yc + sh), Point::new(cx, lb)],
-    }
-}
-
-/// Adds a piece of the parabola `y = y0 + d·(1 − ((x − w/2)/(w/2))²)` from the current point (at
-/// `xa`) to `xb`, as one quadratic curve.
-fn sag(b: &mut Pb, w: f64, d: f64, y0: f64, xa: f64, xb: f64) {
-    let hw = (w / 2.0).max(1e-9);
-    let f = |x: f64| y0 + d * (1.0 - ((x - hw) / hw).powi(2));
-    let slope = -2.0 * d * (xa - hw) / (hw * hw);
-    b.q((xa + xb) / 2.0, f(xa) + slope * (xb - xa) / 2.0, xb, f(xb));
-}
-
-/// A ribbon whose edges sag along one parabola: a front band in the middle and two notched ends
-/// behind it, joined by shaded folds. Built sagging downwards; `up` mirrors it vertically.
-fn ellipse_ribbon(up: bool, w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
-    let th = h * a0.clamp(0.0, 100000.0) / 1e5; // band drop at the centre
-    // Sag of every edge: never more than the drop, never so little that the band would rise
-    // above the ends by more than half their height.
-    let d = (h * a2.max(0.0) / 1e5).max(th - (h - th) / 2.0).clamp(0.0, th);
-    let bw = w * a1.clamp(25000.0, 75000.0) / 1e5;
-    let (x0, x1) = ((w - bw) / 2.0, (w + bw) / 2.0);
-    let ear = w / 8.0;
-    let (xf, xg) = (x0 + ear, x1 - ear);
-    let e = h - th; // band height
-    let off = th - d; // band top below the ends' top
-    let t = |x: f64| {
-        let hw = (w / 2.0).max(1e-9);
-        d * (1.0 - ((x - hw) / hw).powi(2))
-    };
-    let mut ends = Pb::new();
-    ends.m(0.0, 0.0);
-    sag(&mut ends, w, d, 0.0, 0.0, xf);
-    ends.l(xf, t(xf) + off).l(x0, t(x0) + off).l(x0, t(x0) + e);
-    sag(&mut ends, w, d, e, x0, 0.0);
-    ends.l(ear, t(ear) + e / 2.0).z();
-    ends.m(w, 0.0).l(w - ear, t(w - ear) + e / 2.0).l(w, e);
-    sag(&mut ends, w, d, e, w, x1);
-    ends.l(x1, t(x1) + off).l(xg, t(xg) + off).l(xg, t(xg));
-    sag(&mut ends, w, d, 0.0, xg, w);
-    ends.z();
-    let mut folds = Pb::new();
-    folds.poly(&[(x0, t(x0) + off), (xf, t(xf)), (xf, t(xf) + off)]);
-    folds.poly(&[(x1, t(x1) + off), (xg, t(xg)), (xg, t(xg) + off)]);
-    let mut band = Pb::new();
-    band.m(x0, t(x0) + off);
-    sag(&mut band, w, d, off, x0, x1);
-    band.l(x1, t(x1) + off + e);
-    sag(&mut band, w, d, off + e, x1, x0);
-    band.z();
-    let mut paths = vec![fill(ends.take()), shade(folds.take(), FillMode::DarkenLess), fill(band.take())];
-    let mut text = Rect::new(x0, th, x1, t(x0) + off + e);
-    if up {
-        let m = kurbo::Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, h]);
-        for p in &mut paths {
-            p.path.apply_affine(m);
-        }
-        text = m.transform_rect_bbox(text);
-    }
-    Geometry { paths, text_rect: text, handles: vec![], sites: mid_sites(w, h) }
-}
-
-/// A sweeping arrow rising from the bottom-left corner. The band's two edges are quadratic curves
-/// from the corner; the head's base leans slightly forward and reaches one eighth of the shorter
-/// side above and below the band. The tilt and the tip's lift were fitted to the reference look.
-fn swoosh(w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
-    const TILT: f64 = 0.1126; // tan of the head base's lean from vertical
-    const LIFT: f64 = 0.051; // tip height above the band's centre, per unit of height
-    let ss = w.min(h);
-    let e = ss / 8.0;
-    let th = (h * a0.max(0.0) / 1e5).min((h - 2.0 * e).max(0.0));
-    // The head is at least long enough to keep its leaning base inside the frame.
-    let hl = (ss * a1.max(0.0) / 1e5).max((e + th) * TILT).min((w - e * TILT).max(0.0));
-    let qx = w - hl;
-    let mut b = Pb::new();
-    b.m(0.0, h)
-        .q(w / 6.0, h / 3.0, qx, e)
-        .l(qx - e * TILT, 0.0)
-        .l(w, (e + th / 2.0 - LIFT * h).clamp(0.0, 2.0 * e + th))
-        .l((qx + (e + th) * TILT).min(w), 2.0 * e + th)
-        .l((qx + th * TILT).min(w), e + th)
-        .q(w / 4.0, (th + h / 12.0 + e).min(h), 0.0, h)
-        .z();
-    simple(b.take(), Rect::new(0.0, 0.0, w, h), w, h)
-}
-
-/// A band that sweeps around half an ellipse and ends in an arrow head. Built pointing right
-/// (`curvedRightArrow`) in a `cw`×`ch` frame, then turned for the other directions.
-///
-/// Both halves of the band hang off one ellipse touching the far side: its centre sits on the
-/// head side's edge, its horizontal radius is the full length, and the band has a constant
-/// vertical thickness. The back half (shaded) starts flat against the head side; the front half
-/// runs to the head, centred on the band where it ends.
-fn curved_arrow(name: &str, w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
-    let along_x = matches!(name, "curvedRightArrow" | "curvedLeftArrow");
-    let (cw, ch) = if along_x { (w, h) } else { (h, w) };
-    let ss = cw.min(ch);
-    let head = (ss * a1.max(0.0) / 1e5).min(ch / 2.0);
-    let th = (ss * a0.max(0.0) / 1e5).min(head);
-    let hl = (ss * a2.max(0.0) / 1e5).min(cw);
-    let hh = head / 2.0;
-    // The band's centre line, carried on to the head side, ends at the tip, which sits half a
-    // head width above the bottom.
-    let r = ((ch - hh - th / 2.0) / 2.0).max(0.0);
-    // Parametric angle where the front band reaches the head base.
-    let te = if cw > 0.0 { (-(hl / cw)).clamp(-1.0, 1.0).acos().to_degrees() } else { 90.0 };
-    let mut back = Pb::new();
-    back.m(cw, 0.0).arc(cw, r, 270.0, -90.0).l(0.0, r + th).arc(cw, r, 180.0, 90.0).z();
-    let mut front = Pb::new();
-    front.m(0.0, r).arc(cw, r, 180.0, te - 180.0);
-    let yb = front.cur.y;
-    let yc = yb + th / 2.0;
-    front.l(cw - hl, yc - hh).l(cw, 2.0 * r + th / 2.0).l(cw - hl, yc + hh).l(cw - hl, yb + th).arc(cw, r, te, 180.0 - te).z();
-    let m = match name {
-        "curvedLeftArrow" => kurbo::Affine::new([-1.0, 0.0, 0.0, 1.0, w, 0.0]),
-        "curvedUpArrow" => kurbo::Affine::new([0.0, -1.0, 1.0, 0.0, 0.0, h]),
-        "curvedDownArrow" => kurbo::Affine::new([0.0, 1.0, 1.0, 0.0, 0.0, 0.0]),
-        _ => kurbo::Affine::IDENTITY,
-    };
-    let (mut back, mut front) = (back.take(), front.take());
-    back.apply_affine(m);
-    front.apply_affine(m);
-    Geometry {
-        paths: vec![shade(back, FillMode::DarkenLess), fill(front)],
-        text_rect: Rect::new(0.0, 0.0, w, h),
-        handles: vec![],
-        sites: mid_sites(w, h),
-    }
-}
-
-/// A rectangle with a callout leader through `pts` points (`(y, x)` adjust pairs in 1/100 000 of
-/// the height and width), optionally with an accent bar at the first point's x and a border.
-fn line_callout(w: f64, h: f64, a: &dyn Fn(usize) -> f64, pts: usize, accent: bool, border: bool) -> Geometry {
-    let body = corner_rect(w, h, [Corner::Square; 4]);
-    // Leaders may reach well outside the box, but not without bound.
-    let pt = |i: usize| (w * a(2 * i + 1).clamp(-1e7, 1e7) / 1e5, h * a(2 * i).clamp(-1e7, 1e7) / 1e5);
-    let mut l = Pb::new();
-    let (x0, y0) = pt(0);
-    l.m(x0, y0);
-    for i in 1..pts {
-        let (x, y) = pt(i);
-        l.l(x, y);
-    }
-    let mut paths = vec![if border { fill(body) } else { fill_only(body) }];
-    if accent {
-        paths.push(stroke_only(Pb::new().m(x0, 0.0).l(x0, h).take()));
-    }
-    paths.push(stroke_only(l.take()));
-    Geometry { paths, text_rect: Rect::new(0.0, 0.0, w, h), handles: vec![], sites: mid_sites(w, h) }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::{CATALOG, FillMode, build, info};
-    use kurbo::{BezPath, PathEl, Point, Shape};
-
-    const NEW: [&str; 38] = [
-        "lineInv",
-        "nonIsoscelesTrapezoid",
-        "pieWedge",
-        "leftRightArrowCallout",
-        "upDownArrowCallout",
-        "quadArrowCallout",
-        "circularArrow",
-        "leftCircularArrow",
-        "leftRightCircularArrow",
-        "curvedRightArrow",
-        "curvedLeftArrow",
-        "curvedUpArrow",
-        "curvedDownArrow",
-        "swooshArrow",
-        "callout1",
-        "callout2",
-        "callout3",
-        "accentCallout1",
-        "accentCallout2",
-        "accentCallout3",
-        "borderCallout2",
-        "borderCallout3",
-        "accentBorderCallout1",
-        "accentBorderCallout2",
-        "accentBorderCallout3",
-        "ellipseRibbon",
-        "ellipseRibbon2",
-        "leftRightRibbon",
-        "flowChartOfflineStorage",
-        "gear6",
-        "gear9",
-        "funnel",
-        "cornerTabs",
-        "squareTabs",
-        "plaqueTabs",
-        "chartX",
-        "chartStar",
-        "chartPlus",
-    ];
-
-    fn outline(name: &str, w: f64, h: f64, adj: &[f64]) -> BezPath {
-        build(name, w, h, adj).map(|g| g.outline()).unwrap_or_default()
-    }
-
-    /// Distance from `p` to the nearest point of the (flattened) outline.
-    fn dist(path: &BezPath, p: Point) -> f64 {
-        let mut best = f64::MAX;
-        let mut prev = Point::ZERO;
-        let mut start = Point::ZERO;
-        kurbo::flatten(path.iter(), 0.01, |el| {
-            let (a, b) = match el {
-                PathEl::MoveTo(q) => {
-                    prev = q;
-                    start = q;
-                    return;
-                }
-                PathEl::LineTo(q) => (prev, q),
-                PathEl::ClosePath => (prev, start),
-                _ => return,
-            };
-            let d = b - a;
-            let t = if d.hypot2() > 0.0 { ((p - a).dot(d) / d.hypot2()).clamp(0.0, 1.0) } else { 0.0 };
-            best = best.min((a + d * t - p).hypot());
-            prev = b;
-        });
-        best
-    }
-
-    /// Asserts every point lies within 1pt of the outline.
-    fn on(name: &str, w: f64, h: f64, adj: &[f64], pts: &[(f64, f64)]) {
-        let path = outline(name, w, h, adj);
-        for &(x, y) in pts {
-            let d = dist(&path, Point::new(x, y));
-            assert!(d < 1.0, "{name} {w}x{h} {adj:?}: ({x}, {y}) is {d:.2} from the outline");
-        }
-    }
-
-    #[test]
-    fn new_presets_are_in_the_catalog() {
-        for n in NEW {
-            let i = info(n).unwrap_or_else(|| panic!("{n} missing from the catalog"));
-            assert!(!i.label.is_empty());
-        }
-        assert!(CATALOG.len() >= 183);
-    }
-
-    #[test]
-    fn new_presets_build_within_bounds_at_many_sizes_and_adjusts() {
-        let sizes = [(480.0, 300.0), (300.0, 300.0), (200.0, 460.0), (100.0, 460.0), (1.0, 1.0), (0.0, 0.0), (0.0, 50.0), (60.0, 0.0)];
-        let adjusts: [&[f64]; 8] = [
-            &[],
-            &[0.0; 8],
-            &[100000.0; 8],
-            &[-50000.0; 8],
-            &[1e12, -1e12, 1e12, -1e12, 1e12, -1e12, 1e12, -1e12],
-            &[f64::MAX, f64::MIN, f64::MAX, f64::MIN, f64::MAX, f64::MIN, f64::MAX, f64::MIN],
-            &[f64::NAN, f64::INFINITY, f64::NEG_INFINITY, f64::NAN, 5.0, 6.0, 7.0, 8.0],
-            &[30000.0, 60000.0, 20000.0, 9000000.0, 20000.0, 40000.0, 120000.0, -30000.0],
-        ];
-        for n in NEW {
-            // Line callouts' leaders may reach anywhere, by design.
-            let callout = n.contains("allout") && !n.contains("Arrow");
-            for (w, h) in sizes {
-                for adj in adjusts {
-                    let g = build(n, w, h, adj).unwrap_or_else(|| panic!("{n} did not build"));
-                    assert!(!g.paths.is_empty(), "{n} has no paths");
-                    for s in &g.paths {
-                        let bb = s.path.bounding_box();
-                        assert!(bb.x0.is_finite() && bb.y0.is_finite() && bb.x1.is_finite() && bb.y1.is_finite(), "{n} {w}x{h} {adj:?}: {bb:?}");
-                        if !callout {
-                            // Circular arrows with a head longer than their ring can hold carry the
-                            // inner edge on from the head, as the reference does, so may spill.
-                            let spill = if n.contains("ircular") { 0.5 } else { 0.01 };
-                            let tol = 0.5 + w.max(h) * spill;
-                            assert!(
-                                bb.x0 >= -tol && bb.y0 >= -tol && bb.x1 <= w + tol && bb.y1 <= h + tol,
-                                "{n} {w}x{h} {adj:?} out of bounds: {bb:?}"
-                            );
-                        }
-                    }
-                    let t = g.text_rect;
-                    assert!(t.x0.is_finite() && t.y0.is_finite() && t.x1.is_finite() && t.y1.is_finite(), "{n} text rect {t:?}");
-                }
-            }
-            let g = build(n, 480.0, 300.0, &[]).unwrap_or_else(|| panic!("{n}"));
-            assert!(g.outline().elements().len() >= 2, "{n} default outline is empty");
-        }
-    }
-
-    // The spot checks below are outline points measured on reference renders.
-
-    #[test]
-    fn simple_new_presets_match_reference_points() {
-        on("lineInv", 480.0, 300.0, &[], &[(0.0, 300.0), (480.0, 0.0)]);
-        on("nonIsoscelesTrapezoid", 480.0, 300.0, &[], &[(75.0, 0.0), (405.0, 0.0), (0.0, 300.0)]);
-        on("nonIsoscelesTrapezoid", 200.0, 460.0, &[80000.0, 20000.0], &[(100.0, 0.0), (160.0, 0.0)]);
-        on("pieWedge", 480.0, 300.0, &[], &[(64.3, 150.0), (0.0, 300.0), (480.0, 0.0)]);
-        on("flowChartOfflineStorage", 480.0, 300.0, &[], &[(240.0, 300.0), (192.0, 240.0), (288.0, 240.0)]);
-        on("squareTabs", 480.0, 300.0, &[], &[(28.3, 28.3), (451.7, 271.7)]);
-        on("cornerTabs", 480.0, 300.0, &[], &[(23.3, 5.0)]);
-        on("plaqueTabs", 480.0, 300.0, &[], &[(27.85, 5.0)]);
-        on("chartStar", 480.0, 300.0, &[], &[(240.0, 0.0), (240.0, 300.0), (48.0, 30.0)]);
-        on("chartPlus", 480.0, 300.0, &[], &[(0.0, 150.0), (240.0, 0.0)]);
-        // Chart markers and plain callouts leave the box unstroked.
-        for n in ["chartX", "callout1", "accentCallout2"] {
-            let g = build(n, 100.0, 100.0, &[]).unwrap_or_else(|| panic!("{n}"));
-            assert!(!g.paths[0].stroke, "{n}");
-        }
-    }
-
-    #[test]
-    fn line_callouts_follow_their_adjusts() {
-        on("callout3", 480.0, 300.0, &[], &[(-40.0, 56.25), (-80.0, 56.25), (-80.0, 300.0), (-40.0, 338.9)]);
-        let adj = [50000.0, 110000.0, 20000.0, 120000.0, -20000.0, 80000.0, 30000.0, 40000.0];
-        let g = build("accentBorderCallout3", 480.0, 300.0, &adj).unwrap_or_else(|| panic!("accentBorderCallout3"));
-        assert_eq!(g.paths.len(), 3);
-        assert!(g.paths[0].stroke);
-        let accent = g.paths[1].path.bounding_box();
-        assert!((accent.x0 - 528.0).abs() < 1e-6 && accent.y0 == 0.0 && accent.y1 == 300.0, "{accent:?}");
-        on("accentBorderCallout3", 480.0, 300.0, &adj, &[(576.0, 60.0), (384.0, -60.0), (192.0, 90.0)]);
-    }
-
-    #[test]
-    fn arrow_callouts_match_reference_points() {
-        on("leftRightArrowCallout", 480.0, 300.0, &[], &[(0.0, 150.0), (75.0, 75.0), (124.5, 0.0), (355.5, 300.0), (480.0, 150.0)]);
-        on("leftRightArrowCallout", 200.0, 460.0, &[], &[(50.0, 180.0), (52.0, 0.0), (148.0, 460.0)]);
-        on("upDownArrowCallout", 480.0, 300.0, &[], &[(240.0, 0.0), (0.0, 77.8), (480.0, 222.2), (240.0, 300.0)]);
-        on("quadArrowCallout", 480.0, 300.0, &[], &[(0.0, 150.0), (124.5, 77.8), (240.0, 0.0), (480.0, 150.0), (240.0, 300.0)]);
-    }
-
-    #[test]
-    fn curved_arrows_match_reference_points() {
-        on(
-            "curvedRightArrow",
-            480.0,
-            300.0,
-            &[],
-            &[(480.0, 0.0), (480.0, 75.0), (480.0, 225.0), (405.0, 149.0), (405.0, 299.0), (100.0, 151.5), (300.0, 6.7)],
-        );
-        on("curvedRightArrow", 200.0, 460.0, &[30000.0, 60000.0, 40000.0], &[(200.0, 400.0), (120.0, 324.5), (120.0, 443.5), (200.0, 60.0)]);
-        // The band never outgrows the head; the head never outgrows half the frame.
-        on("curvedRightArrow", 200.0, 460.0, &[60000.0, 30000.0, 80000.0], &[(200.0, 60.0)]);
-        on("curvedLeftArrow", 480.0, 300.0, &[], &[(0.0, 225.0), (0.0, 0.0)]);
-        on("curvedUpArrow", 480.0, 300.0, &[], &[(405.0, 0.0), (0.0, 0.0), (75.0, 0.0)]);
-        on("curvedDownArrow", 480.0, 300.0, &[], &[(405.0, 300.0), (0.0, 300.0)]);
-        let g = build("curvedRightArrow", 480.0, 300.0, &[]).unwrap_or_else(|| panic!("curvedRightArrow"));
-        assert_eq!(g.paths[0].fill, FillMode::DarkenLess);
-    }
-
-    #[test]
-    fn swoosh_matches_reference_points() {
-        on("swooshArrow", 480.0, 300.0, &[], &[(0.0, 300.0), (425.8, 0.0), (480.0, 59.7), (442.8, 150.0), (202.0, 105.5), (202.0, 159.0)]);
-        on("swooshArrow", 480.0, 300.0, &[40000.0, 16667.0], &[(480.0, 82.2), (447.8, 195.0)]);
-        on("swooshArrow", 200.0, 460.0, &[], &[(163.9, 0.0), (200.0, 59.4)]);
-    }
-
-    #[test]
-    fn ribbons_match_reference_points() {
-        on(
-            "ellipseRibbon",
-            480.0,
-            300.0,
-            &[],
-            &[(0.0, 0.0), (120.0, 28.1), (60.0, 128.9), (240.0, 300.0), (120.0, 66.1), (180.0, 72.2), (180.0, 35.2)],
-        );
-        on("ellipseRibbon", 480.0, 300.0, &[30000.0, 60000.0, 20000.0], &[(120.0, 45.0), (240.0, 300.0), (96.0, 68.4)]);
-        on("ellipseRibbon", 480.0, 300.0, &[80000.0, 20000.0, 60000.0], &[(240.0, 240.0), (1.0, 61.75)]);
-        on("ellipseRibbon2", 480.0, 300.0, &[], &[(0.0, 300.0), (240.0, 0.0)]);
-        on(
-            "leftRightRibbon",
-            480.0,
-            300.0,
-            &[],
-            &[(0.0, 125.0), (150.0, 0.0), (150.0, 50.0), (255.0, 62.5), (225.0, 87.5), (480.0, 175.0), (330.0, 300.0)],
-        );
-        on("leftRightRibbon", 480.0, 300.0, &[90000.0, 10000.0, 60000.0], &[(0.0, 100.0), (480.0, 200.0), (240.0, 300.0)]);
-    }
-
-    #[test]
-    fn gears_and_funnel_match_reference_points() {
-        // Square gear6: body radius 105, top tooth tip 3.5 inside the frame, tip half-width ~16.3.
-        on("gear6", 300.0, 300.0, &[], &[(150.0, 3.5), (133.7, 3.5), (166.3, 3.5), (45.0, 150.0)]);
-        on("gear9", 300.0, 300.0, &[], &[(150.0, 1.0), (30.0, 150.0)]);
-        on("gear6", 480.0, 300.0, &[], &[(240.0, 3.5), (201.0, 3.5)]);
-        on("funnel", 480.0, 300.0, &[], &[(240.0, 0.0), (0.0, 75.0), (240.0, 15.0), (15.0, 75.0), (240.0, 300.0), (60.5, 150.0)]);
-        let g = build("funnel", 480.0, 300.0, &[]).unwrap_or_else(|| panic!("funnel"));
-        assert!(g.paths[0].even_odd);
-    }
-
-    #[test]
-    fn circular_arrows_match_reference_points() {
-        on("circularArrow", 300.0, 300.0, &[], &[(19.0, 150.0), (56.5, 150.0), (150.0, 19.0), (262.4, 150.0), (218.6, 113.4), (293.6, 113.4)]);
-        on(
-            "circularArrow",
-            300.0,
-            300.0,
-            &[20000.0, 1800000.0, 18000000.0, 5400000.0, 20000.0],
-            &[(150.0, 270.0), (150.0, 210.0), (247.0, 42.1), (143.0, 102.1), (227.9, 105.0)],
-        );
-        on("leftCircularArrow", 300.0, 300.0, &[], &[(37.6, 150.0), (262.4, 150.0), (150.0, 281.0)]);
-        on("leftRightCircularArrow", 300.0, 300.0, &[], &[(262.4, 150.0), (37.6, 150.0), (150.0, 19.0)]);
-        // The band never grows past twice the head's half-width.
-        on("circularArrow", 300.0, 300.0, &[25000.0, 1142319.0, 20457681.0, 10800000.0, 5000.0], &[(0.0, 150.0), (30.0, 150.0)]);
-    }
-}

crates/geom/src/warp.rs

@@ -1,773 +0,0 @@
-//! WordArt text warps (DrawingML `a:bodyPr/a:prstTxWarp`).
-//!
-//! A warp preset is a list of bands laid over the shape's text rectangle (insets are ignored).
-//! Text lines are shared out over the bands in order (the first ⌈n/k⌉ lines to the first band
-//! and so on). A band either
-//! - stretches its lines between a top and a bottom guide ([`Band::Fill`]): the ink box of the
-//!   band's lines fills the band vertically (a band whose ink is shorter than the tallest band's
-//!   keeps the same scale, centred), and horizontally the text is scaled so that the
-//!   widest band is filled along the mean length of its guides (one scale for the whole text), or
-//! - sets its lines at their natural size along one guide ([`Band::Follow`], arches and circles):
-//!   glyphs keep their size, are placed by arc length (aligned as in the paragraph, the whole
-//!   guide being the line's width: insets don't count) and stand on
-//!   the guide's left normal; lines further from the guide stack outwards. Lines that are longer
-//!   than the guide are shrunk to fit.
-//!
-//! Positions along a guide are by arc length; a fill band maps the same fraction of its top and
-//! bottom guide's length and interpolates between them. The guide curves were derived from
-//! observation: synthetic decks of `I` bars were drawn with PowerPoint and every curve fitted to
-//! the measured bar ends (most fit within a point on a 420 × 200 pt box).
-use kurbo::{Arc, BezPath, PathEl, Point, Rect, Vec2};
-
-/// Flattening tolerance for guides, in points.
-const TOL: f64 = 0.02;
-
-/// A guide curve flattened to a polyline with cumulative arc lengths.
-#[derive(Clone, Debug, Default)]
-pub struct Guide {
-    pts: Vec<Point>,
-    cum: Vec<f64>,
-    closed: bool,
-}
-
-impl Guide {
-    fn from_points(raw: impl IntoIterator<Item = Point>, closed: bool) -> Guide {
-        let mut pts: Vec<Point> = Vec::new();
-        let mut cum: Vec<f64> = Vec::new();
-        for p in raw {
-            if !(p.x.is_finite() && p.y.is_finite()) {
-                continue;
-            }
-            match pts.last() {
-                Some(q) => {
-                    let d = (p - *q).hypot();
-                    if d > 1e-9 {
-                        cum.push(cum.last().copied().unwrap_or(0.0) + d);
-                        pts.push(p);
-                    }
-                }
-                None => {
-                    pts.push(p);
-                    cum.push(0.0);
-                }
-            }
-            if pts.len() > 100_000 {
-                break;
-            }
-        }
-        Guide { pts, cum, closed }
-    }
-
-    /// A guide through `path` (any curves), flattened.
-    pub fn from_path(path: &BezPath, closed: bool) -> Guide {
-        let mut pts = Vec::new();
-        kurbo::flatten(path.iter(), TOL, |el| match el {
-            PathEl::MoveTo(p) | PathEl::LineTo(p) => pts.push(p),
-            _ => {}
-        });
-        Guide::from_points(pts, closed)
-    }
-
-    /// Total arc length.
-    pub fn length(&self) -> f64 {
-        self.cum.last().copied().unwrap_or(0.0)
-    }
-
-    /// Whether the guide is a closed loop (positions past its end wrap around).
-    pub fn is_closed(&self) -> bool {
-        self.closed
-    }
-
-    /// Point and unit tangent at arc length `s`. Open guides continue along their end tangents
-    /// past either end; closed guides wrap.
-    pub fn at(&self, s: f64) -> (Point, Vec2) {
-        let len = self.length();
-        let (Some(&first), Some(&last)) = (self.pts.first(), self.pts.last()) else {
-            return (Point::ZERO, Vec2::new(1.0, 0.0));
-        };
-        if self.pts.len() < 2 || len <= 1e-9 {
-            return (first, Vec2::new(1.0, 0.0));
-        }
-        let s = if s.is_finite() { s } else { 0.0 };
-        let s = if self.closed { s.rem_euclid(len) } else { s };
-        let seg = |i: usize| -> (Point, Point, f64) {
-            let a = self.pts.get(i).copied().unwrap_or(first);
-            let b = self.pts.get(i + 1).copied().unwrap_or(last);
-            (a, b, self.cum.get(i).copied().unwrap_or(0.0))
-        };
-        let n = self.pts.len();
-        let i = if s <= 0.0 {
-            0
-        } else if s >= len {
-            n - 2
-        } else {
-            self.cum.partition_point(|c| *c <= s).saturating_sub(1).min(n - 2)
-        };
-        let (a, b, c0) = seg(i);
-        let d = b - a;
-        let l = d.hypot();
-        let t = if l > 1e-12 { d / l } else { Vec2::new(1.0, 0.0) };
-        (a + t * (s - c0), t)
-    }
-
-    /// The parallel curve `d` points away on the left of the direction of travel (above a
-    /// guide running left to right).
-    pub fn offset(&self, d: f64) -> Guide {
-        let n = self.pts.len();
-        if n < 2 || !d.is_finite() || d == 0.0 {
-            return self.clone();
-        }
-        let unit = |i: usize| -> Vec2 {
-            let (a, b) = (self.pts.get(i).copied().unwrap_or(Point::ZERO), self.pts.get(i + 1).copied().unwrap_or(Point::ZERO));
-            let v = b - a;
-            let l = v.hypot();
-            if l > 1e-12 { v / l } else { Vec2::ZERO }
-        };
-        let pts = (0..n).map(|i| {
-            let before = if i > 0 {
-                unit(i - 1)
-            } else if self.closed {
-                unit(n - 2)
-            } else {
-                Vec2::ZERO
-            };
-            let after = if i + 1 < n {
-                unit(i)
-            } else if self.closed {
-                unit(0)
-            } else {
-                Vec2::ZERO
-            };
-            let t = before + after;
-            let l = t.hypot();
-            let t = if l > 1e-12 { t / l } else { Vec2::new(1.0, 0.0) };
-            self.pts.get(i).copied().unwrap_or(Point::ZERO) + Vec2::new(t.y, -t.x) * d
-        });
-        Guide::from_points(pts.collect::<Vec<_>>(), self.closed)
-    }
-
-    /// The point at fraction `t` of the length.
-    pub fn at_frac(&self, t: f64) -> Point {
-        self.at(t * self.length()).0
-    }
-}
-
-/// Which line of a follow band sits on its guide.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum LineAnchor {
-    /// The last line; earlier lines stack outwards (arch up, circle).
-    Last,
-    /// The first line; later lines stack below it (arch down).
-    First,
-    /// The middle of the band's lines.
-    Middle,
-}
-
-#[derive(Clone, Debug)]
-pub enum Band {
-    /// Text stretched between two guides.
-    Fill { top: Guide, bottom: Guide },
-    /// Text at its natural size along a guide.
-    Follow { path: Guide, anchor: LineAnchor },
-}
-
-impl Band {
-    /// The length text is measured against: the mean of a fill band's guides.
-    pub fn length(&self) -> f64 {
-        match self {
-            Band::Fill { top, bottom } => (top.length() + bottom.length()) / 2.0,
-            Band::Follow { path, .. } => path.length(),
-        }
-    }
-}
-
-/// A resolved warp: its bands in shape-local points.
-#[derive(Clone, Debug)]
-pub struct Warp {
-    pub bands: Vec<Band>,
-}
-
-/// Presets whose text follows a guide at its natural size (no wrapping).
-pub fn is_follow(name: &str) -> bool {
-    matches!(name, "textArchUp" | "textArchDown" | "textCircle" | "textButton")
-}
-
-/// Default adjust values of a warp preset (`adj`, or `adj1`, `adj2`); empty for unknown presets.
-pub fn adjust_defaults(name: &str) -> &'static [f64] {
-    match name {
-        "textPlain" => &[50_000.0],
-        "textStop" => &[25_000.0],
-        "textTriangle" | "textTriangleInverted" => &[50_000.0],
-        "textChevron" => &[25_000.0],
-        "textChevronInverted" => &[75_000.0],
-        "textRingInside" | "textRingOutside" => &[60_000.0],
-        "textArchUp" | "textCircle" | "textButton" => &[10_800_000.0],
-        "textArchDown" => &[0.0],
-        "textArchUpPour" | "textCirclePour" | "textButtonPour" => &[10_800_000.0, 50_000.0],
-        "textArchDownPour" => &[0.0, 25_000.0],
-        "textCurveUp" | "textCurveDown" => &[45_977.0],
-        "textCanUp" => &[85_000.0],
-        "textCanDown" => &[14_286.0],
-        "textWave1" | "textWave2" => &[12_500.0, 0.0],
-        "textDoubleWave1" | "textWave4" => &[6_250.0, 0.0],
-        "textInflate" | "textDeflate" => &[18_750.0],
-        "textInflateBottom" => &[60_000.0],
-        "textDeflateBottom" | "textDeflateTop" => &[50_000.0],
-        "textInflateTop" => &[40_000.0],
-        "textDeflateInflate" => &[35_000.0],
-        "textDeflateInflateDeflate" => &[25_000.0],
-        "textFadeRight" | "textFadeLeft" | "textFadeUp" | "textFadeDown" => &[33_333.0],
-        "textSlantUp" => &[55_556.0],
-        "textSlantDown" => &[44_444.0],
-        "textCascadeUp" | "textCascadeDown" => &[44_444.0],
-        _ => &[],
-    }
-}
-
-/// Number of adjust values a warp preset takes.
-pub fn adjust_count(name: &str) -> usize {
-    adjust_defaults(name).len()
-}
-
-/// Whether `name` is a warp preset DeckCraft draws.
-pub fn is_supported(name: &str) -> bool {
-    !adjust_defaults(name).is_empty()
-}
-
-/// Segments of a guide in unit coordinates (x, y in 0..1 over the text rectangle).
-#[derive(Clone, Copy, Debug)]
-enum Seg {
-    M(f64, f64),
-    L(f64, f64),
-    Q(f64, f64, f64, f64),
-    C(f64, f64, f64, f64, f64, f64),
-    /// Elliptical arc: centre, radii, start and sweep in degrees (y down: positive = clockwise).
-    A(f64, f64, f64, f64, f64, f64),
-}
-
-enum Spec {
-    Fill(Vec<Seg>, Vec<Seg>),
-    Follow(Vec<Seg>, LineAnchor),
-}
-
-struct Adj<'a> {
-    raw: &'a [f64],
-    defaults: &'static [f64],
-}
-
-impl Adj<'_> {
-    fn raw(&self, i: usize) -> f64 {
-        self.raw.get(i).copied().filter(|v| v.is_finite()).or_else(|| self.defaults.get(i).copied()).unwrap_or(0.0)
-    }
-    /// Adjust `i` as a fraction (1/100 000), pinned to `lo..=hi` (fractions).
-    fn frac(&self, i: usize, lo: f64, hi: f64) -> f64 {
-        (self.raw(i) / 100_000.0).clamp(lo, hi)
-    }
-    /// Adjust `i` as an angle in degrees (1/60 000), in 0..360.
-    fn angle(&self, i: usize) -> f64 {
-        (self.raw(i) / 60_000.0).rem_euclid(360.0)
-    }
-}
-
-fn line(pts: &[(f64, f64)]) -> Vec<Seg> {
-    pts.iter().enumerate().map(|(i, &(x, y))| if i == 0 { Seg::M(x, y) } else { Seg::L(x, y) }).collect()
-}
-
-/// Quadratic from (0, y0) through control (0.5, c) to (1, y0).
-fn quad(y0: f64, c: f64) -> Vec<Seg> {
-    vec![Seg::M(0.0, y0), Seg::Q(0.5, c, 1.0, y0)]
-}
-
-/// A sweep in (0, 360]: zero means a full turn.
-fn turn(deg: f64) -> f64 {
-    let d = deg.rem_euclid(360.0);
-    if d < 1e-9 { 360.0 } else { d }
-}
-
-/// Arc of the ellipse inscribed in the rectangle, scaled by `s` about its centre.
-fn ellipse(s: f64, start: f64, sweep: f64) -> Vec<Seg> {
-    vec![Seg::A(0.5, 0.5, 0.5 * s, 0.5 * s, start, sweep)]
-}
-
-/// The arch-up arc for adjust angle `a`: symmetric about the top (270°), clockwise.
-fn arch_up(a: f64) -> (f64, f64) {
-    (a, turn(2.0 * (270.0 - a)))
-}
-
-/// The arch-down arc for adjust angle `a`: symmetric about the bottom (90°), counter-clockwise.
-fn arch_down(a: f64) -> (f64, f64) {
-    (180.0 - a, -turn(180.0 - 2.0 * a))
-}
-
-/// The circle arc for adjust angle `a`: from `a` clockwise, symmetric about 0°.
-fn circle(a: f64) -> (f64, f64) {
-    (a, turn(2.0 * (360.0 - a)))
-}
-
-/// One cubic wave period from x0 to x1 at height y: up first when `k` > 0 (y decreases).
-fn wave(out: &mut Vec<Seg>, x0: f64, x1: f64, y: f64, k: f64) {
-    let l = x1 - x0;
-    out.push(Seg::C(x0 + l / 3.0, y - k, x0 + 2.0 * l / 3.0, y + k, x1, y));
-}
-
-/// Wave guides: `periods` cubic waves over the width, shifted apart by `shift` (fraction).
-fn waves(a: f64, shift: f64, periods: usize, up_first: bool) -> Spec {
-    let d = 2.0 * shift;
-    let (top_x, bot_x) = if d >= 0.0 { ((0.0, 1.0 - d), (d, 1.0)) } else { ((-d, 1.0), (0.0, 1.0 + d)) };
-    let k = if up_first { a * 10.0 / 3.0 } else { -a * 10.0 / 3.0 };
-    let guide = |(x0, x1): (f64, f64), y: f64| {
-        let mut v = vec![Seg::M(x0, y)];
-        let n = periods.max(1) as f64;
-        for i in 0..periods.max(1) {
-            let f = i as f64;
-            wave(&mut v, x0 + (x1 - x0) * f / n, x0 + (x1 - x0) * (f + 1.0) / n, y, k);
-        }
-        v
-    };
-    Spec::Fill(guide(top_x, a), guide(bot_x, 1.0 - a))
-}
-
-fn spec(name: &str, a: &Adj) -> Option<Vec<Spec>> {
-    use Seg::*;
-    let fill = |t: Vec<Seg>, b: Vec<Seg>| vec![Spec::Fill(t, b)];
-    let top = || line(&[(0.0, 0.0), (1.0, 0.0)]);
-    let bottom = || line(&[(0.0, 1.0), (1.0, 1.0)]);
-    Some(match name {
-        "textPlain" => {
-            let d = 2.0 * (a.frac(0, 0.3, 0.7) - 0.5);
-            if d < 0.0 {
-                fill(line(&[(-d, 0.0), (1.0, 0.0)]), line(&[(0.0, 1.0), (1.0 + d, 1.0)]))
-            } else {
-                fill(line(&[(0.0, 0.0), (1.0 - d, 0.0)]), line(&[(d, 1.0), (1.0, 1.0)]))
-            }
-        }
-        "textStop" => {
-            let y = a.frac(0, 0.14286, 0.5);
-            let t = 1.0 / 3.0;
-            fill(line(&[(0.0, y), (t, 0.0), (1.0 - t, 0.0), (1.0, y)]), line(&[(0.0, 1.0 - y), (t, 1.0), (1.0 - t, 1.0), (1.0, 1.0 - y)]))
-        }
-        "textTriangle" => {
-            let y = a.frac(0, 0.0, 1.0);
-            fill(line(&[(0.0, y), (0.5, 0.0), (1.0, y)]), bottom())
-        }
-        "textTriangleInverted" => {
-            let y = a.frac(0, 0.0, 1.0);
-            fill(top(), line(&[(0.0, y), (0.5, 1.0), (1.0, y)]))
-        }
-        "textChevron" => {
-            let y = a.frac(0, 0.0, 0.5);
-            fill(line(&[(0.0, y), (0.5, 0.0), (1.0, y)]), line(&[(0.0, 1.0), (0.5, 1.0 - y), (1.0, 1.0)]))
-        }
-        "textChevronInverted" => {
-            let y = a.frac(0, 0.5, 1.0);
-            fill(line(&[(0.0, 0.0), (0.5, 1.0 - y), (1.0, 0.0)]), line(&[(0.0, y), (0.5, 1.0), (1.0, y)]))
-        }
-        "textFadeRight" => {
-            let y = a.frac(0, 0.0, 0.49999);
-            fill(line(&[(0.0, 0.0), (1.0, y)]), line(&[(0.0, 1.0), (1.0, 1.0 - y)]))
-        }
-        "textFadeLeft" => {
-            let y = a.frac(0, 0.0, 0.49999);
-            fill(line(&[(0.0, y), (1.0, 0.0)]), line(&[(0.0, 1.0 - y), (1.0, 1.0)]))
-        }
-        "textFadeUp" => {
-            let x = a.frac(0, 0.0, 0.49999);
-            fill(line(&[(x, 0.0), (1.0 - x, 0.0)]), bottom())
-        }
-        "textFadeDown" => {
-            let x = a.frac(0, 0.0, 0.49999);
-            fill(top(), line(&[(x, 1.0), (1.0 - x, 1.0)]))
-        }
-        "textSlantUp" => {
-            let y = a.frac(0, 0.44444, 1.0);
-            fill(line(&[(0.0, y), (1.0, 0.0)]), line(&[(0.0, 1.0), (1.0, 1.0 - y)]))
-        }
-        "textSlantDown" => {
-            let y = a.frac(0, 0.0, 0.55556);
-            fill(line(&[(0.0, 0.0), (1.0, 1.0 - y)]), line(&[(0.0, y), (1.0, 1.0)]))
-        }
-        "textCascadeUp" => {
-            let y = a.frac(0, 0.0, 1.0);
-            fill(line(&[(0.0, (1.0 - y) / 4.0), (1.0, 0.0)]), line(&[(0.0, 1.0), (1.0, y)]))
-        }
-        "textCascadeDown" => {
-            let y = a.frac(0, 0.0, 1.0);
-            fill(line(&[(0.0, 0.0), (1.0, (1.0 - y) / 4.0)]), line(&[(0.0, y), (1.0, 1.0)]))
-        }
-        "textInflate" => {
-            let y = a.frac(0, 0.0, 0.2);
-            fill(quad(y, -y), quad(1.0 - y, 1.0 + y))
-        }
-        "textDeflate" => {
-            let y = a.frac(0, 0.0, 0.375);
-            fill(quad(0.0, 2.0 * y), quad(1.0, 1.0 - 2.0 * y))
-        }
-        "textInflateBottom" => {
-            let y = a.frac(0, 0.6, 1.0);
-            fill(top(), quad(y, 1.0))
-        }
-        "textDeflateBottom" => {
-            let y = a.frac(0, 0.0625, 1.0);
-            fill(top(), quad(1.0, 2.0 * y - 1.0))
-        }
-        "textInflateTop" => {
-            let y = a.frac(0, 0.0, 0.5);
-            fill(quad(y, 0.0), bottom())
-        }
-        "textDeflateTop" => {
-            let y = a.frac(0, 0.0, 0.9375);
-            fill(quad(0.0, 2.0 * y), bottom())
-        }
-        "textDeflateInflate" => {
-            // The bands are split by a curve from mid-height up to `y`, with a gap of a tenth of
-            // a band's height.
-            let y = a.frac(0, 0.05, 0.95);
-            let g = 0.05;
-            vec![Spec::Fill(top(), quad(0.5 - g, 2.0 * y - 0.5 - g)), Spec::Fill(quad(0.5 + g, 2.0 * y - 0.5 + g), bottom())]
-        }
-        "textDeflateInflateDeflate" => {
-            let y = a.frac(0, 0.01, 1.0 / 3.0);
-            let g = 1.0 / 30.0;
-            let (t1, t2) = (1.0 / 3.0, 2.0 / 3.0);
-            let (c1, c2) = (2.0 * y - t1, 2.0 * (1.0 - y) - t2);
-            vec![
-                Spec::Fill(top(), quad(t1 - g, c1 - g)),
-                Spec::Fill(quad(t1 + g, c1 + g), quad(t2 - g, c2 - g)),
-                Spec::Fill(quad(t2 + g, c2 + g), bottom()),
-            ]
-        }
-        "textCurveUp" | "textCurveDown" => {
-            let y = a.frac(0, 0.0, 0.56818);
-            let b = vec![M(0.0, 1.0 - 3.0 * y / 8.0), C(1.0 / 3.0, 1.0 + y / 8.0, 2.0 / 3.0, 1.0 + y / 8.0, 1.0, 1.0 - 3.0 * y / 8.0)];
-            let t = if name == "textCurveUp" {
-                vec![M(0.0, y), C(1.0 / 3.0, 1.25 * y, 2.0 / 3.0, 0.75 * y, 1.0, 0.0)]
-            } else {
-                vec![M(0.0, 0.0), C(1.0 / 3.0, 0.75 * y, 2.0 / 3.0, 1.25 * y, 1.0, y)]
-            };
-            fill(t, b)
-        }
-        "textCanUp" => {
-            let r = 1.0 - a.frac(0, 0.5, 1.0);
-            fill(vec![A(0.5, r, 0.5, r, 180.0, 180.0)], vec![A(0.5, 1.0, 0.5, r, 180.0, 180.0)])
-        }
-        "textCanDown" => {
-            let r = a.frac(0, 0.0, 0.5);
-            fill(vec![A(0.5, 0.0, 0.5, r, 180.0, -180.0)], vec![A(0.5, 1.0 - r, 0.5, r, 180.0, -180.0)])
-        }
-        "textRingInside" | "textRingOutside" => {
-            let h = a.frac(0, 0.5, 0.99);
-            let sweep = if name == "textRingInside" { 360.0 } else { -360.0 };
-            fill(vec![A(0.5, h / 2.0, 0.5, h / 2.0, 180.0, sweep)], vec![A(0.5, 1.0 - h / 2.0, 0.5, h / 2.0, 180.0, sweep)])
-        }
-        "textWave1" => vec![waves(a.frac(0, 0.0, 0.2), a.frac(1, -0.1, 0.1), 1, true)],
-        "textWave2" => vec![waves(a.frac(0, 0.0, 0.2), a.frac(1, -0.1, 0.1), 1, false)],
-        "textDoubleWave1" => vec![waves(a.frac(0, 0.0, 0.125), a.frac(1, -0.1, 0.1), 2, true)],
-        "textWave4" => vec![waves(a.frac(0, 0.0, 0.125), a.frac(1, -0.1, 0.1), 2, false)],
-        "textArchUp" => {
-            let (s, w) = arch_up(a.angle(0));
-            vec![Spec::Follow(ellipse(1.0, s, w), LineAnchor::Last)]
-        }
-        "textArchDown" => {
-            let (s, w) = arch_down(a.angle(0));
-            vec![Spec::Follow(ellipse(1.0, s, w), LineAnchor::First)]
-        }
-        "textCircle" => {
-            let (s, w) = circle(a.angle(0));
-            vec![Spec::Follow(ellipse(1.0, s, w), LineAnchor::Last)]
-        }
-        "textButton" => {
-            let t = a.angle(0);
-            let (s, w) = arch_up(t);
-            let half = 0.5 * t.to_radians().cos().abs();
-            vec![
-                Spec::Follow(ellipse(1.0, s, w), LineAnchor::Last),
-                Spec::Follow(line(&[(0.5 - half, 0.5), (0.5 + half, 0.5)]), LineAnchor::Middle),
-                Spec::Follow(ellipse(1.0, 360.0 - s, -w), LineAnchor::First),
-            ]
-        }
-        "textArchUpPour" => {
-            let (s, w) = arch_up(a.angle(0));
-            let r = a.frac(1, 0.0, 0.99);
-            fill(ellipse(1.0, s, w), ellipse(r, s, w))
-        }
-        "textArchDownPour" => {
-            let (s, w) = arch_down(a.angle(0));
-            let r = a.frac(1, 0.0, 0.99);
-            fill(ellipse(r, s, w), ellipse(1.0, s, w))
-        }
-        "textCirclePour" => {
-            let (s, w) = circle(a.angle(0));
-            let r = a.frac(1, 0.0, 0.99);
-            fill(ellipse(1.0, s, w), ellipse(r, s, w))
-        }
-        "textButtonPour" => {
-            let (s, w) = arch_up(a.angle(0));
-            let r = a.frac(1, 0.0, 0.99);
-            // The middle band runs between chords of the inner ellipse halfway to its top and
-            // bottom.
-            let (dy, half) = (0.25 * r, 0.25 * r * 3f64.sqrt());
-            vec![
-                Spec::Fill(ellipse(1.0, s, w), ellipse(r, s, w)),
-                Spec::Fill(line(&[(0.5 - half, 0.5 - dy), (0.5 + half, 0.5 - dy)]), line(&[(0.5 - half, 0.5 + dy), (0.5 + half, 0.5 + dy)])),
-                Spec::Fill(ellipse(r, 360.0 - s, -w), ellipse(1.0, 360.0 - s, -w)),
-            ]
-        }
-        _ => return None,
-    })
-}
-
-/// Build a guide from unit-space segments mapped onto `r`.
-fn guide(segs: &[Seg], r: Rect) -> Guide {
-    let mut p = BezPath::new();
-    let mut started = false;
-    let mut closed = false;
-    for s in segs {
-        match *s {
-            Seg::M(x, y) => {
-                p.move_to((x, y));
-                started = true;
-            }
-            Seg::L(x, y) => {
-                if started {
-                    p.line_to((x, y))
-                } else {
-                    p.move_to((x, y))
-                }
-                started = true;
-            }
-            Seg::Q(cx, cy, x, y) => {
-                if started {
-                    p.quad_to((cx, cy), (x, y));
-                }
-            }
-            Seg::C(x1, y1, x2, y2, x, y) => {
-                if started {
-                    p.curve_to((x1, y1), (x2, y2), (x, y));
-                }
-            }
-            Seg::A(cx, cy, rx, ry, start, sweep) => {
-                let arc = Arc::new((cx, cy), (rx.max(0.0), ry.max(0.0)), start.to_radians(), sweep.to_radians(), 0.0);
-                let s0 = Point::new(cx + rx * start.to_radians().cos(), cy + ry * start.to_radians().sin());
-                if started {
-                    p.line_to(s0);
-                } else {
-                    p.move_to(s0);
-                }
-                started = true;
-                for el in arc.append_iter(1e-5) {
-                    p.push(el);
-                }
-                closed = sweep.abs() >= 359.999;
-            }
-        }
-    }
-    let m = kurbo::Affine::new([r.width(), 0.0, 0.0, r.height(), r.x0, r.y0]);
-    p.apply_affine(m);
-    Guide::from_path(&p, closed)
-}
-
-/// The warp `name` with adjust values `adj` (raw guide values; missing ones take the defaults)
-/// over text rectangle `rect`. `None` for unknown presets, `textNoShape` or a non-finite rect.
-pub fn warp(name: &str, adj: &[f64], rect: Rect) -> Option<Warp> {
-    if ![rect.x0, rect.y0, rect.x1, rect.y1].iter().all(|v| v.is_finite()) {
-        return None;
-    }
-    let r = Rect::new(rect.x0.min(rect.x1), rect.y0.min(rect.y1), rect.x0.max(rect.x1), rect.y0.max(rect.y1));
-    let a = Adj { raw: adj, defaults: adjust_defaults(name) };
-    let specs = spec(name, &a)?;
-    let bands = specs
-        .into_iter()
-        .map(|s| match s {
-            Spec::Fill(t, b) => Band::Fill { top: guide(&t, r), bottom: guide(&b, r) },
-            Spec::Follow(p, anchor) => Band::Follow { path: guide(&p, r), anchor },
-        })
-        .collect();
-    Some(Warp { bands })
-}
-
-/// The band line `line` of `lines` goes to when there are `bands` bands: the first ⌈n/k⌉ lines
-/// share the first band, and so on.
-pub fn band_of_line(line: usize, lines: usize, bands: usize) -> usize {
-    if bands <= 1 || lines == 0 {
-        return 0;
-    }
-    // Band b holds lines ceil(b·n/k) .. ceil((b+1)·n/k).
-    (0..bands).rev().find(|&b| (b * lines).div_ceil(bands) <= line).unwrap_or(0)
-}
-
-/// One laid-out line as the warp sees it (layout coordinates, points).
-#[derive(Clone, Copy, Debug)]
-pub struct WarpLine {
-    /// Ink box of the line's glyphs; `None` for a line without ink.
-    pub ink: Option<Rect>,
-    /// Advance extent of the line (left, right).
-    pub extent: (f64, f64),
-    /// Reference height for follow bands: the y that sits on the guide.
-    pub ref_y: f64,
-}
-
-#[derive(Clone, Copy, Debug)]
-enum LineMap {
-    Fill {
-        band: usize,
-        cx: f64,
-        k: f64,
-        len: f64,
-        y0: f64,
-        y1: f64,
-    },
-    /// `guide`: the line's own parallel guide in [`Mapper::offsets`], if it is off the band's.
-    Follow {
-        band: usize,
-        guide: Option<usize>,
-        e0: f64,
-        s0: f64,
-        k: f64,
-        ref_y: f64,
-    },
-}
-
-/// Maps points of laid-out lines onto a warp.
-#[derive(Clone, Debug)]
-pub struct Mapper<'a> {
-    warp: &'a Warp,
-    lines: Vec<LineMap>,
-    offsets: Vec<Guide>,
-    zoom: f64,
-}
-
-impl Warp {
-    /// Plan the mapping of `lines`, laid out in the inner text box `inner` (the line's place in
-    /// it gives its alignment along follow guides; the insets themselves don't shorten a guide).
-    pub fn mapper(&self, lines: &[WarpLine], inner: Rect) -> Mapper<'_> {
-        let nb = self.bands.len().max(1);
-        let n = lines.len();
-        let band_of: Vec<usize> = (0..n).map(|i| band_of_line(i, n, nb).min(nb - 1)).collect();
-        // Ink of the whole text, for the shared horizontal centre and scale of fill bands.
-        let ink_all = lines.iter().filter_map(|l| l.ink).reduce(|a, b| a.union(b));
-        let cx = ink_all.map(|r| r.center().x).unwrap_or(0.0);
-        let mut k_fill = f64::INFINITY;
-        let mut zoom: f64 = 1.0;
-        let mut band_y: Vec<Option<(f64, f64)>> = vec![None; nb];
-        for (i, l) in lines.iter().enumerate() {
-            let Some(r) = l.ink else { continue };
-            let b = band_of.get(i).copied().unwrap_or(0);
-            if let Some(slot) = band_y.get_mut(b) {
-                *slot = Some(match *slot {
-                    Some((y0, y1)) => (y0.min(r.y0), y1.max(r.y1)),
-                    None => (r.y0, r.y1),
-                });
-            }
-        }
-        // Every fill band maps a box as tall as the tallest band's ink, centred on its own ink, so
-        // a band with fewer lines keeps them at the same size, centred between its guides.
-        let tallest = band_y.iter().flatten().map(|(y0, y1)| y1 - y0).fold(0.0, f64::max);
-        let band_y: Vec<Option<(f64, f64)>> =
-            band_y.iter().map(|r| r.map(|(y0, y1)| ((y0 + y1 - tallest) / 2.0, (y0 + y1 + tallest) / 2.0))).collect();
-        for (b, band) in self.bands.iter().enumerate() {
-            if let Band::Fill { top, bottom } = band {
-                let half = lines
-                    .iter()
-                    .enumerate()
-                    .filter(|(i, _)| band_of.get(*i) == Some(&b))
-                    .filter_map(|(_, l)| l.ink)
-                    .map(|r| (r.x0 - cx).abs().max((r.x1 - cx).abs()))
-                    .fold(0.0, f64::max);
-                if half > 1e-9 {
-                    k_fill = k_fill.min(band.length() / (2.0 * half));
-                }
-                if let Some(Some((y0, y1))) = band_y.get(b) {
-                    let thick = [0.0, 0.25, 0.5, 0.75, 1.0].iter().map(|&u| (top.at_frac(u) - bottom.at_frac(u)).hypot()).fold(0.0, f64::max);
-                    if y1 - y0 > 1e-9 {
-                        zoom = zoom.max(thick / (y1 - y0));
-                    }
-                }
-            }
-        }
-        if !k_fill.is_finite() {
-            k_fill = 1.0;
-        }
-        zoom = zoom.max(k_fill);
-        let mut maps = Vec::with_capacity(n);
-        let mut offsets = Vec::new();
-        for (i, l) in lines.iter().enumerate() {
-            let b = band_of.get(i).copied().unwrap_or(0);
-            let in_band = |j: &usize| band_of.get(*j) == Some(&b);
-            match self.bands.get(b) {
-                Some(Band::Fill { .. }) | None => {
-                    let (y0, y1) = band_y.get(b).copied().flatten().unwrap_or((0.0, 1.0));
-                    let len = self.bands.get(b).map(Band::length).unwrap_or(0.0);
-                    maps.push(LineMap::Fill { band: b, cx, k: k_fill, len, y0, y1 });
-                }
-                Some(Band::Follow { path, anchor }) => {
-                    let len = path.length();
-                    let widest = (0..n).filter(in_band).filter_map(|j| lines.get(j)).map(|l| l.extent.1 - l.extent.0).fold(0.0, f64::max);
-                    let k = if widest > len && widest > 1e-9 { len / widest } else { 1.0 };
-                    let members: Vec<&WarpLine> = (0..n).filter(in_band).filter_map(|j| lines.get(j)).collect();
-                    let ref_y = match anchor {
-                        LineAnchor::Last => members.last().map(|l| l.ref_y),
-                        LineAnchor::First => members.first().map(|l| l.ref_y),
-                        LineAnchor::Middle => match (members.first(), members.last()) {
-                            (Some(a), Some(z)) => Some((a.ref_y + z.ref_y) / 2.0),
-                            _ => None,
-                        },
-                    }
-                    .unwrap_or(l.ref_y);
-                    // Lines off the guide run on a parallel curve at their natural length.
-                    let d = (ref_y - l.ref_y) * k;
-                    let (guide, len) = if d.abs() > 1e-6 && d.is_finite() && offsets.len() < 4096 {
-                        let g = path.offset(d);
-                        let len = g.length();
-                        offsets.push(g);
-                        (Some(offsets.len() - 1), len)
-                    } else {
-                        (None, len)
-                    };
-                    let (e0, e1) = l.extent;
-                    let w = (e1 - e0).max(0.0) * k;
-                    let (gl, gr) = ((e0 - inner.x0).max(0.0), (inner.x1 - e1).max(0.0));
-                    let f = if gl + gr > 1e-9 { gl / (gl + gr) } else { 0.5 };
-                    let s0 = f * (len - w);
-                    maps.push(LineMap::Follow { band: b, guide, e0, s0, k, ref_y: l.ref_y });
-                }
-            }
-        }
-        Mapper { warp: self, lines: maps, offsets, zoom: if zoom.is_finite() { zoom.clamp(1.0, 1.0e4) } else { 1.0 } }
-    }
-}
-
-impl Mapper<'_> {
-    /// How much the warp magnifies text at most (for flattening tolerances), ≥ 1.
-    pub fn zoom(&self) -> f64 {
-        self.zoom
-    }
-
-    /// Map point `p` of line `line` (layout coordinates) onto the warp.
-    pub fn map(&self, line: usize, p: Point) -> Point {
-        let out = match self.lines.get(line) {
-            Some(&LineMap::Fill { band, cx, k, len, y0, y1 }) => {
-                let Some(Band::Fill { top, bottom }) = self.warp.bands.get(band) else { return p };
-                let u = if len > 1e-9 { 0.5 + (p.x - cx) * k / len } else { 0.5 };
-                let v = if y1 - y0 > 1e-9 { (p.y - y0) / (y1 - y0) } else { 0.5 };
-                let (t, b) = (top.at_frac(u), bottom.at_frac(u));
-                t.lerp(b, v)
-            }
-            Some(&LineMap::Follow { band, guide, e0, s0, k, ref_y }) => {
-                let path = match (guide.and_then(|g| self.offsets.get(g)), self.warp.bands.get(band)) {
-                    (Some(g), _) => g,
-                    (None, Some(Band::Follow { path, .. })) => path,
-                    _ => return p,
-                };
-                let s = s0 + (p.x - e0) * k;
-                let d = (ref_y - p.y) * k;
-                let (q, t) = path.at(s);
-                q + Vec2::new(t.y, -t.x) * d
-            }
-            None => p,
-        };
-        if out.x.is_finite() && out.y.is_finite() { out } else { p }
-    }
-}
-
-#[cfg(test)]
-mod tests;

crates/geom/src/warp/tests.rs

@@ -1,309 +0,0 @@
-use super::*;
-
-const ALL: &[&str] = &[
-    "textPlain",
-    "textStop",
-    "textTriangle",
-    "textTriangleInverted",
-    "textChevron",
-    "textChevronInverted",
-    "textRingInside",
-    "textRingOutside",
-    "textArchUp",
-    "textArchDown",
-    "textCircle",
-    "textButton",
-    "textArchUpPour",
-    "textArchDownPour",
-    "textCirclePour",
-    "textButtonPour",
-    "textCurveUp",
-    "textCurveDown",
-    "textCanUp",
-    "textCanDown",
-    "textWave1",
-    "textWave2",
-    "textDoubleWave1",
-    "textWave4",
-    "textInflate",
-    "textDeflate",
-    "textInflateBottom",
-    "textDeflateBottom",
-    "textInflateTop",
-    "textDeflateTop",
-    "textDeflateInflate",
-    "textDeflateInflateDeflate",
-    "textFadeRight",
-    "textFadeLeft",
-    "textFadeUp",
-    "textFadeDown",
-    "textSlantUp",
-    "textSlantDown",
-    "textCascadeUp",
-    "textCascadeDown",
-];
-
-const W: f64 = 420.0;
-const H: f64 = 200.0;
-
-fn rect() -> Rect {
-    Rect::new(0.0, 0.0, W, H)
-}
-
-/// One line whose ink box is `ink`.
-fn one_line(ink: Rect) -> Vec<WarpLine> {
-    vec![WarpLine { ink: Some(ink), extent: (ink.x0, ink.x1), ref_y: ink.y1 }]
-}
-
-/// Where the unit-square point (u, v) of a single line's ink box lands, in unit coordinates.
-fn land(name: &str, adj: &[f64], u: f64, v: f64) -> (f64, f64) {
-    let w = warp(name, adj, rect()).unwrap();
-    let ink = Rect::new(100.0, 50.0, 300.0, 90.0);
-    let lines = one_line(ink);
-    let m = w.mapper(&lines, rect().inset(-5.0));
-    let p = m.map(0, Point::new(ink.x0 + u * ink.width(), ink.y0 + v * ink.height()));
-    (p.x / W, p.y / H)
-}
-
-fn close(a: (f64, f64), b: (f64, f64), tol: f64) -> bool {
-    (a.0 - b.0).abs() <= tol && (a.1 - b.1).abs() <= tol
-}
-
-#[track_caller]
-fn corners(name: &str, adj: &[f64], tl: (f64, f64), tr: (f64, f64), bl: (f64, f64), br: (f64, f64)) {
-    for ((u, v), want) in [((0.0, 0.0), tl), ((1.0, 0.0), tr), ((0.0, 1.0), bl), ((1.0, 1.0), br)] {
-        let got = land(name, adj, u, v);
-        assert!(close(got, want, 0.004), "{name} corner ({u},{v}): got {got:?}, want {want:?}");
-    }
-}
-
-#[test]
-fn every_preset_builds_finite_guides() {
-    for name in ALL {
-        assert!(is_supported(name), "{name}");
-        let w = warp(name, &[], rect()).unwrap_or_else(|| panic!("{name}"));
-        assert!(!w.bands.is_empty(), "{name}");
-        for b in &w.bands {
-            let l = b.length();
-            assert!(l.is_finite() && l > 10.0, "{name}: band length {l}");
-        }
-        assert_eq!(adjust_count(name), adjust_defaults(name).len());
-    }
-    assert!(warp("textNoShape", &[], rect()).is_none());
-    assert!(warp("bogus", &[], rect()).is_none());
-    assert!(!is_supported("textNoShape"));
-}
-
-#[test]
-fn straight_presets_put_the_ink_corners_on_their_guides() {
-    corners("textPlain", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0));
-    // A smaller adjust shears the text: the top edge starts 40 % in, the bottom edge ends 60 % in.
-    corners("textPlain", &[30_000.0], (0.4, 0.0), (1.0, 0.0), (0.0, 1.0), (0.6, 1.0));
-    corners("textStop", &[], (0.0, 0.25), (1.0, 0.25), (0.0, 0.75), (1.0, 0.75));
-    corners("textTriangle", &[], (0.0, 0.5), (1.0, 0.5), (0.0, 1.0), (1.0, 1.0));
-    corners("textTriangleInverted", &[25_000.0], (0.0, 0.0), (1.0, 0.0), (0.0, 0.25), (1.0, 0.25));
-    corners("textChevron", &[], (0.0, 0.25), (1.0, 0.25), (0.0, 1.0), (1.0, 1.0));
-    corners("textChevronInverted", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 0.75), (1.0, 0.75));
-    corners("textFadeRight", &[], (0.0, 0.0), (1.0, 0.33333), (0.0, 1.0), (1.0, 0.66667));
-    corners("textFadeLeft", &[], (0.0, 0.33333), (1.0, 0.0), (0.0, 0.66667), (1.0, 1.0));
-    corners("textFadeUp", &[], (0.33333, 0.0), (0.66667, 0.0), (0.0, 1.0), (1.0, 1.0));
-    corners("textFadeDown", &[], (0.0, 0.0), (1.0, 0.0), (0.33333, 1.0), (0.66667, 1.0));
-    corners("textSlantUp", &[], (0.0, 0.55556), (1.0, 0.0), (0.0, 1.0), (1.0, 0.44444));
-    corners("textSlantDown", &[], (0.0, 0.0), (1.0, 0.55556), (0.0, 0.44444), (1.0, 1.0));
-    corners("textCascadeUp", &[], (0.0, 0.13889), (1.0, 0.0), (0.0, 1.0), (1.0, 0.44444));
-    corners("textCascadeDown", &[], (0.0, 0.0), (1.0, 0.13889), (0.0, 0.44444), (1.0, 1.0));
-}
-
-#[test]
-fn curved_presets_bend_where_powerpoint_bends_them() {
-    corners("textInflate", &[], (0.0, 0.1875), (1.0, 0.1875), (0.0, 0.8125), (1.0, 0.8125));
-    assert!(close(land("textInflate", &[], 0.5, 0.0), (0.5, 0.0), 0.004));
-    assert!(close(land("textInflate", &[], 0.5, 1.0), (0.5, 1.0), 0.004));
-    corners("textDeflate", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0));
-    assert!(close(land("textDeflate", &[], 0.5, 0.0), (0.5, 0.1875), 0.004));
-    corners("textInflateBottom", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 0.6), (1.0, 0.6));
-    assert!(close(land("textInflateBottom", &[], 0.5, 1.0), (0.5, 0.8), 0.004));
-    assert!(close(land("textDeflateBottom", &[], 0.5, 1.0), (0.5, 0.5), 0.004));
-    assert!(close(land("textInflateTop", &[], 0.5, 0.0), (0.5, 0.2), 0.004));
-    assert!(close(land("textDeflateTop", &[], 0.5, 0.0), (0.5, 0.5), 0.004));
-    // Cans: half ellipses.
-    corners("textCanUp", &[], (0.0, 0.15), (1.0, 0.15), (0.0, 1.0), (1.0, 1.0));
-    assert!(close(land("textCanUp", &[], 0.5, 0.0), (0.5, 0.0), 0.004));
-    assert!(close(land("textCanUp", &[], 0.5, 1.0), (0.5, 0.85), 0.004));
-    assert!(close(land("textCanDown", &[], 0.5, 0.0), (0.5, 0.14286), 0.004));
-    // Curves and waves.
-    let a = 0.45977;
-    corners("textCurveUp", &[], (0.0, a), (1.0, 0.0), (0.0, 1.0 - 3.0 * a / 8.0), (1.0, 1.0 - 3.0 * a / 8.0));
-    assert!(close(land("textCurveUp", &[], 0.5, 1.0), (0.5, 1.0), 0.004));
-    corners("textCurveDown", &[], (0.0, 0.0), (1.0, a), (0.0, 1.0 - 3.0 * a / 8.0), (1.0, 1.0 - 3.0 * a / 8.0));
-    corners("textWave1", &[], (0.0, 0.125), (1.0, 0.125), (0.0, 0.875), (1.0, 0.875));
-    // Wave 1 rises first: its top is near the box top a quarter of the way along.
-    assert!(land("textWave1", &[], 0.25, 0.0).1 < 0.02);
-    assert!(land("textWave2", &[], 0.25, 0.0).1 > 0.23);
-    // A horizontal shift moves the bottom guide right.
-    corners("textWave1", &[12_500.0, 5_000.0], (0.0, 0.125), (0.9, 0.125), (0.1, 0.875), (1.0, 0.875));
-    assert!(land("textDoubleWave1", &[], 0.125, 0.0).1 < 0.02);
-    assert!(land("textWave4", &[], 0.125, 0.0).1 > 0.1);
-}
-
-#[test]
-fn arc_presets_follow_ellipses() {
-    // Pour arches: the outer arc from the left end over the top; the inner one is scaled by adj2.
-    corners("textArchUpPour", &[], (0.0, 0.5), (1.0, 0.5), (0.25, 0.5), (0.75, 0.5));
-    assert!(close(land("textArchUpPour", &[], 0.5, 0.0), (0.5, 0.0), 0.004));
-    assert!(close(land("textArchUpPour", &[], 0.5, 1.0), (0.5, 0.25), 0.004));
-    assert!(close(land("textArchUpPour", &[10_800_000.0, 30_000.0], 0.5, 1.0), (0.5, 0.35), 0.004));
-    assert!(close(land("textArchDownPour", &[], 0.5, 0.0), (0.5, 0.625), 0.004));
-    assert!(close(land("textArchDownPour", &[], 0.5, 1.0), (0.5, 1.0), 0.004));
-    // Circle pour: once round from the left; the middle of the text is at the right.
-    assert!(close(land("textCirclePour", &[], 0.5, 0.0), (1.0, 0.5), 0.004));
-    // Rings: the text goes round two stacked ellipses.
-    assert!(close(land("textRingInside", &[], 0.0, 0.0), (0.0, 0.3), 0.004));
-    assert!(close(land("textRingInside", &[], 0.0, 1.0), (0.0, 0.7), 0.004));
-    assert!(close(land("textRingInside", &[], 0.25, 0.0), (0.5, 0.0), 0.01));
-    assert!(close(land("textRingOutside", &[], 0.25, 1.0), (0.5, 1.0), 0.01));
-}
-
-#[test]
-fn follow_presets_keep_text_size_and_stack_lines_outwards() {
-    let w = warp("textArchUp", &[], rect()).unwrap();
-    // A 40-wide centred line whose reference height is 80.
-    let line = WarpLine { ink: Some(Rect::new(190.0, 50.0, 230.0, 88.0)), extent: (190.0, 230.0), ref_y: 80.0 };
-    let inner = Rect::new(7.2, 3.6, W - 7.2, H - 3.6);
-    let m = w.mapper(&[line], inner);
-    // The middle of the reference line lands on the top of the ellipse; 10 pt above it lands
-    // 10 pt above the top.
-    let p = m.map(0, Point::new(210.0, 80.0));
-    assert!((p.x - 210.0).abs() < 0.05 && p.y.abs() < 0.05, "{p:?}");
-    let q = m.map(0, Point::new(210.0, 70.0));
-    assert!((q.x - 210.0).abs() < 0.15 && (q.y + 10.0).abs() < 0.05, "{q:?}");
-    // Natural size: 40 pt of text spans about 40 pt of arc.
-    let (a, b) = (m.map(0, Point::new(190.0, 80.0)), m.map(0, Point::new(230.0, 80.0)));
-    assert!(((b - a).hypot() - 40.0).abs() < 0.5);
-    // Left-aligned text starts at the very start of the arc: insets don't shorten it.
-    let left = WarpLine { ink: Some(Rect::new(7.2, 50.0, 47.2, 88.0)), extent: (7.2, 47.2), ref_y: 80.0 };
-    let m = w.mapper(&[left], inner);
-    let p = m.map(0, Point::new(7.2, 80.0));
-    assert!(p.x.abs() < 0.01 && (p.y - 100.0).abs() < 0.01, "{p:?}");
-    // Two lines on an arch up: the last sits on the arc, the first stacks outside it.
-    let l1 = WarpLine { ink: Some(Rect::new(190.0, 10.0, 230.0, 40.0)), extent: (190.0, 230.0), ref_y: 34.0 };
-    let l2 = WarpLine { ink: Some(Rect::new(190.0, 50.0, 230.0, 80.0)), extent: (190.0, 230.0), ref_y: 74.0 };
-    let m = w.mapper(&[l1, l2], inner);
-    assert!(m.map(1, Point::new(210.0, 74.0)).y.abs() < 0.05);
-    assert!((m.map(0, Point::new(210.0, 34.0)).y + 40.0).abs() < 0.05);
-    // Arch down: the first line sits on the bottom of the ellipse.
-    let w = warp("textArchDown", &[], rect()).unwrap();
-    let m = w.mapper(&[l1, l2], inner);
-    assert!((m.map(0, Point::new(210.0, 34.0)).y - H).abs() < 0.05);
-    assert!((m.map(1, Point::new(210.0, 74.0)).y - H - 40.0).abs() < 0.05);
-    // Text longer than the arc is shrunk to fit it.
-    let w = warp("textArchUp", &[], rect()).unwrap();
-    let long = WarpLine { ink: Some(Rect::new(-500.0, 50.0, 900.0, 88.0)), extent: (-500.0, 900.0), ref_y: 80.0 };
-    let m = w.mapper(&[long], inner);
-    let (a, b) = (m.map(0, Point::new(-500.0, 80.0)), m.map(0, Point::new(900.0, 80.0)));
-    assert!(a.x < 5.0 && b.x > W - 5.0 && (a.y - 100.0).abs() < 10.0 && (b.y - 100.0).abs() < 10.0, "{a:?} {b:?}");
-}
-
-#[test]
-fn lines_share_bands_in_order() {
-    assert_eq!((0..2).map(|i| band_of_line(i, 2, 2)).collect::<Vec<_>>(), [0, 1]);
-    assert_eq!((0..3).map(|i| band_of_line(i, 3, 2)).collect::<Vec<_>>(), [0, 0, 1]);
-    assert_eq!((0..5).map(|i| band_of_line(i, 5, 2)).collect::<Vec<_>>(), [0, 0, 0, 1, 1]);
-    assert_eq!((0..5).map(|i| band_of_line(i, 5, 3)).collect::<Vec<_>>(), [0, 0, 1, 1, 2]);
-    assert_eq!((0..4).map(|i| band_of_line(i, 4, 3)).collect::<Vec<_>>(), [0, 0, 1, 2]);
-    assert_eq!((0..2).map(|i| band_of_line(i, 2, 3)).collect::<Vec<_>>(), [0, 1]);
-    assert_eq!(band_of_line(0, 1, 3), 0);
-    assert_eq!(band_of_line(7, 9, 1), 0);
-    assert_eq!(band_of_line(0, 0, 3), 0);
-}
-
-#[test]
-fn deflate_inflate_maps_each_band_separately() {
-    let w = warp("textDeflateInflate", &[], rect()).unwrap();
-    assert_eq!(w.bands.len(), 2);
-    let l1 = WarpLine { ink: Some(Rect::new(100.0, 10.0, 300.0, 40.0)), extent: (100.0, 300.0), ref_y: 34.0 };
-    let l2 = WarpLine { ink: Some(Rect::new(100.0, 50.0, 300.0, 80.0)), extent: (100.0, 300.0), ref_y: 74.0 };
-    let m = w.mapper(&[l1, l2], rect());
-    // Band 1 ends at 45 % height on the sides, band 2 starts at 55 %.
-    assert!((m.map(0, Point::new(100.0, 40.0)).y / H - 0.45).abs() < 0.004);
-    assert!((m.map(1, Point::new(100.0, 50.0)).y / H - 0.55).abs() < 0.004);
-    assert!((m.map(1, Point::new(300.0, 80.0)).y / H - 1.0).abs() < 0.004);
-    // A band with fewer lines keeps them at the size of the fuller band, centred in its band:
-    // two lines (ink 10..60) in band 1, one line (ink 70..80) in band 2 of three.
-    let a = WarpLine { ink: Some(Rect::new(100.0, 10.0, 300.0, 30.0)), extent: (100.0, 300.0), ref_y: 28.0 };
-    let b = WarpLine { ink: Some(Rect::new(100.0, 40.0, 300.0, 60.0)), extent: (100.0, 300.0), ref_y: 58.0 };
-    let c = WarpLine { ink: Some(Rect::new(100.0, 70.0, 300.0, 80.0)), extent: (100.0, 300.0), ref_y: 78.0 };
-    let m = w.mapper(&[a, b, c], rect());
-    let (top, bot) = (m.map(2, Point::new(200.0, 70.0)).y / H, m.map(2, Point::new(200.0, 80.0)).y / H);
-    // Band 2 runs from 0.4 to 1 at the centre; the line takes the middle fifth of it.
-    assert!((top - 0.64).abs() < 0.005 && (bot - 0.76).abs() < 0.005, "{top} {bot}");
-    // A shorter first line keeps its share of the width.
-    let short = WarpLine { ink: Some(Rect::new(150.0, 10.0, 250.0, 40.0)), extent: (150.0, 250.0), ref_y: 34.0 };
-    let m = w.mapper(&[short, l2], rect());
-    let p = m.map(0, Point::new(150.0, 10.0));
-    assert!((p.x / W - 0.25).abs() < 0.01, "{p:?}");
-}
-
-#[test]
-fn guides_extrapolate_and_wrap() {
-    let mut p = BezPath::new();
-    p.move_to((0.0, 0.0));
-    p.line_to((10.0, 0.0));
-    let g = Guide::from_path(&p, false);
-    assert!((g.length() - 10.0).abs() < 1e-9);
-    assert!((g.at(15.0).0.x - 15.0).abs() < 1e-9);
-    assert!((g.at(-5.0).0.x + 5.0).abs() < 1e-9);
-    assert!(g.at(f64::NAN).0.x.is_finite());
-    let w = warp("textCircle", &[], rect()).unwrap();
-    let Some(Band::Follow { path, .. }) = w.bands.first() else { panic!() };
-    assert!(path.is_closed());
-    let l = path.length();
-    let (a, b) = (path.at(5.0).0, path.at(l + 5.0).0);
-    assert!((a - b).hypot() < 1e-6);
-    let empty = Guide::default();
-    assert_eq!(empty.length(), 0.0);
-    assert!(empty.at(3.0).0.x.is_finite());
-}
-
-#[test]
-fn hostile_adjusts_and_boxes_stay_finite() {
-    let adjs: &[&[f64]] =
-        &[&[], &[f64::NAN, f64::INFINITY], &[f64::NEG_INFINITY, f64::NAN], &[1e300, -1e300], &[-1e9, 1e9], &[0.0, 0.0], &[21_599_999.0, 100_000.0]];
-    let rects = [
-        Rect::new(0.0, 0.0, 0.0, 0.0),
-        Rect::new(10.0, 10.0, 10.0, 200.0),
-        Rect::new(0.0, 0.0, 300.0, 0.0),
-        Rect::new(100.0, 100.0, -50.0, -20.0),
-        Rect::new(0.0, 0.0, 1e7, 1e7),
-    ];
-    let lines = [
-        WarpLine { ink: Some(Rect::new(0.0, 0.0, 0.0, 0.0)), extent: (0.0, 0.0), ref_y: 0.0 },
-        WarpLine { ink: None, extent: (5.0, 5.0), ref_y: 3.0 },
-        WarpLine { ink: Some(Rect::new(-1e6, -5.0, 1e6, 5.0)), extent: (-1e6, 1e6), ref_y: 4.0 },
-    ];
-    for name in ALL {
-        for adj in adjs {
-            for r in rects {
-                let Some(w) = warp(name, adj, r) else { panic!("{name} {adj:?} {r:?}") };
-                for b in &w.bands {
-                    assert!(b.length().is_finite());
-                }
-                let m = w.mapper(&lines, r);
-                assert!(m.zoom().is_finite() && m.zoom() >= 1.0);
-                let probes = [
-                    (0, Point::ZERO),
-                    (1, Point::new(5.0, 3.0)),
-                    (2, Point::new(1e6, -5.0)),
-                    (2, Point::new(f64::NAN, 1.0)),
-                    (9, Point::new(1.0, 1.0)),
-                ];
-                for (i, p) in probes {
-                    let q = m.map(i, p);
-                    assert!(q.x.is_finite() || !p.x.is_finite(), "{name} {adj:?} {r:?}: {q:?}");
-                    assert!(q.y.is_finite(), "{name} {adj:?} {r:?}: {q:?}");
-                }
-            }
-        }
-    }
-    assert!(warp("textPlain", &[], Rect::new(f64::NAN, 0.0, 1.0, 1.0)).is_none());
-}

crates/metafile/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "deckcraft-metafile"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-description = "DeckCraft metafiles (ported from WordCraft): parses Windows WMF and EMF records into a neutral vector model (paths and bitmaps)"
-
-[lints]
-workspace = true
-
-[dependencies]
-kurbo = { workspace = true }
-thiserror = { workspace = true }

crates/metafile/src/bytes.rs

@@ -1,59 +0,0 @@
-//! Bounds-checked little-endian access to hostile input. Every read returns `None` past the end, so
-//! a truncated or lying size field stops the parse instead of panicking.
-
-#[derive(Clone, Copy)]
-pub(crate) struct Bytes<'a>(pub(crate) &'a [u8]);
-
-impl<'a> Bytes<'a> {
-    pub fn slice(&self, off: usize, len: usize) -> Option<&'a [u8]> {
-        self.0.get(off..off.checked_add(len)?)
-    }
-
-    pub fn tail(&self, off: usize) -> Option<Bytes<'a>> {
-        self.0.get(off..).map(Bytes)
-    }
-
-    fn arr<const N: usize>(&self, off: usize) -> Option<[u8; N]> {
-        self.slice(off, N)?.try_into().ok()
-    }
-
-    pub fn u16(&self, off: usize) -> Option<u16> {
-        Some(u16::from_le_bytes(self.arr(off)?))
-    }
-
-    pub fn i16(&self, off: usize) -> Option<i16> {
-        Some(i16::from_le_bytes(self.arr(off)?))
-    }
-
-    pub fn u32(&self, off: usize) -> Option<u32> {
-        Some(u32::from_le_bytes(self.arr(off)?))
-    }
-
-    pub fn i32(&self, off: usize) -> Option<i32> {
-        Some(i32::from_le_bytes(self.arr(off)?))
-    }
-
-    pub fn f32(&self, off: usize) -> Option<f32> {
-        Some(f32::from_le_bytes(self.arr(off)?))
-    }
-
-    /// `n` consecutive (x, y) pairs of 16- or 32-bit signed integers starting at `off`.
-    pub fn points(&self, off: usize, n: usize, wide: bool) -> Option<Vec<(f64, f64)>> {
-        let sz = if wide { 8 } else { 4 };
-        let raw = self.slice(off, n.checked_mul(sz)?)?;
-        let mut out = Vec::with_capacity(n);
-        for c in raw.chunks_exact(sz) {
-            let p = if wide {
-                let x = i32::from_le_bytes(c.get(0..4)?.try_into().ok()?);
-                let y = i32::from_le_bytes(c.get(4..8)?.try_into().ok()?);
-                (f64::from(x), f64::from(y))
-            } else {
-                let x = i16::from_le_bytes(c.get(0..2)?.try_into().ok()?);
-                let y = i16::from_le_bytes(c.get(2..4)?.try_into().ok()?);
-                (f64::from(x), f64::from(y))
-            };
-            out.push(p);
-        }
-        Some(out)
-    }
-}

crates/metafile/src/canvas.rs

@@ -1,893 +0,0 @@
-//! Drawing state shared by the WMF and EMF readers: window/viewport mapping and the EMF world
-//! transform, pen and brush selection through an object table, the DC save stack and path brackets.
-//! Output is device-space items; `lib.rs` maps them into the picture frame.
-
-use std::sync::{Arc, OnceLock};
-
-use crate::dib::Rgba;
-use crate::geom::{Op, P};
-use crate::text::{ETO_CLIPPED, ETO_OPAQUE, Font, TA_UPDATECP, Text, align};
-use crate::{MAX_BYTES, MAX_ITEMS, MAX_OBJECTS, MAX_PATH_OPS, MAX_STACK};
-
-pub(crate) const MM_TEXT: u32 = 1;
-const MM_ISOTROPIC: u32 = 7;
-const MM_ANISOTROPIC: u32 = 8;
-const STOCK: u32 = 0x8000_0000;
-pub(crate) const PS_NULL: u32 = 5;
-/// Pen style bits; the rest of the style word holds end-cap, join and type flags.
-pub(crate) const PS_STYLE_MASK: u32 = 0x0F;
-const BS_SOLID: u32 = 0;
-pub(crate) const BS_NULL: u32 = 1;
-pub(crate) const BS_HATCHED: u32 = 2;
-/// BS_PATTERN, BS_DIBPATTERN and BS_DIBPATTERNPT: the brush paints a bitmap tile.
-const BS_PATTERN: u32 = 3;
-const BS_DIBPATTERN: u32 = 5;
-const BS_DIBPATTERNPT: u32 = 6;
-const WINDING: u32 = 2;
-/// SETROP2 mix modes. R2_NOP leaves the destination alone: outlines and fills draw nothing.
-/// R2_XORPEN and R2_MASKPEN draw the classic see-through shadow (XOR a colour, AND a pattern, XOR
-/// the colour again); the others draw as R2_COPYPEN.
-const R2_XORPEN: u32 = 7;
-const R2_MASKPEN: u32 = 9;
-const R2_NOP: u32 = 11;
-const R2_COPYPEN: u32 = 13;
-/// SETBKMODE OPAQUE: text cells and hatch gaps are filled with the background colour.
-const OPAQUE: u32 = 2;
-const PATCOPY: u32 = 0x00F0_0021;
-const BLACKNESS: u32 = 0x0000_0042;
-const WHITENESS: u32 = 0x00FF_0062;
-/// Device pixels per millimetre assumed for WMF (96 dpi), and for EMF files without a device size.
-const DEFAULT_PX_PER_MM: f64 = 96.0 / 25.4;
-
-/// Affine transform `[m11, m12, m21, m22, dx, dy]` in EMF XFORM order: `x' = x·m11 + y·m21 + dx`.
-pub(crate) type Xform = [f64; 6];
-const IDENTITY: Xform = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
-
-/// `a` then `b` in EMF row-vector convention: the matrix product `a × b`.
-pub(crate) fn mul(a: Xform, b: Xform) -> Xform {
-    [
-        a[0] * b[0] + a[1] * b[2],
-        a[0] * b[1] + a[1] * b[3],
-        a[2] * b[0] + a[3] * b[2],
-        a[2] * b[1] + a[3] * b[3],
-        a[4] * b[0] + a[5] * b[2] + b[4],
-        a[4] * b[1] + a[5] * b[3] + b[5],
-    ]
-}
-
-#[derive(Clone, Copy, PartialEq, Debug)]
-pub(crate) struct Pen {
-    pub style: u32,
-    /// Logical width; 0 means a cosmetic one-pixel hairline.
-    pub width: f64,
-    pub color: [u8; 4],
-}
-
-#[derive(Clone, PartialEq, Debug)]
-pub(crate) struct Brush {
-    pub style: u32,
-    pub color: [u8; 4],
-    /// HS_* hatch style of a BS_HATCHED brush.
-    pub hatch: u32,
-    /// The tile of a pattern brush.
-    pub pattern: Option<Arc<Pattern>>,
-}
-
-impl Brush {
-    pub fn new(style: u32, color: [u8; 4]) -> Self {
-        Brush { style, color, hatch: 0, pattern: None }
-    }
-
-    /// A pattern brush painting `img`. A monochrome brush paints its dark pixels in the text
-    /// colour and its light ones in the background colour. None for an empty or oversized tile.
-    pub fn pattern(img: Rgba, mono: bool) -> Option<Self> {
-        if img.w == 0 || img.h == 0 || img.w > MAX_TILE_SIDE || img.h > MAX_TILE_SIDE || img.px.len() != img.w * img.h * 4 {
-            return None;
-        }
-        let pattern = Arc::new(Pattern { w: img.w, h: img.h, px: img.px, mono, plain: OnceLock::new() });
-        Some(Brush { style: BS_DIBPATTERNPT, color: [0, 0, 0, 255], hatch: 0, pattern: Some(pattern) })
-    }
-}
-
-/// A pattern brush's tile, top-down RGBA.
-#[derive(PartialEq, Debug)]
-pub(crate) struct Pattern {
-    pub w: usize,
-    pub h: usize,
-    pub px: Vec<u8>,
-    pub mono: bool,
-    /// The tile as drawn when nothing recolours it, shared by every fill with this brush.
-    pub plain: OnceLock<Arc<RawTile>>,
-}
-
-/// Largest pattern tile side kept (GDI brushes are typically 8×8).
-pub(crate) const MAX_TILE_SIDE: usize = 256;
-
-#[derive(Clone, Debug)]
-pub(crate) enum Obj {
-    Pen(Pen),
-    Brush(Brush),
-    Font(Arc<LogFont>),
-    /// Palettes and regions: they take a table slot but draw nothing.
-    Other,
-}
-
-/// A font object: the neutral [`Font`] and its escapement (tenths of a degree, counter-clockwise),
-/// which the text transform takes.
-#[derive(Debug, Clone, PartialEq, Default)]
-pub(crate) struct LogFont {
-    pub font: Font,
-    pub escapement: f64,
-}
-
-/// A brush tile in device units: `cell` device units per tile pixel, laid from the device origin.
-#[derive(Debug, PartialEq)]
-pub(crate) struct RawTile {
-    pub w: usize,
-    pub h: usize,
-    pub px: Vec<u8>,
-    pub cell: f64,
-}
-
-/// What a fill paints.
-enum Paint {
-    Solid([u8; 4]),
-    Tile(Arc<RawTile>),
-}
-
-/// Converts a COLORREF (0x00BBGGRR) to opaque RGBA.
-pub(crate) fn colorref(c: u32) -> [u8; 4] {
-    [(c & 0xFF) as u8, ((c >> 8) & 0xFF) as u8, ((c >> 16) & 0xFF) as u8, 255]
-}
-
-/// Millimetres per logical unit of the metric map modes (LOMETRIC, HIMETRIC, LOENGLISH, HIENGLISH, TWIPS).
-fn metric_mm(mode: u32) -> Option<f64> {
-    match mode {
-        2 => Some(0.1),
-        3 => Some(0.01),
-        4 => Some(25.4 / 100.0),
-        5 => Some(25.4 / 1000.0),
-        6 => Some(25.4 / 1440.0),
-        _ => None,
-    }
-}
-
-#[derive(Clone, Copy)]
-pub(crate) struct Mapping {
-    wo: P,
-    we: P,
-    vo: P,
-    ve: P,
-    mode: u32,
-    world: Xform,
-    /// Device pixels per millimetre on each axis (EMF: from szlDevice and szlMillimeters).
-    px_mm: P,
-}
-
-impl Mapping {
-    fn identity() -> Self {
-        Mapping {
-            wo: (0.0, 0.0),
-            we: (1.0, 1.0),
-            vo: (0.0, 0.0),
-            ve: (1.0, 1.0),
-            mode: MM_TEXT,
-            world: IDENTITY,
-            px_mm: (DEFAULT_PX_PER_MM, DEFAULT_PX_PER_MM),
-        }
-    }
-
-    /// Logical point to device point: world transform, then window to viewport.
-    pub fn device(&self, p: P) -> P {
-        let w = self.world;
-        let (x, y) = (p.0 * w[0] + p.1 * w[2] + w[4], p.0 * w[1] + p.1 * w[3] + w[5]);
-        let (sx, sy) = self.ratios();
-        ((x - self.wo.0) * sx + self.vo.0, (y - self.wo.1) * sy + self.vo.1)
-    }
-
-    /// Window-to-viewport scale per axis. MM_TEXT fixes the scale at 1; the metric modes use a fixed
-    /// scale with y up; MM_ISOTROPIC uses one scale on both axes (the smaller magnitude, each axis's
-    /// sign kept); anisotropic and unknown modes use the extents as given.
-    fn ratios(&self) -> (f64, f64) {
-        if self.mode == MM_TEXT {
-            return (1.0, 1.0);
-        }
-        if let Some(mm) = metric_mm(self.mode) {
-            return (mm * self.px_mm.0, -mm * self.px_mm.1);
-        }
-        let (rx, ry) = (ratio(self.ve.0, self.we.0), ratio(self.ve.1, self.we.1));
-        if self.mode == MM_ISOTROPIC {
-            let s = rx.abs().min(ry.abs());
-            return (if rx < 0.0 { -s } else { s }, if ry < 0.0 { -s } else { s });
-        }
-        (rx, ry)
-    }
-
-    /// Approximate device length per logical length, for pen widths.
-    fn scale(&self) -> f64 {
-        let w = self.world;
-        let det = (w[0] * w[3] - w[1] * w[2]).abs().sqrt();
-        let (sx, sy) = self.ratios();
-        det * (sx.abs() + sy.abs()) / 2.0
-    }
-
-    /// True when the window-to-viewport extents set the scale (the isotropic and anisotropic modes).
-    pub fn uses_extents(&self) -> bool {
-        matches!(self.mode, MM_ISOTROPIC | MM_ANISOTROPIC)
-    }
-
-    pub fn window_ext(&self) -> P {
-        self.we
-    }
-
-    pub fn viewport_ext(&self) -> P {
-        self.ve
-    }
-
-    /// The window in device units as `[x, y, w, h]` with positive extents, used as the picture frame
-    /// of a plain WMF.
-    pub fn window_rect(&self) -> [f64; 4] {
-        let a = self.device(self.wo);
-        let b = self.device((self.wo.0 + self.we.0, self.wo.1 + self.we.1));
-        [a.0.min(b.0), a.1.min(b.1), (b.0 - a.0).abs(), (b.1 - a.1).abs()]
-    }
-}
-
-fn ratio(num: f64, den: f64) -> f64 {
-    if den == 0.0 { 1.0 } else { num / den }
-}
-
-/// Output of drawing, in device units. Path points are already mapped; `lib.rs` normalises them.
-pub(crate) enum Raw {
-    Path {
-        ops: Vec<Op>,
-        fill: Option<[u8; 4]>,
-        stroke: Option<([u8; 4], f64)>,
-        even_odd: bool,
-    },
-    /// A path filled with a repeating tile.
-    Pattern {
-        ops: Vec<Op>,
-        even_odd: bool,
-        tile: Arc<RawTile>,
-    },
-    Bitmap {
-        rect: [f64; 4],
-        img: Rgba,
-    },
-    /// Text whose transform and clip are in device units.
-    Text(Box<Text>),
-}
-
-/// Text drawing state: colours, background mode, alignment and the selected font.
-#[derive(Clone)]
-struct TextState {
-    color: [u8; 4],
-    bk_color: [u8; 4],
-    bk_opaque: bool,
-    align: u32,
-    font: Option<Arc<LogFont>>,
-}
-
-#[derive(Clone)]
-struct Saved {
-    map: Mapping,
-    pen: Pen,
-    brush: Brush,
-    even_odd: bool,
-    rop2: u32,
-    text: TextState,
-}
-
-pub(crate) struct Canvas {
-    pub items: Vec<Raw>,
-    pub map: Mapping,
-    /// True once SETWINDOWEXT was seen, so a plain WMF has a frame to use.
-    pub window_set: bool,
-    /// True once the file set the viewport extent itself (not the player, see [`Canvas::play_into`]).
-    pub viewport_set: bool,
-    saved: Vec<Saved>,
-    /// Bytes held by the items so far (path ops and pixels), capped at [`MAX_BYTES`].
-    used: usize,
-    objects: Vec<Option<Obj>>,
-    pen: Pen,
-    brush: Brush,
-    even_odd: bool,
-    /// SETROP2 mix mode.
-    rop2: u32,
-    /// The colour of the last fill drawn with R2_XORPEN, for the see-through shadow idiom.
-    xor_color: Option<[u8; 4]>,
-    text: TextState,
-    /// Device units per pattern-brush pixel: brushes are laid out in 96-dpi pixels.
-    pub pattern_px: f64,
-    pos: P,
-    in_path: bool,
-    path: Vec<Op>,
-    full: bool,
-}
-
-impl Canvas {
-    pub fn new() -> Self {
-        Canvas {
-            items: Vec::new(),
-            map: Mapping::identity(),
-            window_set: false,
-            viewport_set: false,
-            saved: Vec::new(),
-            used: 0,
-            objects: Vec::new(),
-            pen: Pen { style: 0, width: 0.0, color: [0, 0, 0, 255] },
-            brush: Brush::new(BS_SOLID, [255, 255, 255, 255]),
-            even_odd: true,
-            rop2: R2_COPYPEN,
-            xor_color: None,
-            text: TextState { color: [0, 0, 0, 255], bk_color: [255, 255, 255, 255], bk_opaque: true, align: 0, font: None },
-            pattern_px: 1.0,
-            pos: (0.0, 0.0),
-            in_path: false,
-            path: Vec::new(),
-            full: false,
-        }
-    }
-
-    /// True once the item cap is hit; the readers stop there and keep what they have.
-    pub fn full(&self) -> bool {
-        self.full
-    }
-
-    fn push(&mut self, raw: Raw) {
-        let cost = match &raw {
-            Raw::Path { ops, .. } => ops.len() * std::mem::size_of::<Op>(),
-            // A tile shared with its brush is counted once (by the brush); one made for this fill
-            // counts here.
-            Raw::Pattern { ops, tile, .. } => {
-                let own = if Arc::strong_count(tile) == 1 { tile.px.len() } else { 0 };
-                ops.len() * std::mem::size_of::<Op>() + 64 + own
-            }
-            Raw::Bitmap { img, .. } => img.px.len(),
-            Raw::Text(t) => t.text.len() + t.dx.len() * 4 + t.font.family.len() + 128,
-        };
-        if self.items.len() >= MAX_ITEMS || self.used.saturating_add(cost) > MAX_BYTES {
-            self.full = true;
-        } else {
-            self.used += cost;
-            self.items.push(raw);
-        }
-    }
-
-    pub fn set_window_org(&mut self, p: P) {
-        self.map.wo = p;
-    }
-
-    pub fn set_window_ext(&mut self, e: P) {
-        self.map.we = e;
-        self.window_set = true;
-    }
-
-    pub fn set_viewport_org(&mut self, p: P) {
-        self.map.vo = p;
-    }
-
-    pub fn set_viewport_ext(&mut self, e: P) {
-        self.map.ve = e;
-        self.viewport_set = true;
-    }
-
-    /// Sets up the mapping the way a player does before it plays a WMF into a target: anisotropic,
-    /// `window` (`[x, y, w, h]` in logical units) onto a viewport of `size` at the origin. The file's
-    /// own window records then replace the window; the viewport stays unless the file sets one.
-    /// Without a window (a plain WMF) only the viewport extent is set: the map mode and viewport
-    /// origin stay the file's.
-    pub fn play_into(&mut self, window: Option<[f64; 4]>, size: P) {
-        if let Some([x, y, w, h]) = window {
-            self.map.mode = MM_ANISOTROPIC;
-            self.map.wo = (x, y);
-            self.map.we = (w, h);
-            self.map.vo = (0.0, 0.0);
-        }
-        self.map.ve = size;
-    }
-
-    pub fn set_map_mode(&mut self, mode: u32) {
-        self.map.mode = mode;
-    }
-
-    /// Device pixels per millimetre (x, y) for the metric map modes. Ignored unless both are positive.
-    pub fn set_device_mm(&mut self, px_mm: P) {
-        if px_mm.0.is_finite() && px_mm.1.is_finite() && px_mm.0 > 0.0 && px_mm.1 > 0.0 {
-            self.map.px_mm = px_mm;
-        }
-    }
-
-    pub fn set_polyfill(&mut self, mode: u32) {
-        self.even_odd = mode != WINDING;
-    }
-
-    /// SETROP2. R2_NOP draws nothing; R2_XORPEN and R2_MASKPEN are read as the see-through shadow
-    /// idiom (see [`Canvas::fill_paint`]); the other mix modes draw as copy.
-    pub fn set_rop2(&mut self, mode: u32) {
-        self.rop2 = mode;
-    }
-
-    pub fn set_text_color(&mut self, c: u32) {
-        self.text.color = colorref(c);
-    }
-
-    pub fn set_bk_color(&mut self, c: u32) {
-        self.text.bk_color = colorref(c);
-    }
-
-    pub fn set_bk_mode(&mut self, mode: u32) {
-        self.text.bk_opaque = mode == OPAQUE;
-    }
-
-    pub fn set_text_align(&mut self, ta: u32) {
-        self.text.align = ta;
-    }
-
-    /// The character set of the selected font (ANSI without one).
-    pub fn font_charset(&self) -> u8 {
-        self.text.font.as_ref().map_or(0, |f| f.font.charset)
-    }
-
-    /// EMF SETWORLDTRANSFORM (`mode` 4) and MODIFYWORLDTRANSFORM (1 identity, 2 left, 3 right, 4 set).
-    /// An unknown mode leaves the world transform as it was.
-    pub fn modify_world(&mut self, x: Xform, mode: u32) {
-        match mode {
-            1 => self.map.world = IDENTITY,
-            2 => self.map.world = mul(x, self.map.world),
-            3 => self.map.world = mul(self.map.world, x),
-            4 => self.map.world = x,
-            _ => {}
-        }
-    }
-
-    /// Pushes the drawing state. Past [`MAX_STACK`] levels the parse stops, since later restores
-    /// could no longer match the file.
-    pub fn save_dc(&mut self) {
-        if self.saved.len() < MAX_STACK {
-            self.saved.push(Saved {
-                map: self.map,
-                pen: self.pen,
-                brush: self.brush.clone(),
-                even_odd: self.even_odd,
-                rop2: self.rop2,
-                text: self.text.clone(),
-            });
-        } else {
-            self.full = true;
-        }
-    }
-
-    /// Negative `n` pops `-n` levels; positive `n` restores absolute level `n`.
-    pub fn restore_dc(&mut self, n: i32) {
-        let idx = if n < 0 { self.saved.len().checked_sub(n.unsigned_abs() as usize) } else { (n as usize).checked_sub(1) };
-        let Some(idx) = idx else { return };
-        let Some(s) = self.saved.get(idx).cloned() else { return };
-        self.saved.truncate(idx);
-        self.map = s.map;
-        self.pen = s.pen;
-        self.brush = s.brush;
-        self.even_odd = s.even_odd;
-        self.rop2 = s.rop2;
-        self.text = s.text;
-    }
-
-    /// Stores an object in `slot` (EMF index), or in the first free slot (WMF handle table).
-    pub fn add_object(&mut self, slot: Option<usize>, obj: Obj) {
-        // A pattern brush's pixels count against the byte budget like drawn items.
-        if let Obj::Brush(Brush { pattern: Some(p), .. }) = &obj {
-            let cost = p.px.len();
-            if self.used.saturating_add(cost) > MAX_BYTES {
-                self.full = true;
-                return;
-            }
-            self.used += cost;
-        }
-        match slot {
-            Some(i) if i < MAX_OBJECTS => {
-                if self.objects.len() <= i {
-                    self.objects.resize(i + 1, None);
-                }
-                if let Some(s) = self.objects.get_mut(i) {
-                    *s = Some(obj);
-                }
-            }
-            Some(_) => {}
-            None => match self.objects.iter().position(Option::is_none) {
-                Some(i) => {
-                    if let Some(s) = self.objects.get_mut(i) {
-                        *s = Some(obj);
-                    }
-                }
-                None if self.objects.len() < MAX_OBJECTS => self.objects.push(Some(obj)),
-                None => {}
-            },
-        }
-    }
-
-    pub fn delete_object(&mut self, i: u32) {
-        if let Some(s) = self.objects.get_mut(i as usize) {
-            *s = None;
-        }
-    }
-
-    /// Selects an object by index; indices with the high bit set are stock objects.
-    pub fn select(&mut self, i: u32) {
-        if i & STOCK != 0 {
-            return self.select_stock(i & !STOCK);
-        }
-        match self.objects.get(i as usize).cloned().flatten() {
-            Some(Obj::Pen(p)) => self.pen = p,
-            Some(Obj::Brush(b)) => self.brush = b,
-            Some(Obj::Font(f)) => self.text.font = Some(f),
-            Some(Obj::Other) | None => {}
-        }
-    }
-
-    fn select_stock(&mut self, i: u32) {
-        let white = [255, 255, 255, 255];
-        let black = [0, 0, 0, 255];
-        let gray = |v: u8| Brush::new(BS_SOLID, [v, v, v, 255]);
-        match i {
-            0 | 18 => self.brush = Brush::new(BS_SOLID, white),
-            1 => self.brush = gray(192),
-            2 => self.brush = gray(128),
-            3 => self.brush = gray(64),
-            4 => self.brush = Brush::new(BS_SOLID, black),
-            5 => self.brush = Brush::new(BS_NULL, black),
-            6 => self.pen = Pen { style: 0, width: 0.0, color: white },
-            7 | 19 => self.pen = Pen { style: 0, width: 0.0, color: black },
-            8 => self.pen = Pen { style: PS_NULL, width: 0.0, color: black },
-            // The stock fonts (OEM_FIXED_FONT … DEFAULT_GUI_FONT): drawn in the default face.
-            10..=17 => self.text.font = None,
-            _ => {}
-        }
-    }
-
-    fn map_op(&self, op: Op) -> Op {
-        match op {
-            Op::M(p) => Op::M(self.map.device(p)),
-            Op::L(p) => Op::L(self.map.device(p)),
-            Op::C(a, b, c) => Op::C(self.map.device(a), self.map.device(b), self.map.device(c)),
-            Op::Z => Op::Z,
-        }
-    }
-
-    /// The current brush's paint. Hatch and monochrome brushes take the background colour (when
-    /// the background mode is opaque) and the text colour. Under R2_MASKPEN (destination AND
-    /// brush) a tile's white pixels keep what is below, and its black ones take the colour of the
-    /// XOR fill before it: XOR, AND, XOR again leaves that colour where the tile is black.
-    fn fill_paint(&self) -> Option<Paint> {
-        let b = &self.brush;
-        match b.style {
-            BS_SOLID => Some(Paint::Solid(b.color)),
-            BS_HATCHED => {
-                let bg = self.text.bk_opaque.then_some(self.text.bk_color);
-                let px = hatch_tile(b.hatch, b.color, bg)?;
-                Some(Paint::Tile(Arc::new(RawTile { w: 8, h: 8, px, cell: self.pattern_px })))
-            }
-            BS_PATTERN | BS_DIBPATTERN | BS_DIBPATTERNPT => {
-                let p = b.pattern.as_ref()?;
-                if !p.mono && self.rop2 != R2_MASKPEN {
-                    let cell = self.pattern_px;
-                    return Some(Paint::Tile(p.plain.get_or_init(|| Arc::new(RawTile { w: p.w, h: p.h, px: p.px.clone(), cell })).clone()));
-                }
-                let mut px = p.px.clone();
-                for c in px.as_chunks_mut::<4>().0 {
-                    if p.mono {
-                        let light = u16::from(c[0]) + u16::from(c[1]) + u16::from(c[2]) >= 384;
-                        let v = if light { self.text.bk_color } else { self.text.color };
-                        *c = [v[0], v[1], v[2], 255];
-                    }
-                    if self.rop2 == R2_MASKPEN {
-                        if c[..3] == [255, 255, 255] {
-                            c[3] = 0;
-                        } else if c[..3] == [0, 0, 0]
-                            && let Some(x) = self.xor_color
-                        {
-                            *c = x;
-                        }
-                    }
-                }
-                Some(Paint::Tile(Arc::new(RawTile { w: p.w, h: p.h, px, cell: self.pattern_px })))
-            }
-            _ => None,
-        }
-    }
-
-    /// Pushes device ops filled with `fill` and stroked with `stroke`: a tile fill and its outline
-    /// are two items.
-    fn push_shape(&mut self, ops: Vec<Op>, fill: Option<Paint>, stroke: Option<([u8; 4], f64)>) {
-        let even_odd = self.even_odd;
-        match fill {
-            Some(Paint::Tile(tile)) => {
-                if stroke.is_some() {
-                    self.push(Raw::Pattern { ops: ops.clone(), even_odd, tile });
-                    self.push(Raw::Path { ops, fill: None, stroke, even_odd });
-                } else {
-                    self.push(Raw::Pattern { ops, even_odd, tile });
-                }
-            }
-            Some(Paint::Solid(c)) => self.push(Raw::Path { ops, fill: Some(c), stroke, even_odd }),
-            None if stroke.is_some() => self.push(Raw::Path { ops, fill: None, stroke, even_odd }),
-            None => {}
-        }
-    }
-
-    /// Whether the mix mode suppresses drawing: R2_NOP draws nothing, and R2_XORPEN shapes only
-    /// remember their fill colour (an XOR pair cancels; the see-through shadow idiom draws its
-    /// pattern in that colour).
-    fn mix_skips(&mut self, fill: bool) -> bool {
-        match self.rop2 {
-            R2_NOP => true,
-            R2_XORPEN => {
-                if fill && self.brush.style == BS_SOLID {
-                    self.xor_color = Some(self.brush.color);
-                }
-                true
-            }
-            _ => false,
-        }
-    }
-
-    fn stroke_pen(&self) -> Option<([u8; 4], f64)> {
-        if (self.pen.style & PS_STYLE_MASK) == PS_NULL {
-            return None;
-        }
-        // A cosmetic pen (width 0) stays 0: the renderers draw that as a hairline.
-        let w = if self.pen.width == 0.0 { 0.0 } else { self.pen.width.abs() * self.map.scale() };
-        Some((self.pen.color, w))
-    }
-
-    fn push_path_ops(&mut self, ops: impl IntoIterator<Item = Op>) {
-        for op in ops {
-            if self.path.len() >= MAX_PATH_OPS {
-                return;
-            }
-            self.path.push(op);
-        }
-    }
-
-    /// Draws logical-space ops with the current pen (`stroke`) and brush (`fill`), or appends them to
-    /// the open path bracket, where fill and stroke wait for FILLPATH/STROKEPATH.
-    pub fn shape(&mut self, ops: &[Op], fill: bool, stroke: bool) {
-        let dev: Vec<Op> = ops.iter().map(|o| self.map_op(*o)).collect();
-        if self.in_path {
-            return self.push_path_ops(dev);
-        }
-        if self.mix_skips(fill) || dev.len() < 2 {
-            return;
-        }
-        let fill = if fill { self.fill_paint() } else { None };
-        let stroke = if stroke { self.stroke_pen() } else { None };
-        self.push_shape(dev, fill, stroke);
-    }
-
-    pub fn move_to(&mut self, p: P) {
-        if self.in_path {
-            self.push_path_ops([Op::M(self.map.device(p))]);
-        }
-        self.pos = p;
-    }
-
-    /// LINETO from the current point, then moves the current point to `p`.
-    pub fn line_to(&mut self, p: P) {
-        self.line_chain(&[p], false, true);
-    }
-
-    /// Lines from the current point through `pts` (POLYLINETO), or a polyline from the current point.
-    pub fn line_chain(&mut self, pts: &[P], fill: bool, stroke: bool) {
-        // Inside an open bracket the path already ends at the current point, so no MoveTo is needed.
-        let mut ops = if self.in_path && !self.path.is_empty() { Vec::new() } else { vec![Op::M(self.pos)] };
-        ops.extend(pts.iter().map(|p| Op::L(*p)));
-        if let Some(last) = pts.last() {
-            self.pos = *last;
-        }
-        self.shape(&ops, fill, stroke);
-    }
-
-    /// POLYBEZIER: cubic segments that start a new figure at `from`. The current point is unchanged.
-    pub fn bezier(&mut self, from: P, pts: &[P]) {
-        let mut ops = vec![Op::M(from)];
-        ops.extend(cubics(pts));
-        self.shape(&ops, false, true);
-    }
-
-    /// POLYBEZIERTO: cubic segments from the current point through groups of three control or end
-    /// points; the current point moves to the last point. Inside an open bracket the path already
-    /// ends at the current point, so no MoveTo is needed.
-    pub fn bezier_to(&mut self, pts: &[P]) {
-        let mut ops = if self.in_path && !self.path.is_empty() { Vec::new() } else { vec![Op::M(self.pos)] };
-        ops.extend(cubics(pts));
-        if let Some(last) = pts.last() {
-            self.pos = *last;
-        }
-        self.shape(&ops, false, true);
-    }
-
-    pub fn poly(&mut self, pts: &[P], close: bool, fill: bool, stroke: bool) {
-        let Some(first) = pts.first() else { return };
-        let mut ops = vec![Op::M(*first)];
-        ops.extend(pts.iter().skip(1).map(|p| Op::L(*p)));
-        if close {
-            ops.push(Op::Z);
-        }
-        self.shape(&ops, fill, stroke);
-    }
-
-    pub fn begin_path(&mut self) {
-        self.in_path = true;
-        self.path.clear();
-    }
-
-    pub fn end_path(&mut self) {
-        self.in_path = false;
-    }
-
-    pub fn close_figure(&mut self) {
-        if self.in_path {
-            self.push_path_ops([Op::Z]);
-        }
-    }
-
-    /// FILLPATH, STROKEPATH and STROKEANDFILLPATH: paints the bracketed path and empties it.
-    pub fn paint_path(&mut self, fill: bool, stroke: bool) {
-        let ops = std::mem::take(&mut self.path);
-        if self.mix_skips(fill) || ops.len() < 2 {
-            return;
-        }
-        let fill = if fill { self.fill_paint() } else { None };
-        let stroke = if stroke { self.stroke_pen() } else { None };
-        self.push_shape(ops, fill, stroke);
-    }
-
-    /// Fills a logical rectangle `[l, t, r, b]` with the current brush (PATBLT, PATCOPY blits).
-    pub fn fill_brush_rect(&mut self, [l, t, r, b]: [f64; 4]) {
-        if self.mix_skips(true) {
-            return;
-        }
-        let fill = self.fill_paint();
-        let dev: Vec<Op> = crate::geom::rect(l, t, r, b).iter().map(|o| self.map_op(*o)).collect();
-        self.push_shape(dev, fill, None);
-    }
-
-    /// Fills a logical rectangle `[l, t, r, b]` with a solid colour (ROP fills such as BLACKNESS).
-    pub fn fill_rect_with(&mut self, [l, t, r, b]: [f64; 4], color: [u8; 4]) {
-        let dev: Vec<Op> = crate::geom::rect(l, t, r, b).iter().map(|o| self.map_op(*o)).collect();
-        self.push(Raw::Path { ops: dev, fill: Some(color), stroke: None, even_odd: true });
-    }
-
-    /// Whether a raster operation draws without a source bitmap (PATCOPY, BLACKNESS, WHITENESS).
-    pub fn sourceless(rop: u32) -> bool {
-        matches!(rop, PATCOPY | BLACKNESS | WHITENESS)
-    }
-
-    /// Fills a logical rectangle `[x, y, w, h]` for a source-less raster operation. PATCOPY uses the
-    /// brush (when solid); the others fill black or white. Other operations are not handled here.
-    pub fn fill_rop(&mut self, [x, y, w, h]: [f64; 4], rop: u32) {
-        let rect = [x, y, x + w, y + h];
-        match rop {
-            PATCOPY => self.fill_brush_rect(rect),
-            BLACKNESS => self.fill_rect_with(rect, [0, 0, 0, 255]),
-            WHITENESS => self.fill_rect_with(rect, [255, 255, 255, 255]),
-            _ => {}
-        }
-    }
-
-    /// Draws `text` (one `dx` advance per character, or none) with the current font, colours and
-    /// alignment. The reference point is `at`, or the current position under TA_UPDATECP (which
-    /// then moves past the string). `rect` (logical `[l, t, r, b]`) is filled with the background
-    /// colour under ETO_OPAQUE and clips the text under ETO_CLIPPED. Text ignores the mix mode, as
-    /// GDI's does.
-    pub fn text(&mut self, at: P, text: String, dx: Vec<f32>, options: u32, rect: Option<[f64; 4]>) {
-        if let (true, Some(r)) = (options & ETO_OPAQUE != 0, rect) {
-            self.fill_rect_with(r, self.text.bk_color);
-        }
-        let lf = self.text.font.as_deref().cloned().unwrap_or_default();
-        let update = self.text.align & TA_UPDATECP != 0;
-        let origin = if update { self.pos } else { at };
-        let (h_align, v_align) = align(self.text.align);
-        let o = self.map.device(origin);
-        let ux = self.map.device((origin.0 + 1.0, origin.1));
-        let uy = self.map.device((origin.0, origin.1 + 1.0));
-        let (ux, uy) = ((ux.0 - o.0, ux.1 - o.1), (uy.0 - o.0, uy.1 - o.1));
-        if update {
-            // The current position moves along the baseline past the string (back past it when
-            // right-aligned). Without a dx array the advance is estimated from the height.
-            let adv: f64 = if dx.is_empty() {
-                f64::from(lf.font.height.abs().max(1.0)) * 0.5 * text.chars().count() as f64
-            } else {
-                dx.iter().map(|d| f64::from(*d)).sum()
-            };
-            let adv = match h_align {
-                crate::HAlign::Left => adv,
-                crate::HAlign::Right => -adv,
-                crate::HAlign::Center => 0.0,
-            };
-            let theta = (lf.escapement / 10.0).to_radians();
-            let y_sign = if uy.1 < 0.0 { 1.0 } else { -1.0 };
-            let p = (origin.0 + adv * theta.cos(), origin.1 + adv * theta.sin() * y_sign);
-            if p.0.is_finite() && p.1.is_finite() {
-                self.pos = p;
-            }
-        }
-        let (sx, sy) = (ux.0.hypot(ux.1), uy.0.hypot(uy.1));
-        let drawable = !text.is_empty() && [sx, sy, o.0, o.1].iter().all(|v| v.is_finite()) && sx > 0.0 && sy > 0.0;
-        if !drawable {
-            return;
-        }
-        // The baseline runs along the device direction of the logical x axis (rotated by a world
-        // transform; a mirroring mapping does not mirror glyphs), turned counter-clockwise by the
-        // escapement.
-        let det = ux.0 * uy.1 - ux.1 * uy.0;
-        let phi = if det > 0.0 { ux.1.atan2(ux.0) } else { ux.1.atan2(ux.0.abs()) };
-        let a = phi - (lf.escapement / 10.0).to_radians();
-        let (c, s) = (a.cos(), a.sin());
-        let clip = match (options & ETO_CLIPPED != 0, rect) {
-            (true, Some([l, t, r, b])) => {
-                let (p, q) = (self.map.device((l, t)), self.map.device((r, b)));
-                Some([p.0.min(q.0) as f32, p.1.min(q.1) as f32, p.0.max(q.0) as f32, p.1.max(q.1) as f32])
-            }
-            _ => None,
-        };
-        self.push(Raw::Text(Box::new(Text {
-            transform: [sx * c, sx * s, -sy * s, sy * c, o.0, o.1],
-            text,
-            dx,
-            font: lf.font,
-            color: self.text.color,
-            background: self.text.bk_opaque.then_some(self.text.bk_color),
-            h_align,
-            v_align,
-            clip,
-        })));
-    }
-
-    /// A bitmap stretched into a logical rectangle `[x, y, w, h]`. A negative extent mirrors the
-    /// bitmap, as the mapping does.
-    pub fn bitmap(&mut self, rect: [f64; 4], mut img: Rgba) {
-        let [x, y, w, h] = rect;
-        let a = self.map.device((x, y));
-        let b = self.map.device((x + w, y + h));
-        crate::dib::flip(&mut img, a.0 > b.0, a.1 > b.1);
-        let dev = [a.0.min(b.0), a.1.min(b.1), (b.0 - a.0).abs(), (b.1 - a.1).abs()];
-        self.push(Raw::Bitmap { rect: dev, img });
-    }
-}
-
-/// An 8×8 hatch tile (HS_HORIZONTAL, HS_VERTICAL, HS_FDIAGONAL, HS_BDIAGONAL, HS_CROSS,
-/// HS_DIAGCROSS): one-pixel lines in `fg` over `bg`, or over nothing when the background is
-/// transparent. None for an unknown style.
-pub(crate) fn hatch_tile(style: u32, fg: [u8; 4], bg: Option<[u8; 4]>) -> Option<Vec<u8>> {
-    if style > 5 {
-        return None;
-    }
-    let mut px = Vec::with_capacity(8 * 8 * 4);
-    for y in 0..8u32 {
-        for x in 0..8u32 {
-            let (h, v, f, b) = (y == 7, x == 7, x == y, x + y == 7);
-            let on = match style {
-                0 => h,
-                1 => v,
-                2 => f,
-                3 => b,
-                4 => h || v,
-                _ => f || b,
-            };
-            px.extend(if on { fg } else { bg.unwrap_or([0, 0, 0, 0]) });
-        }
-    }
-    Some(px)
-}
-
-/// Cubic segments from groups of three points (control, control, end). A trailing partial group is
-/// dropped.
-fn cubics(pts: &[P]) -> Vec<Op> {
-    let mut ops = Vec::with_capacity(pts.len() / 3);
-    let mut it = pts.iter().copied();
-    while let (Some(a), Some(b), Some(e)) = (it.next(), it.next(), it.next()) {
-        ops.push(Op::C(a, b, e));
-    }
-    ops
-}

crates/metafile/src/dib.rs

@@ -1,259 +0,0 @@
-//! Device-independent bitmaps. BITMAPINFOHEADER DIBs at 1/4/8/16/24/32 bpp with BI_RGB or BI_BITFIELDS
-//! decode to RGBA8 rows, top-down. Compressed (RLE, JPEG, PNG) and V4/V5-only features are not decoded.
-
-use crate::{MAX_PIXELS, bytes::Bytes};
-
-const BI_RGB: u32 = 0;
-const BI_BITFIELDS: u32 = 3;
-/// Most palette entries a DIB can carry (the colour table never exceeds 2^8).
-const MAX_PALETTE: usize = 256;
-const ROP_SRCAND: u32 = 0x0088_00C6;
-const ROP_SRCPAINT: u32 = 0x00EE_0086;
-const ROP_SRCINVERT: u32 = 0x0066_0046;
-
-/// A decoded picture. `bottom_up` records the DIB's native row order, which source rectangles use.
-pub(crate) struct Rgba {
-    pub w: usize,
-    pub h: usize,
-    pub bottom_up: bool,
-    pub px: Vec<u8>,
-}
-
-/// How a decoded bitmap combines with the destination.
-#[derive(Clone, Copy)]
-pub(crate) enum Blend {
-    /// A raster operation (BITBLT, STRETCHDIB and friends).
-    Rop(u32),
-    /// EMR_ALPHABLEND: a constant alpha (0..=255), times the per-pixel alpha when `per_pixel` is set
-    /// (AC_SRC_ALPHA: the source colours are premultiplied by it).
-    Alpha { constant: u8, per_pixel: bool },
-}
-
-impl Blend {
-    /// Whether the decoder must keep the 32-bit alpha byte of each pixel.
-    pub fn per_pixel(self) -> bool {
-        matches!(self, Blend::Alpha { per_pixel: true, .. })
-    }
-}
-
-struct Header {
-    w: usize,
-    h: usize,
-    top_down: bool,
-    bpp: usize,
-    masks: [u32; 3],
-    pal_off: usize,
-    pal_n: usize,
-}
-
-impl Header {
-    fn read(info: Bytes) -> Option<Header> {
-        let size = info.u32(0)? as usize;
-        let w = info.i32(4)?;
-        let h = info.i32(8)?;
-        let bpp = info.u16(14)? as usize;
-        let comp = info.u32(16)?;
-        let clr_used = info.u32(32)? as usize;
-        if size < 40 || w <= 0 || h == 0 || !matches!(bpp, 1 | 4 | 8 | 16 | 24 | 32) || !matches!(comp, BI_RGB | BI_BITFIELDS) {
-            return None;
-        }
-        let masks = if comp == BI_BITFIELDS {
-            [info.u32(40)?, info.u32(44)?, info.u32(48)?]
-        } else if bpp == 16 {
-            [0x7C00, 0x03E0, 0x001F]
-        } else {
-            [0xFF_0000, 0xFF00, 0xFF]
-        };
-        let masks_len = if comp == BI_BITFIELDS && size == 40 { 12 } else { 0 };
-        let pal_off = size.checked_add(masks_len)?;
-        // Indexed formats take 2^bpp entries when clrUsed is 0. Deeper formats carry only the
-        // entries clrUsed names (WMF DIBs can have them), still capped.
-        let pal_n = match (bpp <= 8, clr_used) {
-            (true, 0) => 1usize << bpp,
-            (true, n) => n.min(1usize << bpp),
-            (false, n) => n.min(MAX_PALETTE),
-        };
-        Some(Header { w: w as usize, h: h.unsigned_abs() as usize, top_down: h < 0, bpp, masks, pal_off, pal_n })
-    }
-}
-
-/// Byte length of the info part (header, masks, palette) of a DIB, so the pixel bits follow it.
-pub(crate) fn info_len(dib: Bytes) -> Option<usize> {
-    let h = Header::read(dib)?;
-    h.pal_off.checked_add(h.pal_n.checked_mul(4)?)
-}
-
-/// Decodes a DIB given as its info part (header plus masks and palette) and its pixel bits. The
-/// 32-bit alpha byte is kept only when `keep_alpha` is set (per-pixel alpha blends); otherwise pixels
-/// are opaque.
-pub(crate) fn decode(info: Bytes, bits: Bytes, keep_alpha: bool) -> Option<Rgba> {
-    let hd = Header::read(info)?;
-    let pixels = hd.w.checked_mul(hd.h)?;
-    if pixels == 0 || pixels > MAX_PIXELS {
-        return None;
-    }
-    let stride = hd.w.checked_mul(hd.bpp)?.checked_add(31)? / 32 * 4;
-    let data = bits.slice(0, stride.checked_mul(hd.h)?)?;
-    let pal = info.slice(hd.pal_off, hd.pal_n * 4)?;
-    let mut px = vec![0u8; pixels * 4];
-    for y in 0..hd.h {
-        let src_row = if hd.top_down { y } else { hd.h - 1 - y };
-        let row = src_row * stride;
-        for x in 0..hd.w {
-            let p = pixel(data, row, x, &hd, pal, keep_alpha)?;
-            let o = (y * hd.w + x) * 4;
-            px.get_mut(o..o + 4)?.copy_from_slice(&p);
-        }
-    }
-    Some(Rgba { w: hd.w, h: hd.h, bottom_up: !hd.top_down, px })
-}
-
-fn pixel(data: &[u8], row: usize, x: usize, hd: &Header, pal: &[u8], keep_alpha: bool) -> Option<[u8; 4]> {
-    let [m_r, m_g, m_b] = hd.masks;
-    let [r, g, b] = match hd.bpp {
-        1 => {
-            let b = *data.get(row + x / 8)?;
-            palette(pal, usize::from((b >> (7 - x % 8)) & 1))
-        }
-        4 => {
-            let b = *data.get(row + x / 2)?;
-            palette(pal, usize::from(if x.is_multiple_of(2) { b >> 4 } else { b & 0x0F }))
-        }
-        8 => palette(pal, usize::from(*data.get(row + x)?)),
-        24 => {
-            let [b, g, r] = data.get(row + x * 3..row + x * 3 + 3)?.try_into().ok()?;
-            [r, g, b]
-        }
-        16 => {
-            let o = row + x * 2;
-            let v = u32::from(u16::from_le_bytes(data.get(o..o + 2)?.try_into().ok()?));
-            [field(v, m_r), field(v, m_g), field(v, m_b)]
-        }
-        _ => {
-            let o = row + x * 4;
-            let v = u32::from_le_bytes(data.get(o..o + 4)?.try_into().ok()?);
-            let a = if keep_alpha { (v >> 24) as u8 } else { 255 };
-            return Some([field(v, m_r), field(v, m_g), field(v, m_b), a]);
-        }
-    };
-    Some([r, g, b, 255])
-}
-
-/// Palette entries are BGRX quads; an index past the table reads as black rather than failing the image.
-fn palette(pal: &[u8], i: usize) -> [u8; 3] {
-    pal.get(i * 4..i * 4 + 4).and_then(|c| <[u8; 4]>::try_from(c).ok()).map_or([0, 0, 0], |c| [c[2], c[1], c[0]])
-}
-
-/// Extracts one channel from a masked pixel value and scales it to 8 bits.
-fn field(v: u32, mask: u32) -> u8 {
-    if mask == 0 {
-        return 0;
-    }
-    let shift = mask.trailing_zeros();
-    let max = u64::from(mask >> shift);
-    let val = u64::from((v & mask) >> shift);
-    ((val * 255 + max / 2) / max) as u8
-}
-
-/// Clips a source rectangle `src` = `[x, y, w, h]` to the bitmap and returns the cropped pixels (top-down)
-/// with the part of the destination `dst` that they fill. `src` is in DIB pixel coordinates (`y` counted
-/// from the DIB's origin, so bottom-up images count from the bottom); a non-positive source size means the
-/// whole bitmap. Clipping shrinks the destination by the same ratio and shifts it by the clipped-off part,
-/// so the rest of the image keeps its place. A negative destination extent is kept (the caller mirrors).
-pub(crate) fn clip_blit(img: &Rgba, src: [i64; 4], dst: [f64; 4]) -> Option<(Rgba, [f64; 4])> {
-    let (iw, ih) = (img.w as i64, img.h as i64);
-    let [sx, sy, sw, sh] = if src[2] > 0 && src[3] > 0 { src } else { [0, 0, iw, ih] };
-    // The request's top row in top-down order.
-    let top = if img.bottom_up { ih.saturating_sub(sy).saturating_sub(sh) } else { sy };
-    let (x0, x1) = (sx.max(0), sx.saturating_add(sw).min(iw));
-    let (r0, r1) = (top.max(0), top.saturating_add(sh).min(ih));
-    if x1 <= x0 || r1 <= r0 {
-        return None;
-    }
-    let (kx, ky) = (dst[2] / sw as f64, dst[3] / sh as f64);
-    let out = [dst[0] + (x0 - sx) as f64 * kx, dst[1] + (r0 - top) as f64 * ky, (x1 - x0) as f64 * kx, (r1 - r0) as f64 * ky];
-    let (x0, x1, r0, r1) = (x0 as usize, x1 as usize, r0 as usize, r1 as usize);
-    let (ow, oh) = (x1 - x0, r1 - r0);
-    let mut px = Vec::with_capacity(ow * oh * 4);
-    for row in r0..r1 {
-        let s = (row * img.w + x0) * 4;
-        px.extend_from_slice(img.px.get(s..s + ow * 4)?);
-    }
-    Some((Rgba { w: ow, h: oh, bottom_up: false, px }, out))
-}
-
-/// Applies a blend to decoded pixels before they are drawn. The picture has no destination pixels, so
-/// raster operations are drawn as they look over white paper: SRCAND (destination AND source) leaves
-/// white source pixels out and draws the rest; SRCPAINT and SRCINVERT leave black ones out. Other
-/// operations draw the source as copied. Constant alpha scales every pixel's alpha, after a
-/// per-pixel (premultiplied) source is made straight.
-pub(crate) fn prepare(img: &mut Rgba, blend: Blend) {
-    match blend {
-        Blend::Rop(ROP_SRCAND) => clear_where(img, [255, 255, 255]),
-        Blend::Rop(ROP_SRCPAINT | ROP_SRCINVERT) => clear_where(img, [0, 0, 0]),
-        Blend::Rop(_) => {}
-        Blend::Alpha { constant, per_pixel } => {
-            for p in img.px.as_chunks_mut::<4>().0 {
-                if per_pixel {
-                    unpremultiply(p);
-                }
-                p[3] = (u16::from(p[3]) * u16::from(constant) / 255) as u8;
-            }
-        }
-    }
-}
-
-/// Makes the pixels of colour `rgb` transparent: where a raster operation keeps the destination.
-fn clear_where(img: &mut Rgba, rgb: [u8; 3]) {
-    for p in img.px.as_chunks_mut::<4>().0 {
-        if p[..3] == rgb {
-            p[3] = 0;
-        }
-    }
-}
-
-/// AC_SRC_ALPHA sources are premultiplied; the model holds straight RGBA, so divide the colour by the
-/// alpha (rounded, capped at 255). A transparent pixel keeps its colour bytes.
-fn unpremultiply(p: &mut [u8; 4]) {
-    let a = u32::from(p[3]);
-    if a == 0 || a == 255 {
-        return;
-    }
-    for c in &mut p[..3] {
-        *c = ((u32::from(*c) * 255 + a / 2) / a).min(255) as u8;
-    }
-}
-
-/// Mirrors a decoded image left-right and/or top-bottom. Rows come from the buffer as chunks, so a
-/// short buffer flips only the rows it has.
-pub(crate) fn flip(img: &mut Rgba, horizontal: bool, vertical: bool) {
-    let (w, h) = (img.w, img.h);
-    if w == 0 || h == 0 {
-        return;
-    }
-    let row = w * 4;
-    if horizontal {
-        for line in img.px.chunks_exact_mut(row) {
-            for x in 0..w / 2 {
-                for c in 0..4 {
-                    line.swap(x * 4 + c, (w - 1 - x) * 4 + c);
-                }
-            }
-        }
-    }
-    if vertical {
-        // Rows the buffer actually holds: a short buffer flips only those.
-        let n = h.min(img.px.len() / row);
-        for y in 0..n / 2 {
-            swap_rows(&mut img.px, y * row, (n - 1 - y) * row, row);
-        }
-    }
-}
-
-/// Swaps the `len` bytes at `a` with those at `b` (`a < b`); does nothing when either is out of range.
-fn swap_rows(px: &mut [u8], a: usize, b: usize, len: usize) {
-    let Some((head, tail)) = px.split_at_mut_checked(b) else { return };
-    if let (Some(top), Some(bottom)) = (head.get_mut(a..a.saturating_add(len)), tail.get_mut(..len)) {
-        top.swap_with_slice(bottom);
-    }
-}

crates/metafile/src/emf.rs

@@ -1,433 +0,0 @@
-//! EMF reader (MS-EMF). Records are (type, size in bytes) followed by a payload; offsets inside a
-//! record (bitmap info and bits) are relative to the record start, so each handler reads the record slice.
-
-use std::sync::Arc;
-
-use crate::bytes::Bytes;
-use crate::canvas::{BS_HATCHED, BS_NULL, Brush, Canvas, LogFont, Obj, PS_NULL, PS_STYLE_MASK, Pen, Xform, colorref};
-use crate::dib::{self, Blend};
-use crate::geom::{self, ArcKind, P};
-use crate::text::{ETO_GLYPH_INDEX, ETO_PDY, Font, MAX_CHARS, decode_bytes, decode_utf16};
-use crate::{Error, Frame, MAX_PATH_OPS};
-
-/// ExtTextOut options: no rectangle in the record (EMR_SMALLTEXTOUT, EmrText), and 8-bit
-/// characters (EMR_SMALLTEXTOUT).
-const ETO_NO_RECT: u32 = 0x0100;
-const ETO_SMALL_CHARS: u32 = 0x0200;
-
-const EMF_SIGNATURE: u32 = 0x464D_4520;
-/// Hundredths of a millimetre to points.
-const HMM_TO_PT: f64 = 72.0 / 2540.0;
-/// SRCCOPY, the plain copy of a bitmap.
-const SRCCOPY: u32 = 0x00CC_0020;
-/// LogPenEx pen type bits; PS_COSMETIC pens are one device pixel wide.
-const PS_TYPE_MASK: u32 = 0x000F_0000;
-const PS_COSMETIC: u32 = 0;
-
-pub(crate) fn is_emf(b: Bytes) -> bool {
-    b.u32(0) == Some(1) && b.u32(40) == Some(EMF_SIGNATURE)
-}
-
-/// The picture frame: `rclFrame` (0.01 mm) mapped to device units through `szlDevice` and
-/// `szlMillimeters`, sized in points. Without a usable frame, the device bounds stand in (1 unit = 1 point).
-pub(crate) fn parse(input: Bytes) -> Result<(Canvas, Option<Frame>), Error> {
-    if !is_emf(input) {
-        return Err(Error::BadHeader);
-    }
-    let hsize = input.u32(4).ok_or(Error::BadHeader)? as usize;
-    let bounds = rect32(input, 8).ok_or(Error::BadHeader)?;
-    let [l, t, r, b] = bounds;
-    let frame = frame_from_header(input).or_else(|| (r > l && b > t).then_some(Frame { rect: [l, t, r - l, b - t], size: None }));
-    let mut cv = Canvas::new();
-    if let Some(px_mm) = device_px_per_mm(input) {
-        cv.set_device_mm(px_mm);
-    }
-    let mut parsed = 0usize;
-    let mut pos = hsize.max(88);
-    while !cv.full() {
-        let (Some(typ), Some(size)) = (input.u32(pos), pos.checked_add(4).and_then(|o| input.u32(o))) else { break };
-        let size = size as usize;
-        if size < 8 || !size.is_multiple_of(4) {
-            break;
-        }
-        let Some(rec) = input.slice(pos, size) else { break };
-        if typ == 14 {
-            break;
-        }
-        record(&mut cv, typ, Bytes(rec));
-        parsed += 1;
-        let Some(next) = pos.checked_add(size) else { break };
-        pos = next;
-    }
-    if parsed == 0 {
-        return Err(Error::NoRecords);
-    }
-    Ok((cv, frame))
-}
-
-/// Device pixels per millimetre on each axis, from `szlDevice` (72) and `szlMillimeters` (80).
-fn device_px_per_mm(input: Bytes) -> Option<(f64, f64)> {
-    let (dw, dh) = (input.i32(72)?, input.i32(76)?);
-    let (mw, mh) = (input.i32(80)?, input.i32(84)?);
-    (dw > 0 && dh > 0 && mw > 0 && mh > 0).then(|| (f64::from(dw) / f64::from(mw), f64::from(dh) / f64::from(mh)))
-}
-
-/// The frame from `rclFrame` (offset 24), `szlDevice` (72) and `szlMillimeters` (80) in the header.
-fn frame_from_header(input: Bytes) -> Option<Frame> {
-    let [fl, ft, fr, fb] = rect32(input, 24)?;
-    if fr <= fl || fb <= ft {
-        return None;
-    }
-    // Device units per hundredth of a millimetre.
-    let (px_mm_x, px_mm_y) = device_px_per_mm(input)?;
-    let (sx, sy) = (px_mm_x / 100.0, px_mm_y / 100.0);
-    let rect = [fl * sx, ft * sy, (fr - fl) * sx, (fb - ft) * sy];
-    Some(Frame { rect, size: Some(((fr - fl) * HMM_TO_PT, (fb - ft) * HMM_TO_PT)) })
-}
-
-fn record(cv: &mut Canvas, typ: u32, r: Bytes) {
-    if cv.full() {
-        return;
-    }
-    let _ = match typ {
-        9 => xy32(r, 8).map(|p| cv.set_window_ext(p)),
-        10 => xy32(r, 8).map(|p| cv.set_window_org(p)),
-        11 => xy32(r, 8).map(|p| cv.set_viewport_ext(p)),
-        12 => xy32(r, 8).map(|p| cv.set_viewport_org(p)),
-        17 => r.u32(8).map(|m| cv.set_map_mode(m)),
-        19 => r.u32(8).map(|m| cv.set_polyfill(m)),
-        20 => r.u32(8).map(|m| cv.set_rop2(m)),
-        33 => {
-            cv.save_dc();
-            Some(())
-        }
-        34 => r.i32(8).map(|n| cv.restore_dc(n)),
-        35 => xform(r, 8).map(|x| cv.modify_world(x, 4)),
-        36 => xform(r, 8).zip(r.u32(32)).map(|(x, m)| cv.modify_world(x, m)),
-        37 => r.u32(8).map(|i| cv.select(i)),
-        38 => create_pen(cv, r),
-        95 => create_ext_pen(cv, r),
-        39 => create_brush(cv, r),
-        93 | 94 => create_dib_brush(cv, r, typ == 93),
-        82 => create_font(cv, r),
-        18 => r.u32(8).map(|m| cv.set_bk_mode(m)),
-        22 => r.u32(8).map(|a| cv.set_text_align(a)),
-        24 => r.u32(8).map(|c| cv.set_text_color(c)),
-        25 => r.u32(8).map(|c| cv.set_bk_color(c)),
-        83 | 84 => ext_text_out(cv, r, typ == 84),
-        108 => small_text_out(cv, r),
-        40 => r.u32(8).map(|i| cv.delete_object(i)),
-        27 => xy32(r, 8).map(|p| cv.move_to(p)),
-        54 => xy32(r, 8).map(|p| cv.line_to(p)),
-        42 => rect32(r, 8).map(|[l, t, rr, b]| cv.shape(&geom::ellipse(l, t, rr, b), true, true)),
-        43 => rect32(r, 8).map(|[l, t, rr, b]| cv.shape(&geom::rect(l, t, rr, b), true, true)),
-        44 => {
-            let (cw, ch) = (r.i32(24), r.i32(28));
-            let (Some(cw), Some(ch)) = (cw, ch) else { return };
-            rect32(r, 8).map(|[l, t, rr, b]| {
-                cv.shape(&geom::round_rect(l, t, rr, b, f64::from(cw), f64::from(ch)), true, true);
-            })
-        }
-        45..=47 => arc32(r).map(|(bounds, s, e)| {
-            let kind = match typ {
-                45 => ArcKind::Arc,
-                46 => ArcKind::Chord,
-                _ => ArcKind::Pie,
-            };
-            let [l, t, rr, b] = bounds;
-            cv.shape(&geom::arc_shape(l, t, rr, b, s, e, kind), kind != ArcKind::Arc, true);
-        }),
-        4 | 87 => counted(r, typ == 4).map(|pts| cv.poly(&pts, false, false, true)),
-        3 | 86 => counted(r, typ == 3).map(|pts| cv.poly(&pts, true, true, true)),
-        6 | 89 => counted(r, typ == 6).map(|pts| cv.line_chain(&pts, false, true)),
-        // POLYBEZIER starts its own figure at the first point and leaves the current point alone;
-        // POLYBEZIERTO continues from the current point.
-        2 | 85 => counted(r, typ == 2).and_then(|pts| {
-            let from = *pts.first()?;
-            cv.bezier(from, pts.get(1..)?);
-            Some(())
-        }),
-        5 | 88 => counted(r, typ == 5).map(|pts| cv.bezier_to(&pts)),
-        7 | 90 => poly_groups(r, typ == 7).map(|(counts, pts)| cv.shape(&geom::subpaths(&pts, &counts, false), false, true)),
-        8 | 91 => poly_groups(r, typ == 8).map(|(counts, pts)| cv.shape(&geom::subpaths(&pts, &counts, true), true, true)),
-        59 => {
-            cv.begin_path();
-            Some(())
-        }
-        60 => {
-            cv.end_path();
-            Some(())
-        }
-        61 => {
-            cv.close_figure();
-            Some(())
-        }
-        62 => {
-            cv.paint_path(true, false);
-            Some(())
-        }
-        63 => {
-            cv.paint_path(true, true);
-            Some(())
-        }
-        64 => {
-            cv.paint_path(false, true);
-            Some(())
-        }
-        76 | 77 => bitblt(cv, r, typ == 77),
-        80 => set_dibits(cv, r),
-        81 => stretch_dibits(cv, r),
-        114 => alphablend(cv, r),
-        _ => Some(()),
-    };
-}
-
-/// Two little-endian i32 values at `off`, as a point.
-fn xy32(r: Bytes, off: usize) -> Option<P> {
-    Some((f64::from(r.i32(off)?), f64::from(r.i32(off + 4)?)))
-}
-
-/// RECTL (left, top, right, bottom) as i32 values widened to f64.
-fn rect32(r: Bytes, off: usize) -> Option<[f64; 4]> {
-    Some([f64::from(r.i32(off)?), f64::from(r.i32(off + 4)?), f64::from(r.i32(off + 8)?), f64::from(r.i32(off + 12)?)])
-}
-
-/// An i32 field as f64; 0 past the end.
-fn i32s(r: Bytes, off: usize) -> f64 {
-    r.i32(off).map_or(0.0, f64::from)
-}
-
-/// XFORM: six f32 values in M11, M12, M21, M22, Dx, Dy order.
-fn xform(r: Bytes, off: usize) -> Option<Xform> {
-    let mut x = [0.0f64; 6];
-    for (i, v) in x.iter_mut().enumerate() {
-        *v = f64::from(r.f32(off + i * 4)?);
-    }
-    Some(x)
-}
-
-/// ARC, CHORD, PIE: bounds at 8, start point at 24, end point at 32.
-fn arc32(r: Bytes) -> Option<([f64; 4], P, P)> {
-    Some((rect32(r, 8)?, xy32(r, 24)?, xy32(r, 32)?))
-}
-
-/// A point count from a record, rejected when it exceeds the path budget (before any allocation).
-fn budget(n: u32) -> Option<usize> {
-    let n = n as usize;
-    (n <= MAX_PATH_OPS).then_some(n)
-}
-
-/// Point count at 24, then the points (32-bit or 16-bit) at 28.
-fn counted(r: Bytes, wide: bool) -> Option<Vec<P>> {
-    let n = budget(r.u32(24)?)?;
-    r.tail(28)?.points(0, n, wide)
-}
-
-/// Subpath count at 24, total point count at 28, per-subpath counts at 32, then the points.
-fn poly_groups(r: Bytes, wide: bool) -> Option<(Vec<usize>, Vec<P>)> {
-    let n = budget(r.u32(24)?)?;
-    // The record must hold the n counts before anything is allocated for them.
-    let raw = r.slice(32, n.checked_mul(4)?)?;
-    let counts: Vec<usize> = raw.as_chunks::<4>().0.iter().map(|c| u32::from_le_bytes(*c) as usize).collect();
-    let total = counts.iter().try_fold(0usize, |a, c| a.checked_add(*c))?;
-    let total = budget(u32::try_from(total).ok()?)?;
-    let pts = r.tail(n.checked_mul(4)?.checked_add(32)?)?.points(0, total, wide)?;
-    Some((counts, pts))
-}
-
-/// EMR_CREATEPEN: handle, LogPen (style, width x/y, colour).
-fn create_pen(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let slot = r.u32(8)? as usize;
-    let style = r.u32(12)?;
-    let width = r.i32(16)?;
-    let color = r.u32(24)?;
-    cv.add_object(Some(slot), Obj::Pen(Pen { style, width: f64::from(width), color: colorref(color) }));
-    Some(())
-}
-
-/// EMR_EXTCREATEPEN: handle, bitmap offsets (unused), LogPenEx (style, width, brush style, colour).
-/// A cosmetic pen's width is in device pixels (always 1), so it is a hairline; a BS_NULL brush draws
-/// no line at all.
-fn create_ext_pen(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let slot = r.u32(8)? as usize;
-    let (style, width, brush, color) = (r.u32(28)?, r.u32(32)?, r.u32(36)?, r.u32(40)?);
-    let width = if style & PS_TYPE_MASK == PS_COSMETIC { 0.0 } else { f64::from(width) };
-    let style = if brush == BS_NULL { PS_NULL } else { style & PS_STYLE_MASK };
-    cv.add_object(Some(slot), Obj::Pen(Pen { style, width, color: colorref(color) }));
-    Some(())
-}
-
-/// EMR_CREATEBRUSHINDIRECT: handle, LogBrush32 (style, colour, hatch).
-fn create_brush(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let slot = r.u32(8)? as usize;
-    let style = r.u32(12)?;
-    let color = r.u32(16)?;
-    let mut b = Brush::new(style, colorref(color));
-    if style == BS_HATCHED {
-        b.hatch = r.u32(20).unwrap_or(0);
-    }
-    cv.add_object(Some(slot), Obj::Brush(b));
-    Some(())
-}
-
-/// EMR_CREATEDIBPATTERNBRUSHPT (94) and EMR_CREATEMONOBRUSH (93): handle, colour usage, then the
-/// bitmap info and bits as offset/size pairs. A mono brush (or one whose palette holds indices,
-/// DIB_PAL_COLORS) takes the text and background colours. An undecodable bitmap leaves the slot
-/// empty.
-fn create_dib_brush(cv: &mut Canvas, r: Bytes, mono: bool) -> Option<()> {
-    let slot = r.u32(8)? as usize;
-    let usage = r.u32(12)?;
-    let (bo, bl) = (r.u32(16)? as usize, r.u32(20)? as usize);
-    let (po, pl) = (r.u32(24)? as usize, r.u32(28)? as usize);
-    let img = dib::decode(Bytes(r.slice(bo, bl)?), Bytes(r.slice(po, pl)?), false)?;
-    let b = Brush::pattern(img, mono || usage == 1)?;
-    cv.add_object(Some(slot), Obj::Brush(b));
-    Some(())
-}
-
-/// EMR_EXTCREATEFONTINDIRECTW: handle, then a LogFont (MS-EMF 2.2.13): height, width, escapement,
-/// orientation, weight (i32 each), italic, underline, strike-out, charset and four more bytes, then
-/// the face name in 32 UTF-16 units (NUL-terminated).
-fn create_font(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let slot = r.u32(8)? as usize;
-    let height = r.i32(12)?;
-    let width = r.i32(16).unwrap_or(0);
-    let escapement = r.i32(20).unwrap_or(0);
-    let weight = r.i32(28).unwrap_or(0);
-    let byte = |o: usize| r.0.get(o).copied().unwrap_or(0);
-    let units: Vec<u16> = (0..32).map_while(|i| r.u16(40 + 2 * i)).take_while(|u| *u != 0).collect();
-    let (family, _) = decode_utf16(&units, &[]);
-    let font = Font {
-        family: family.trim().to_string(),
-        height: height as f32,
-        width: width as f32,
-        weight: weight.clamp(0, 1000) as u16,
-        italic: byte(32) != 0,
-        underline: byte(33) != 0,
-        strike: byte(34) != 0,
-        charset: byte(35),
-    };
-    cv.add_object(Some(slot), Obj::Font(Arc::new(LogFont { font, escapement: f64::from(escapement) })));
-    Some(())
-}
-
-/// The dx array at `off` for `n` characters: i32 advances, or (dx, dy) pairs under ETO_PDY (only
-/// dx is used). Empty when absent or short.
-fn dx_array(r: Bytes, off: usize, n: usize, opts: u32) -> Vec<f32> {
-    let step = if opts & ETO_PDY != 0 { 8 } else { 4 };
-    if off == 0 {
-        return Vec::new();
-    }
-    let dx: Vec<f32> = (0..n).map_while(|i| r.i32(off.checked_add(i.checked_mul(step)?)?)).map(|v| v as f32).collect();
-    if dx.len() == n { dx } else { Vec::new() }
-}
-
-/// EMR_EXTTEXTOUTA (83) and EMR_EXTTEXTOUTW (84): bounds, graphics mode and scales, then an EmrText
-/// at 36: reference point, character count, string offset, options, the rectangle (absent under
-/// ETO_NO_RECT) and the dx offset. Offsets count from the record start. Glyph-index strings name
-/// glyphs of a font the reader cannot match, so they are left out.
-fn ext_text_out(cv: &mut Canvas, r: Bytes, wide: bool) -> Option<()> {
-    let at = xy32(r, 36)?;
-    let n = (r.u32(44)? as usize).min(MAX_CHARS);
-    let off = r.u32(48)? as usize;
-    let opts = r.u32(52)?;
-    let (rect, dx_off) = if opts & ETO_NO_RECT != 0 { (None, r.u32(56)?) } else { (rect32(r, 56), r.u32(72)?) };
-    if opts & ETO_GLYPH_INDEX != 0 {
-        return None;
-    }
-    let dx = dx_array(r, dx_off as usize, n, opts);
-    let (text, dx) = if wide {
-        let raw = r.slice(off, n.checked_mul(2)?)?;
-        let units: Vec<u16> = raw.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
-        decode_utf16(&units, &dx)
-    } else {
-        decode_bytes(r.slice(off, n)?, cv.font_charset(), &dx)
-    };
-    cv.text(at, text, dx, opts, rect);
-    Some(())
-}
-
-/// EMR_SMALLTEXTOUT (MS-EMF 2.3.5.37): x, y, character count, options, graphics mode, scales, the
-/// bounds (absent under ETO_NO_RECT), then the characters: 8-bit under ETO_SMALL_CHARS, else UTF-16.
-fn small_text_out(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let at = xy32(r, 8)?;
-    let n = (r.u32(16)? as usize).min(MAX_CHARS);
-    let opts = r.u32(20)?;
-    if opts & ETO_GLYPH_INDEX != 0 {
-        return None;
-    }
-    let (rect, off) = if opts & ETO_NO_RECT != 0 { (None, 36) } else { (rect32(r, 36), 52) };
-    let (text, _) = if opts & ETO_SMALL_CHARS != 0 {
-        decode_bytes(r.slice(off, n)?, cv.font_charset(), &[])
-    } else {
-        let raw = r.slice(off, n.checked_mul(2)?)?;
-        let units: Vec<u16> = raw.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
-        decode_utf16(&units, &[])
-    };
-    cv.text(at, text, Vec::new(), opts, rect);
-    Some(())
-}
-
-/// BITBLT (76) and STRETCHBLT (77): dest at 24..40, rop at 40, source x/y at 44, bmi at 84, bits at
-/// 92; STRETCHBLT adds the source w/h at 100. A source-less rop fills the destination instead.
-fn bitblt(cv: &mut Canvas, r: Bytes, stretch: bool) -> Option<()> {
-    let dst = [i32s(r, 24), i32s(r, 28), i32s(r, 32), i32s(r, 36)];
-    let rop = r.u32(40)?;
-    if Canvas::sourceless(rop) {
-        cv.fill_rop(dst, rop);
-        return Some(());
-    }
-    let (sw, sh) = if stretch { (i32s(r, 100), i32s(r, 104)) } else { (dst[2], dst[3]) };
-    let src = [i32s(r, 44), i32s(r, 48), sw, sh];
-    blit(cv, r, dst, src, (84, 92), Blend::Rop(rop))
-}
-
-/// ALPHABLEND: laid out like STRETCHBLT, with a BLENDFUNCTION at 40. Constant alpha at 42 applies to
-/// every pixel; AlphaFormat at 43 with AC_SRC_ALPHA (1) also uses the per-pixel alpha.
-fn alphablend(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let dst = [i32s(r, 24), i32s(r, 28), i32s(r, 32), i32s(r, 36)];
-    let constant = *r.0.get(42)?;
-    let per_pixel = (*r.0.get(43)? & 0x01) != 0;
-    let src = [i32s(r, 44), i32s(r, 48), i32s(r, 100), i32s(r, 104)];
-    blit(cv, r, dst, src, (84, 92), Blend::Alpha { constant, per_pixel })
-}
-
-/// STRETCHDIBITS: dest x/y at 24, src x/y/w/h at 32..48, bmi offset/size at 48, bits at 56, rop at 68,
-/// dest w/h at 72.
-fn stretch_dibits(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let dst = [i32s(r, 24), i32s(r, 28), i32s(r, 72), i32s(r, 76)];
-    let src = [i32s(r, 32), i32s(r, 36), i32s(r, 40), i32s(r, 44)];
-    let rop = r.u32(68)?;
-    blit(cv, r, dst, src, (48, 56), Blend::Rop(rop))
-}
-
-/// SETDIBITSTODEVICE (MS-EMF 2.3.1.5): dest x/y at 24, src x/y at 32, size (cxSrc, cySrc) at 40, bmi
-/// at 48, bits at 56, start scan at 68. The image keeps its own size; the bits begin at scan line
-/// `iStartScan`, so the source y counts from there.
-fn set_dibits(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let (cx, cy) = (i32s(r, 40), i32s(r, 44));
-    if cx <= 0.0 || cy <= 0.0 {
-        return None;
-    }
-    let dst = [i32s(r, 24), i32s(r, 28), cx, cy];
-    let src = [i32s(r, 32), i32s(r, 36) - f64::from(r.u32(68)?), cx, cy];
-    blit(cv, r, dst, src, (48, 56), Blend::Rop(SRCCOPY))
-}
-
-/// Decodes the bitmap at `at` = (offset of the bmi offset/length pair, offset of the bits pair), both
-/// inside the record, and stretches the source rectangle `src` into `dst`. Both are `[x, y, w, h]`; a
-/// non-positive source size means the whole bitmap. `blend` decides how it combines.
-fn blit(cv: &mut Canvas, r: Bytes, dst: [f64; 4], src: [f64; 4], at: (usize, usize), blend: Blend) -> Option<()> {
-    let (bo, bl) = (r.u32(at.0)? as usize, r.u32(at.0 + 4)? as usize);
-    let (po, pl) = (r.u32(at.1)? as usize, r.u32(at.1 + 4)? as usize);
-    if pl == 0 {
-        return None;
-    }
-    let info = Bytes(r.slice(bo, bl)?);
-    let pixels = Bytes(r.slice(po, pl)?);
-    let mut img = dib::decode(info, pixels, blend.per_pixel())?;
-    dib::prepare(&mut img, blend);
-    let (img, dst) = dib::clip_blit(&img, src.map(|v| v as i64), dst)?;
-    cv.bitmap(dst, img);
-    Some(())
-}

crates/metafile/src/geom.rs

@@ -1,118 +0,0 @@
-//! Path operations in `f64` and the shape builders that turn WMF/EMF rectangles, ellipses and arcs
-//! into cubic Béziers (the classic 4/3·tan(Δ/4) approximation, at most 90° per piece).
-
-use std::f64::consts::{FRAC_PI_2, PI, TAU};
-
-pub(crate) type P = (f64, f64);
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub(crate) enum Op {
-    M(P),
-    L(P),
-    C(P, P, P),
-    Z,
-}
-
-pub(crate) fn rect(l: f64, t: f64, r: f64, b: f64) -> Vec<Op> {
-    vec![Op::M((l, t)), Op::L((r, t)), Op::L((r, b)), Op::L((l, b)), Op::Z]
-}
-
-/// Corner radii are half the EMF/WMF corner ellipse size, clamped so the corners never overlap.
-pub(crate) fn round_rect(l: f64, t: f64, r: f64, b: f64, ew: f64, eh: f64) -> Vec<Op> {
-    // Reversed corners (right < left, bottom < top) describe the same rectangle.
-    let (l, r) = (l.min(r), l.max(r));
-    let (t, b) = (t.min(b), t.max(b));
-    let rx = (ew / 2.0).abs().min((r - l) / 2.0);
-    let ry = (eh / 2.0).abs().min((b - t) / 2.0);
-    let mut ops = vec![Op::M((l + rx, t)), Op::L((r - rx, t))];
-    ops.extend(arc(r - rx, t + ry, rx, ry, -FRAC_PI_2, FRAC_PI_2));
-    ops.push(Op::L((r, b - ry)));
-    ops.extend(arc(r - rx, b - ry, rx, ry, 0.0, FRAC_PI_2));
-    ops.push(Op::L((l + rx, b)));
-    ops.extend(arc(l + rx, b - ry, rx, ry, FRAC_PI_2, FRAC_PI_2));
-    ops.push(Op::L((l, t + ry)));
-    ops.extend(arc(l + rx, t + ry, rx, ry, PI, FRAC_PI_2));
-    ops.push(Op::Z);
-    ops
-}
-
-pub(crate) fn ellipse(l: f64, t: f64, r: f64, b: f64) -> Vec<Op> {
-    let (cx, cy, rx, ry) = center(l, t, r, b);
-    let mut ops = vec![Op::M((cx + rx, cy))];
-    ops.extend(arc(cx, cy, rx, ry, 0.0, TAU));
-    ops.push(Op::Z);
-    ops
-}
-
-/// Which closed or open shape an ARC/CHORD/PIE record draws.
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ArcKind {
-    Arc,
-    Chord,
-    Pie,
-}
-
-/// ARC, CHORD and PIE: the arc runs counter-clockwise on screen from the start point to the end point.
-pub(crate) fn arc_shape(l: f64, t: f64, r: f64, b: f64, s: P, e: P, kind: ArcKind) -> Vec<Op> {
-    let (cx, cy, rx, ry) = center(l, t, r, b);
-    let ang = |p: P| ((p.1 - cy) / ry.max(f64::MIN_POSITIVE)).atan2((p.0 - cx) / rx.max(f64::MIN_POSITIVE));
-    let (a0, a1) = (ang(s), ang(e));
-    let mut d = (a0 - a1).rem_euclid(TAU);
-    if d < 1e-12 {
-        d = TAU;
-    }
-    let sweep = -d;
-    let start = (cx + rx * a0.cos(), cy + ry * a0.sin());
-    let mut ops = if kind == ArcKind::Pie { vec![Op::M((cx, cy)), Op::L(start)] } else { vec![Op::M(start)] };
-    ops.extend(arc(cx, cy, rx, ry, a0, sweep));
-    match kind {
-        ArcKind::Arc => {}
-        ArcKind::Chord => ops.push(Op::Z),
-        ArcKind::Pie => ops.extend([Op::L((cx, cy)), Op::Z]),
-    }
-    ops
-}
-
-fn center(l: f64, t: f64, r: f64, b: f64) -> (f64, f64, f64, f64) {
-    ((l + r) / 2.0, (t + b) / 2.0, (r - l).abs() / 2.0, (b - t).abs() / 2.0)
-}
-
-/// Cubic pieces along an ellipse from parameter `a0` over signed `sweep` radians. The current point
-/// must already be at `(cx + rx cos a0, cy + ry sin a0)`.
-fn arc(cx: f64, cy: f64, rx: f64, ry: f64, a0: f64, sweep: f64) -> Vec<Op> {
-    let n = ((sweep.abs() / FRAC_PI_2).ceil() as usize).clamp(1, 8);
-    let step = sweep / n as f64;
-    let k = 4.0 / 3.0 * (step / 4.0).tan();
-    let pt = |t: f64| (cx + rx * t.cos(), cy + ry * t.sin());
-    let mut ops = Vec::with_capacity(n);
-    for i in 0..n {
-        let t0 = a0 + step * i as f64;
-        let t1 = t0 + step;
-        let (p0, p3) = (pt(t0), pt(t1));
-        let c1 = (p0.0 - k * rx * t0.sin(), p0.1 + k * ry * t0.cos());
-        let c2 = (p3.0 + k * rx * t1.sin(), p3.1 - k * ry * t1.cos());
-        ops.push(Op::C(c1, c2, p3));
-    }
-    ops
-}
-
-/// Consecutive subpaths: `counts[i]` points each, taken in order from `pts`. Counts that run past the
-/// point list are cut short rather than failing the whole record.
-pub(crate) fn subpaths(pts: &[P], counts: &[usize], close: bool) -> Vec<Op> {
-    let mut ops = Vec::with_capacity(pts.len() + counts.len());
-    let mut at = 0usize;
-    for &c in counts {
-        let end = at.saturating_add(c).min(pts.len());
-        let Some((first, rest)) = pts.get(at..end).and_then(|s| s.split_first()) else {
-            at = end;
-            continue;
-        };
-        ops.push(Op::M(*first));
-        ops.extend(rest.iter().map(|p| Op::L(*p)));
-        if close {
-            ops.push(Op::Z);
-        }
-        at = end;
-    }
-    ops
-}

crates/metafile/src/lib.rs

@@ -1,275 +0,0 @@
-//! DeckCraft metafiles (ported from WordCraft's `crates/metafile`): reads Windows Metafiles (WMF)
-//! and Enhanced Metafiles (EMF) into a neutral vector model of filled and stroked paths, pattern
-//! fills, RGBA bitmaps and text strings, in a picture frame with y down.
-//!
-//! Text stays font-agnostic: a [`Text`] item names the font the file asks for and carries the
-//! string, its advances and alignment; the renderer resolves the font and draws the glyphs.
-//!
-//! The reader is pure Rust over byte slices (no file system), so it builds for wasm. Every read is
-//! bounds-checked and every count is capped; hostile input yields a shorter picture or an [`Error`],
-//! never a panic.
-//!
-//! Records follow MS-WMF and MS-EMF. Records outside the supported set are skipped silently.
-#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
-#![forbid(unsafe_code)]
-
-mod bytes;
-mod canvas;
-mod dib;
-mod emf;
-mod geom;
-mod place;
-mod text;
-mod wmf;
-
-#[cfg(test)]
-mod tests;
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use bytes::Bytes;
-use canvas::Raw;
-use geom::{Op, P};
-pub use place::{MAX_BITMAP_SIDE, PlacedItem};
-pub use text::{Font, HAlign, SYMBOL_CHARSET, Text, VAlign};
-
-/// Items kept from one file. Past the cap the parse stops and keeps what it has.
-pub(crate) const MAX_ITEMS: usize = 200_000;
-/// Object table slots (WMF handles, EMF object indices).
-pub(crate) const MAX_OBJECTS: usize = 4096;
-/// Largest bitmap in pixels (about 40 megapixels, 160 MB of RGBA).
-pub(crate) const MAX_PIXELS: usize = 40_000_000;
-/// DC save-stack depth.
-pub(crate) const MAX_STACK: usize = 1024;
-/// Points in one open path bracket.
-pub(crate) const MAX_PATH_OPS: usize = 2_000_000;
-/// Bytes of path ops and pixels kept from one file (about 256 MB).
-pub(crate) const MAX_BYTES: usize = 256 * 1024 * 1024;
-
-/// A parsed metafile. Items use coordinates in `0..width` and `0..height`, y down.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Picture {
-    /// Size of the drawing in its own units: points for placeable WMF and EMF (from the frame), device
-    /// or logical units otherwise.
-    pub width: f32,
-    pub height: f32,
-    pub items: Vec<Item>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Item {
-    /// A filled and/or stroked path, in picture coordinates.
-    Path {
-        segs: Vec<Seg>,
-        fill: Option<[u8; 4]>,
-        /// Colour and width in picture units.
-        stroke: Option<([u8; 4], f32)>,
-        even_odd: bool,
-    },
-    /// A bitmap stretched into `rect` = `[x, y, w, h]` (picture units), RGBA8 rows top-down.
-    Bitmap { rect: [f32; 4], width: u32, height: u32, rgba: Vec<u8> },
-    /// A path filled with a repeating tile (pattern and hatch brushes). Items filled with the same
-    /// brush share its tile.
-    Pattern { segs: Vec<Seg>, even_odd: bool, tile: Arc<Tile> },
-    /// A text string.
-    Text(Box<Text>),
-}
-
-/// A brush tile: RGBA8 rows top-down (transparent where the brush leaves the background), each
-/// pixel `cell` picture units, with a tile's top-left corner at `origin`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Tile {
-    pub width: u32,
-    pub height: u32,
-    pub rgba: Vec<u8>,
-    pub cell: [f32; 2],
-    pub origin: [f32; 2],
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Seg {
-    Move(f32, f32),
-    Line(f32, f32),
-    Cubic(f32, f32, f32, f32, f32, f32),
-    Close,
-}
-
-#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq)]
-pub enum Error {
-    #[error("not a WMF or EMF file")]
-    NotMetafile,
-    #[error("metafile header is truncated or invalid")]
-    BadHeader,
-    #[error("metafile has no readable records")]
-    NoRecords,
-}
-
-/// The picture frame in device units (`rect` = `[x, y, w, h]`) and, when the file states one, its
-/// size in picture units.
-pub(crate) struct Frame {
-    pub rect: [f64; 4],
-    pub size: Option<(f64, f64)>,
-}
-
-/// Parses a WMF (placeable or plain) or EMF file.
-pub fn parse(bytes: &[u8]) -> Result<Picture, Error> {
-    let b = Bytes(bytes);
-    let (cv, frame) = if emf::is_emf(b) {
-        emf::parse(b)?
-    } else if wmf::is_wmf(b) {
-        // A WMF converted from an EMF can carry the original in MFCOMMENT escapes; PowerPoint draws
-        // the WMF's own records (its dx rounding shows), so the copy is not used.
-        wmf::parse(b)?
-    } else {
-        return Err(Error::NotMetafile);
-    };
-    Ok(build(cv.items, frame))
-}
-
-/// True when the bytes start like a WMF (placeable or plain header) or an EMF.
-pub fn is_metafile(bytes: &[u8]) -> bool {
-    let b = Bytes(bytes);
-    emf::is_emf(b) || wmf::is_wmf(b)
-}
-
-/// Maps device-space output into the picture frame. Without a usable frame the frame is the bounding
-/// box of the drawing, so the origin is still the top-left of what was drawn.
-fn build(raw: Vec<Raw>, frame: Option<Frame>) -> Picture {
-    let frame = frame.filter(|f| f.rect.iter().all(|v| v.is_finite()) && f.rect[2] > 0.0 && f.rect[3] > 0.0);
-    let (rect, size) = match frame {
-        Some(f) => (f.rect, f.size.unwrap_or((f.rect[2], f.rect[3]))),
-        None => match bbox(&raw) {
-            Some([x0, y0, x1, y1]) => ([x0, y0, x1 - x0, y1 - y0], (x1 - x0, y1 - y0)),
-            None => return Picture { width: 0.0, height: 0.0, items: Vec::new() },
-        },
-    };
-    let sx = if rect[2] > 0.0 { size.0 / rect[2] } else { 1.0 };
-    let sy = if rect[3] > 0.0 { size.1 / rect[3] } else { 1.0 };
-    let tf = move |p: P| ((p.0 - rect[0]) * sx, (p.1 - rect[1]) * sy);
-    let stroke_scale = (sx + sy) / 2.0;
-    // No stroke is wider than the picture's diagonal: anything wider is a mapping artefact.
-    let diag = size.0.hypot(size.1);
-    // Tiles shared by several fills stay shared.
-    let mut tiles: HashMap<*const canvas::RawTile, (Arc<canvas::RawTile>, Arc<Tile>)> = HashMap::new();
-    let items = raw.into_iter().filter_map(|r| match r {
-        Raw::Path { ops, fill, stroke, even_odd } => {
-            let segs = ops.iter().map(|op| seg(op, tf)).collect::<Option<Vec<Seg>>>()?;
-            if segs.len() < 2 {
-                return None;
-            }
-            let stroke = stroke.and_then(|(c, w)| Some((c, f((w * stroke_scale).min(diag))?)));
-            Some(Item::Path { segs, fill, stroke, even_odd })
-        }
-        Raw::Bitmap { rect: r, img } => {
-            let (x, y) = tf((r[0], r[1]));
-            let rect = [f(x)?, f(y)?, f(r[2] * sx)?, f(r[3] * sy)?];
-            Some(Item::Bitmap { rect, width: img.w as u32, height: img.h as u32, rgba: img.px })
-        }
-        Raw::Pattern { ops, even_odd, tile } => {
-            let segs = ops.iter().map(|op| seg(op, tf)).collect::<Option<Vec<Seg>>>()?;
-            if segs.len() < 2 {
-                return None;
-            }
-            let key = Arc::as_ptr(&tile);
-            let tile = match tiles.get(&key) {
-                Some((_, t)) => t.clone(),
-                None => {
-                    let (ox, oy) = tf((0.0, 0.0));
-                    let t = Arc::new(Tile {
-                        width: u32::try_from(tile.w).ok()?,
-                        height: u32::try_from(tile.h).ok()?,
-                        rgba: tile.px.clone(),
-                        cell: [f(tile.cell * sx)?, f(tile.cell * sy)?],
-                        origin: [f(ox)?, f(oy)?],
-                    });
-                    // The raw tile is kept with its key, so the address is never reused by another.
-                    tiles.insert(key, (tile.clone(), t.clone()));
-                    t
-                }
-            };
-            Some(Item::Pattern { segs, even_odd, tile })
-        }
-        Raw::Text(mut t) => {
-            // Device to picture: scale by (sx, sy) after moving the frame's corner to the origin.
-            let [a, b, c, d, e, g] = t.transform;
-            let (e, g) = tf((e, g));
-            t.transform = [a * sx, b * sy, c * sx, d * sy, e, g];
-            if !t.transform.iter().all(|v| v.is_finite()) {
-                return None;
-            }
-            if let Some([x0, y0, x1, y1]) = t.clip {
-                let (p, q) = (tf((f64::from(x0), f64::from(y0))), tf((f64::from(x1), f64::from(y1))));
-                t.clip = Some([f(p.0.min(q.0))?, f(p.1.min(q.1))?, f(p.0.max(q.0))?, f(p.1.max(q.1))?]);
-            }
-            Some(Item::Text(t))
-        }
-    });
-    let items = items.collect();
-    Picture { width: f(size.0).unwrap_or(0.0), height: f(size.1).unwrap_or(0.0), items }
-}
-
-fn f(v: f64) -> Option<f32> {
-    let v = v as f32;
-    v.is_finite().then_some(v)
-}
-
-fn seg(op: &Op, tf: impl Fn(P) -> P) -> Option<Seg> {
-    let pt = |p: P| {
-        let (x, y) = tf(p);
-        Some((f(x)?, f(y)?))
-    };
-    Some(match *op {
-        Op::M(p) => {
-            let (x, y) = pt(p)?;
-            Seg::Move(x, y)
-        }
-        Op::L(p) => {
-            let (x, y) = pt(p)?;
-            Seg::Line(x, y)
-        }
-        Op::C(a, b, c) => {
-            let (x1, y1) = pt(a)?;
-            let (x2, y2) = pt(b)?;
-            let (x3, y3) = pt(c)?;
-            Seg::Cubic(x1, y1, x2, y2, x3, y3)
-        }
-        Op::Z => Seg::Close,
-    })
-}
-
-/// Bounding box `[x0, y0, x1, y1]` over the finite points of the output.
-fn bbox(raw: &[Raw]) -> Option<[f64; 4]> {
-    let mut b: Option<[f64; 4]> = None;
-    let mut grow = |p: P| {
-        if p.0.is_finite() && p.1.is_finite() {
-            b = Some(match b {
-                None => [p.0, p.1, p.0, p.1],
-                Some([x0, y0, x1, y1]) => [x0.min(p.0), y0.min(p.1), x1.max(p.0), y1.max(p.1)],
-            });
-        }
-    };
-    for r in raw {
-        match r {
-            Raw::Path { ops, .. } | Raw::Pattern { ops, .. } => {
-                for op in ops {
-                    match *op {
-                        Op::M(p) | Op::L(p) => grow(p),
-                        Op::C(a, c, d) => {
-                            grow(a);
-                            grow(c);
-                            grow(d);
-                        }
-                        Op::Z => {}
-                    }
-                }
-            }
-            Raw::Bitmap { rect, .. } => {
-                grow((rect[0], rect[1]));
-                grow((rect[0] + rect[2], rect[1] + rect[3]));
-            }
-            Raw::Text(t) => grow((t.transform[4], t.transform[5])),
-        }
-    }
-    b
-}

crates/metafile/src/place.rs

@@ -1,150 +0,0 @@
-//! Placing a picture on a target (a page or a device): the fitted transform, paths as kurbo paths in
-//! target units and bitmaps as target rectangles. The rasteriser and the PDF writer only paint the result.
-
-use kurbo::{Affine, BezPath, Rect, Shape};
-
-use crate::{Item, Picture, Seg};
-
-/// Largest bitmap side the renderers draw: within the PDF image limit and the rasteriser's 16-bit sides.
-pub const MAX_BITMAP_SIDE: u32 = 30_000;
-/// Placed coordinates past this (target units) are far off any page; such items are left out.
-const MAX_COORD: f64 = 1e6;
-/// Smallest placed bitmap side (target units), so the stretch onto it is never singular.
-const MIN_BITMAP_SIDE: f64 = 1e-6;
-
-/// One item of a placed picture, in target units.
-pub enum PlacedItem {
-    /// A filled and/or stroked path. The stroke width is in target units; 0 is a cosmetic hairline that
-    /// the renderer draws at its minimum width.
-    Path { path: BezPath, fill: Option<[u8; 4]>, stroke: Option<([u8; 4], f64)>, even_odd: bool },
-    /// `Picture::items[index]`, a bitmap, stretched into `rect`.
-    Bitmap { index: usize, rect: Rect },
-    /// `Picture::items[index]`, a pattern fill: `path` (target units) filled with the item's tile
-    /// repeated; `tile` maps tile pixels to target units.
-    Pattern { index: usize, path: BezPath, even_odd: bool, tile: Affine },
-    /// `Picture::items[index]`, a text string: `transform` maps its text space to target units;
-    /// `clip` (target units) bounds what it draws.
-    Text { index: usize, transform: Affine, clip: Option<Rect> },
-}
-
-impl Picture {
-    /// Whether the picture has a finite, positive size, so it can be fitted into a frame.
-    pub fn has_size(&self) -> bool {
-        self.width.is_finite() && self.height.is_finite() && self.width > 0.0 && self.height > 0.0
-    }
-
-    /// The transform that fits the picture into `r` with the crop fractions `crop` (left, top, right,
-    /// bottom) removed first: the visible part fills `r`. None for a degenerate size.
-    pub fn fit(&self, r: Rect, crop: [f32; 4]) -> Option<Affine> {
-        let [cl, ct, cr, cb] = crop.map(|v| if v.is_finite() { f64::from(v.clamp(0.0, 0.95)) } else { 0.0 });
-        let (w, h) = (f64::from(self.width), f64::from(self.height));
-        let sx = r.width() / (w * (1.0 - cl - cr).max(0.05));
-        let sy = r.height() / (h * (1.0 - ct - cb).max(0.05));
-        (sx.is_finite() && sy.is_finite() && sx > 0.0 && sy > 0.0)
-            .then(|| Affine::translate((r.x0 - cl * w * sx, r.y0 - ct * h * sy)) * Affine::scale_non_uniform(sx, sy))
-    }
-
-    /// The items placed into `r` with `crop` applied. Items that are not finite or reach past ±1e6
-    /// target units are left out (they are far off any page), as are bitmaps with no area. Stroke
-    /// widths are scaled to target units (along the mean axis scale, so a non-uniform fit keeps
-    /// strokes even).
-    pub fn place(&self, r: Rect, crop: [f32; 4]) -> Vec<PlacedItem> {
-        let Some(tf) = self.fit(r, crop) else { return Vec::new() };
-        let c = tf.as_coeffs();
-        let k = (c[0].abs() + c[3].abs()) / 2.0;
-        let mut out = Vec::with_capacity(self.items.len());
-        for (index, item) in self.items.iter().enumerate() {
-            match item {
-                Item::Path { segs, fill, stroke, even_odd } => {
-                    let path = tf * bez(segs);
-                    if in_range(path.bounding_box()) {
-                        let stroke = stroke.map(|(c, w)| (c, f64::from(w) * k));
-                        out.push(PlacedItem::Path { path, fill: *fill, stroke, even_odd: *even_odd });
-                    }
-                }
-                Item::Pattern { segs, even_odd, tile: t } => {
-                    let path = tf * bez(segs);
-                    let tile = tf
-                        * Affine::translate((f64::from(t.origin[0]), f64::from(t.origin[1])))
-                        * Affine::scale_non_uniform(f64::from(t.cell[0]), f64::from(t.cell[1]));
-                    let det = tile.determinant();
-                    if in_range(path.bounding_box()) && det.is_finite() && det.abs() > 1e-12 {
-                        out.push(PlacedItem::Pattern { index, path, even_odd: *even_odd, tile });
-                    }
-                }
-                Item::Text(t) => {
-                    let transform = tf * Affine::new(t.transform);
-                    let clip =
-                        t.clip.map(|[x0, y0, x1, y1]| tf.transform_rect_bbox(Rect::new(f64::from(x0), f64::from(y0), f64::from(x1), f64::from(y1))));
-                    let c = transform.as_coeffs();
-                    let origin = Rect::new(c[4], c[5], c[4], c[5]);
-                    if in_range(origin) && c.iter().all(|v| v.is_finite()) && clip.is_none_or(in_range) {
-                        out.push(PlacedItem::Text { index, transform, clip });
-                    }
-                }
-                Item::Bitmap { rect: [x, y, w, h], .. } => {
-                    let (x0, y0) = (f64::from(*x), f64::from(*y));
-                    let rect = tf.transform_rect_bbox(Rect::new(x0, y0, x0 + f64::from(*w), y0 + f64::from(*h)));
-                    if in_range(rect) && rect.width() > MIN_BITMAP_SIDE && rect.height() > MIN_BITMAP_SIDE {
-                        out.push(PlacedItem::Bitmap { index, rect });
-                    }
-                }
-            }
-        }
-        out
-    }
-}
-
-impl Item {
-    /// Takes a bitmap's pixels out of the item (its geometry stays) and returns them as (width, height,
-    /// RGBA) when a renderer can draw them: both sides in 1..=[`MAX_BITMAP_SIDE`] and exactly that many
-    /// pixels. None for paths and for bitmaps that cannot be drawn.
-    pub fn take_pixels(&mut self) -> Option<(u32, u32, Vec<u8>)> {
-        let Item::Bitmap { width, height, rgba, .. } = self else { return None };
-        let (w, h, px) = (*width, *height, std::mem::take(rgba));
-        let sides = (1..=MAX_BITMAP_SIDE).contains(&w) && (1..=MAX_BITMAP_SIDE).contains(&h);
-        (sides && px.len() == (w as usize).saturating_mul(h as usize).saturating_mul(4)).then_some((w, h, px))
-    }
-}
-
-/// Segments as a kurbo path. A segment after a close opens a new subpath at the last start point.
-fn bez(segs: &[Seg]) -> BezPath {
-    let mut p = BezPath::new();
-    let mut start = (0.0, 0.0);
-    let mut open = false;
-    for s in segs {
-        match *s {
-            Seg::Move(x, y) => {
-                start = (f64::from(x), f64::from(y));
-                p.move_to(start);
-                open = true;
-            }
-            Seg::Line(x, y) => {
-                if !open {
-                    p.move_to(start);
-                }
-                p.line_to((f64::from(x), f64::from(y)));
-                open = true;
-            }
-            Seg::Cubic(a, b, c, d, e, f) => {
-                if !open {
-                    p.move_to(start);
-                }
-                p.curve_to((f64::from(a), f64::from(b)), (f64::from(c), f64::from(d)), (f64::from(e), f64::from(f)));
-                open = true;
-            }
-            Seg::Close => {
-                if open {
-                    p.close_path();
-                }
-                open = false;
-            }
-        }
-    }
-    p
-}
-
-/// Whether a placed box is finite and within ±[`MAX_COORD`].
-fn in_range(b: Rect) -> bool {
-    [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite() && v.abs() < MAX_COORD)
-}

crates/metafile/src/text.rs

@@ -1,200 +0,0 @@
-//! Text records: the font (LOGFONT), the text string decoded from its character set, and the
-//! neutral [`Text`] item. The metafile crate knows no fonts, so measuring, alignment against the
-//! font's metrics and glyph drawing are left to the renderer.
-
-/// A font chosen by a CREATEFONTINDIRECT record (MS-WMF 2.2.1.2 Font, MS-EMF 2.2.13 LogFont).
-#[derive(Debug, Clone, PartialEq, Default)]
-pub struct Font {
-    /// The face name the file asks for (`"Arial"`, `"Wingdings"`); may be empty.
-    pub family: String,
-    /// LOGFONT height in text units: negative is the character (em) height, positive the cell
-    /// height (ascent plus descent), 0 the default size.
-    pub height: f32,
-    /// Average character width in text units; 0 keeps the font's own proportions.
-    pub width: f32,
-    /// 100..=900 (400 regular, 700 bold); 0 is the default weight.
-    pub weight: u16,
-    pub italic: bool,
-    pub underline: bool,
-    pub strike: bool,
-    /// LOGFONT character set (0 ANSI, 2 SYMBOL, 238 EASTEUROPE…).
-    pub charset: u8,
-}
-
-/// SYMBOL_CHARSET: byte codes are the font's own symbol codes.
-pub const SYMBOL_CHARSET: u8 = 2;
-
-/// Where the reference point sits on the string horizontally (TA_LEFT, TA_CENTER, TA_RIGHT).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum HAlign {
-    #[default]
-    Left,
-    Center,
-    Right,
-}
-
-/// Where the reference point sits vertically (TA_TOP, TA_BASELINE, TA_BOTTOM): the top of the
-/// character cell, the baseline or the bottom of the cell.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum VAlign {
-    #[default]
-    Top,
-    Baseline,
-    Bottom,
-}
-
-/// One string drawn by EXTTEXTOUT, TEXTOUT or SMALLTEXTOUT.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Text {
-    /// Text space to picture space as affine coefficients `[a, b, c, d, e, f]` (`x' = a·x + c·y + e`,
-    /// `y' = b·x + d·y + f`, kurbo's order). Text space has x along the baseline and y down, in the
-    /// metafile's logical units, with the reference point at the origin. Escapement and the
-    /// mapping are folded in; glyphs are never mirrored.
-    pub transform: [f64; 6],
-    pub text: String,
-    /// Advance after each character of `text`, in text units (the dx array). Empty when the file
-    /// gives none: the font's own advances apply.
-    pub dx: Vec<f32>,
-    pub font: Font,
-    pub color: [u8; 4],
-    /// Colour filled behind the character cells (OPAQUE background mode); None when transparent.
-    pub background: Option<[u8; 4]>,
-    pub h_align: HAlign,
-    pub v_align: VAlign,
-    /// Clip rectangle `[x0, y0, x1, y1]` in picture units (ETO_CLIPPED).
-    pub clip: Option<[f32; 4]>,
-}
-
-/// TA_UPDATECP: the string starts at the current position, which moves past it.
-pub(crate) const TA_UPDATECP: u32 = 0x0001;
-/// ETO_OPAQUE fills the rectangle with the background colour; ETO_CLIPPED clips the text to it.
-pub(crate) const ETO_OPAQUE: u32 = 0x0002;
-pub(crate) const ETO_CLIPPED: u32 = 0x0004;
-/// The string holds glyph indices, not characters (drawn only when the font matches).
-pub(crate) const ETO_GLYPH_INDEX: u32 = 0x0010;
-/// The dx array holds (dx, dy) pairs.
-pub(crate) const ETO_PDY: u32 = 0x2000;
-/// Longest string kept from one record.
-pub(crate) const MAX_CHARS: usize = 16_384;
-
-/// Horizontal and vertical alignment from a TA_* word (the vertical bits are 0 top, 8 bottom,
-/// 24 baseline; the horizontal ones 0 left, 2 right, 6 center).
-pub(crate) fn align(ta: u32) -> (HAlign, VAlign) {
-    let h = match ta & 0x06 {
-        6 => HAlign::Center,
-        2 => HAlign::Right,
-        _ => HAlign::Left,
-    };
-    let v = match ta & 0x18 {
-        0x18 => VAlign::Baseline,
-        0x08 => VAlign::Bottom,
-        _ => VAlign::Top,
-    };
-    (h, v)
-}
-
-/// Decodes 8-bit text in `charset` to one character per byte, and merges `dx` to match: a
-/// double-byte character set's lead and trail bytes become one blank (its glyphs are not
-/// decoded) whose advance is the sum of both. `dx` may be empty.
-pub(crate) fn decode_bytes(bytes: &[u8], charset: u8, dx: &[f32]) -> (String, Vec<f32>) {
-    let mut s = String::with_capacity(bytes.len());
-    let mut out_dx = Vec::with_capacity(dx.len().min(bytes.len()));
-    let dbcs = matches!(charset, 128 | 129 | 130 | 134 | 136);
-    let mut i = 0;
-    while let Some(&b) = bytes.get(i) {
-        let n = if dbcs && b >= 0x81 && i + 1 < bytes.len() { 2 } else { 1 };
-        let c = if n == 2 { ' ' } else { byte_char(b, charset) };
-        s.push(c);
-        if !dx.is_empty() {
-            out_dx.push((i..i + n).filter_map(|k| dx.get(k)).sum());
-        }
-        i += n;
-    }
-    (s, out_dx)
-}
-
-/// UTF-16 text to a string with one dx entry per character: a surrogate pair takes the sum of
-/// its two advances. Unpaired surrogates become U+FFFD.
-pub(crate) fn decode_utf16(units: &[u16], dx: &[f32]) -> (String, Vec<f32>) {
-    let mut s = String::with_capacity(units.len());
-    let mut out_dx = Vec::with_capacity(dx.len().min(units.len()));
-    let mut i = 0;
-    for r in char::decode_utf16(units.iter().copied()) {
-        let c = r.unwrap_or(char::REPLACEMENT_CHARACTER);
-        let n = c.len_utf16();
-        s.push(c);
-        if !dx.is_empty() {
-            out_dx.push((i..i + n).filter_map(|k| dx.get(k)).sum());
-        }
-        i += n;
-    }
-    (s, out_dx)
-}
-
-/// One byte in a single-byte Windows code page. Symbol fonts keep their codes in the private-use
-/// range (U+F000 + code), where symbol fonts map them.
-fn byte_char(b: u8, charset: u8) -> char {
-    if b < 0x80 && charset != SYMBOL_CHARSET {
-        return char::from(b);
-    }
-    let cp = match charset {
-        SYMBOL_CHARSET => 0xF000 | u32::from(b),
-        238 => high(b, &CP1250),
-        204 => high(b, &CP1251),
-        _ => high(b, &CP1252),
-    };
-    char::from_u32(cp).unwrap_or(char::REPLACEMENT_CHARACTER)
-}
-
-/// The code point of byte `b` (0x80..=0xFF) from a table of the upper half; 0 entries are
-/// undefined bytes, drawn as U+FFFD.
-fn high(b: u8, table: &[u16; 128]) -> u32 {
-    match table.get(usize::from(b.wrapping_sub(0x80))) {
-        Some(0) | None => 0xFFFD,
-        Some(v) => u32::from(*v),
-    }
-}
-
-/// Windows-1252 (Western) 0x80..=0xFF: the upper half of Latin-1 with typographic marks in 0x80..=0x9F.
-const CP1252: [u16; 128] = {
-    let mut t = [0u16; 128];
-    let low: [u16; 32] = [
-        0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0, 0x017D, 0, 0, 0x2018, 0x2019, 0x201C,
-        0x201D, 0x2022, 0x2013, 0x2014, 0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0, 0x017E, 0x0178,
-    ];
-    let mut i = 0;
-    while i < 128 {
-        t[i] = if i < 32 { low[i] } else { 0x80 + i as u16 };
-        i += 1;
-    }
-    t
-};
-
-/// Windows-1250 (Central European) 0x80..=0xFF.
-const CP1250: [u16; 128] = [
-    0x20AC, 0, 0x201A, 0, 0x201E, 0x2026, 0x2020, 0x2021, 0, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179, //
-    0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A, //
-    0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B, //
-    0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C, //
-    0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E, //
-    0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7, 0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF, //
-    0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F, //
-    0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7, 0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
-];
-
-/// Windows-1251 (Cyrillic) 0x80..=0xFF; 0xC0..=0xFF are А..я in order.
-const CP1251: [u16; 128] = {
-    let low: [u16; 64] = [
-        0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021, 0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F, //
-        0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F, //
-        0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7, 0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407, //
-        0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7, 0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
-    ];
-    let mut t = [0u16; 128];
-    let mut i = 0;
-    while i < 128 {
-        t[i] = if i < 64 { low[i] } else { 0x0410 + (i as u16 - 64) };
-        i += 1;
-    }
-    t
-};

crates/metafile/src/wmf.rs

@@ -1,380 +0,0 @@
-//! WMF reader (MS-WMF). A file is an optional 22-byte placeable header, a 9-word standard header, then
-//! records of (size in 16-bit words, function, parameters). Parameters are read at byte 6 of each record.
-
-use std::sync::Arc;
-
-use crate::bytes::Bytes;
-use crate::canvas::{BS_HATCHED, Brush, Canvas, LogFont, Obj, Pen, colorref};
-use crate::dib;
-use crate::geom::{self, ArcKind, P};
-use crate::text::{ETO_CLIPPED, ETO_OPAQUE, Font, MAX_CHARS, decode_bytes};
-use crate::{Error, Frame, MAX_PATH_OPS};
-
-const PLACEABLE_KEY: u32 = 0x9AC6_CDD7;
-const DEFAULT_INCH: f64 = 1440.0;
-/// A placeable WMF plays into a target sized in points; brushes are laid out in 96-dpi pixels.
-const PT_PER_PX: f64 = 72.0 / 96.0;
-
-pub(crate) fn is_wmf(b: Bytes) -> bool {
-    if b.u32(0) == Some(PLACEABLE_KEY) {
-        return true;
-    }
-    matches!(b.u16(0), Some(1 | 2)) && b.u16(2) == Some(9) && matches!(b.u16(4), Some(0x100 | 0x300))
-}
-
-/// Reads all records. Returns the drawing state and the picture frame, or an error when no record
-/// could be read at all.
-pub(crate) fn parse(input: Bytes) -> Result<(Canvas, Option<Frame>), Error> {
-    let placeable = input.u32(0) == Some(PLACEABLE_KEY);
-    // Placeable bounds: logical corners (left, top, right, bottom) and their size in points.
-    let (hdr, bounds) = if placeable {
-        let [l, t, r, b] = [6, 8, 10, 12].map(|o| input.i16(o).map(f64::from));
-        let (Some(l), Some(t), Some(r), Some(b)) = (l, t, r, b) else { return Err(Error::BadHeader) };
-        let inch = input.u16(14).filter(|v| *v > 0).map_or(DEFAULT_INCH, f64::from);
-        let (w, h) = (r - l, b - t);
-        let bounds = (w > 0.0 && h > 0.0).then_some(([l, t, r, b], (w * 72.0 / inch, h * 72.0 / inch)));
-        (22, bounds)
-    } else {
-        (0, None)
-    };
-    let hsize = input.u16(hdr + 2).ok_or(Error::BadHeader)? as usize;
-    if hsize < 9 {
-        return Err(Error::BadHeader);
-    }
-    let mut pos = hdr.checked_add(hsize.checked_mul(2).ok_or(Error::BadHeader)?).ok_or(Error::BadHeader)?;
-    // Played into a target like Word does: the placeable bounds are the first window, the target (the
-    // picture size) the viewport. A plain WMF's target is its first window.
-    let mut cv = Canvas::new();
-    if let Some((c, size)) = bounds {
-        cv.play_into(Some([c[0], c[1], c[2] - c[0], c[3] - c[1]]), size);
-        cv.pattern_px = PT_PER_PX;
-    }
-    let mut player_viewport = bounds.is_some();
-    let mut parsed = 0usize;
-    while !cv.full() {
-        let (Some(words), Some(func)) = (input.u32(pos), pos.checked_add(4).and_then(|o| input.u16(o))) else { break };
-        let Some(len) = (words as usize).checked_mul(2).filter(|l| *l >= 6) else { break };
-        let Some(rec) = input.slice(pos, len) else { break };
-        if func == 0 {
-            break;
-        }
-        record(&mut cv, func, Bytes(rec));
-        if func == 0x020C && cv.window_set && !player_viewport && !cv.viewport_set {
-            let we = cv.map.window_ext();
-            cv.play_into(None, (we.0.abs(), we.1.abs()));
-            player_viewport = true;
-        }
-        parsed += 1;
-        let Some(next) = pos.checked_add(len) else { break };
-        pos = next;
-    }
-    if parsed == 0 {
-        return Err(Error::NoRecords);
-    }
-    let frame = match bounds {
-        // Played into its target: the frame is the target.
-        Some((_, size)) if !cv.viewport_set && cv.map.uses_extents() => Some(Frame { rect: [0.0, 0.0, size.0, size.1], size: Some(size) }),
-        // The file set its own viewport, so the drawing is in its device units and the logical bounds
-        // go through the final mapping.
-        Some((c, size)) => {
-            let (a, b) = (cv.map.device((c[0], c[1])), cv.map.device((c[2], c[3])));
-            let rect = [a.0.min(b.0), a.1.min(b.1), (b.0 - a.0).abs(), (b.1 - a.1).abs()];
-            (rect[2] > 0.0 && rect[3] > 0.0).then_some(Frame { rect, size: Some(size) })
-        }
-        None if player_viewport && !cv.viewport_set && cv.map.uses_extents() => {
-            let ve = cv.map.viewport_ext();
-            Some(Frame { rect: [0.0, 0.0, ve.0, ve.1], size: None })
-        }
-        None if cv.window_set => Some(Frame { rect: cv.map.window_rect(), size: None }),
-        None => None,
-    };
-    Ok((cv, frame))
-}
-
-fn record(cv: &mut Canvas, func: u16, r: Bytes) {
-    if cv.full() {
-        return;
-    }
-    let _ = match func {
-        0x0103 => r.u16(6).map(|m| cv.set_map_mode(u32::from(m))),
-        0x0106 => r.u16(6).map(|m| cv.set_polyfill(u32::from(m))),
-        0x0104 => r.u16(6).map(|m| cv.set_rop2(u32::from(m))),
-        // Y is stored before X in these records.
-        0x020B => xy16(r, 6).map(|p| cv.set_window_org(p)),
-        0x020C => xy16(r, 6).map(|p| cv.set_window_ext(p)),
-        0x020D => xy16(r, 6).map(|p| cv.set_viewport_org(p)),
-        0x020E => xy16(r, 6).map(|p| cv.set_viewport_ext(p)),
-        0x001E => {
-            cv.save_dc();
-            Some(())
-        }
-        0x0127 => r.i16(6).map(|n| cv.restore_dc(i32::from(n))),
-        0x0214 => xy16(r, 6).map(|p| cv.move_to(p)),
-        0x0213 => xy16(r, 6).map(|p| cv.line_to(p)),
-        0x0325 => counted_points(r).map(|pts| cv.poly(&pts, false, false, true)),
-        0x0324 => counted_points(r).map(|pts| cv.poly(&pts, true, true, true)),
-        0x0538 => polypolygon(r).map(|ops| cv.shape(&ops, true, true)),
-        0x041B => rect16(r, 6).map(|[l, t, rr, b]| cv.shape(&geom::rect(l, t, rr, b), true, true)),
-        0x061C => {
-            let [ew, eh] = [r.i16(8), r.i16(6)];
-            let (Some(ew), Some(eh)) = (ew, eh) else { return };
-            rect16(r, 10).map(|[l, t, rr, b]| {
-                cv.shape(&geom::round_rect(l, t, rr, b, f64::from(ew), f64::from(eh)), true, true);
-            })
-        }
-        0x0418 => rect16(r, 6).map(|[l, t, rr, b]| cv.shape(&geom::ellipse(l, t, rr, b), true, true)),
-        0x0817 | 0x081A | 0x0830 => arc16(r).map(|(bounds, s, e)| {
-            let kind = match func {
-                0x0817 => ArcKind::Arc,
-                0x081A => ArcKind::Pie,
-                _ => ArcKind::Chord,
-            };
-            let [l, t, rr, b] = bounds;
-            cv.shape(&geom::arc_shape(l, t, rr, b, s, e, kind), kind != ArcKind::Arc, true);
-        }),
-        0x02FA => create_pen(cv, r),
-        0x02FC => create_brush(cv, r),
-        0x02FB => {
-            let f = font(r).unwrap_or_default();
-            cv.add_object(None, Obj::Font(Arc::new(f)));
-            Some(())
-        }
-        0x0142 => {
-            // A pattern the reader cannot decode still takes its handle slot.
-            let b = dib_pattern_brush(r).map_or(Obj::Other, Obj::Brush);
-            cv.add_object(None, b);
-            Some(())
-        }
-        // Palettes, old-style pattern brushes and regions take a handle slot too, so later
-        // SELECTOBJECT handles count them; selecting one draws nothing.
-        0x00F7 | 0x01F9 | 0x06FF => {
-            cv.add_object(None, Obj::Other);
-            Some(())
-        }
-        0x0209 => r.u32(6).map(|c| cv.set_text_color(c)),
-        0x0201 => r.u32(6).map(|c| cv.set_bk_color(c)),
-        0x0102 => r.u16(6).map(|m| cv.set_bk_mode(u32::from(m))),
-        0x012E => r.u16(6).map(|a| cv.set_text_align(u32::from(a))),
-        0x0A32 => ext_text_out(cv, r),
-        0x0521 => text_out(cv, r),
-        // PATBLT: rop(4), height, width, y, x.
-        0x061D => r.u32(6).map(|rop| cv.fill_rop([i16s(r, 16), i16s(r, 14), i16s(r, 12), i16s(r, 10)], rop)),
-        0x012D => r.u16(6).map(|h| cv.select(wmf_handle(h))),
-        0x01F0 => r.u16(6).map(|h| cv.delete_object(u32::from(h))),
-        // STRETCHDIB: rop(4) usage(2) srcH srcW ySrc xSrc destH destW yDest xDest, then the DIB.
-        0x0F43 => {
-            let rop = r.u32(6).unwrap_or(0);
-            dib_blit(cv, r, 28, rop, [i16s(r, 26), i16s(r, 24), i16s(r, 22), i16s(r, 20)], [i16s(r, 18), i16s(r, 16), i16s(r, 14), i16s(r, 12)])
-        }
-        0x0B41 => dib_stretchblt(cv, r),
-        0x0940 => dib_bitblt(cv, r),
-        _ => Some(()),
-    };
-}
-
-/// A 16-bit WMF handle as a canvas object index: stock objects are `0x8000 | index`, which the
-/// canvas reads with the 32-bit stock flag.
-fn wmf_handle(h: u16) -> u32 {
-    let h = u32::from(h);
-    if h & 0x8000 != 0 { (h & 0x7FFF) | 0x8000_0000 } else { h }
-}
-
-/// An i16 field as f64; 0 past the end.
-fn i16s(r: Bytes, off: usize) -> f64 {
-    r.i16(off).map_or(0.0, f64::from)
-}
-
-/// CREATEPENINDIRECT: style, width (x, y), colour. Only the width's x component is used.
-fn create_pen(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let style = r.u16(6)?;
-    let width = r.i16(8)?;
-    let color = r.u32(12)?;
-    cv.add_object(None, Obj::Pen(Pen { style: u32::from(style), width: f64::from(width), color: colorref(color) }));
-    Some(())
-}
-
-/// CREATEBRUSHINDIRECT: style, colour, hatch.
-fn create_brush(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let style = u32::from(r.u16(6)?);
-    let color = r.u32(8)?;
-    let mut b = Brush::new(style, colorref(color));
-    if style == BS_HATCHED {
-        b.hatch = u32::from(r.u16(12).unwrap_or(0));
-    }
-    cv.add_object(None, Obj::Brush(b));
-    Some(())
-}
-
-/// DIBCREATEPATTERNBRUSH: style, colour usage, then a DIB (MS-WMF 2.3.4.8). The DIB's own palette
-/// gives the colours; with DIB_PAL_COLORS (indices into a palette the reader does not keep) a
-/// monochrome DIB takes the text and background colours.
-fn dib_pattern_brush(r: Bytes) -> Option<Brush> {
-    let usage = r.u16(8)?;
-    let dib = r.tail(10)?;
-    let n = dib::info_len(dib)?;
-    let img = dib::decode(Bytes(dib.slice(0, n)?), dib.tail(n)?, false)?;
-    Brush::pattern(img, usage == 1)
-}
-
-/// Font object (MS-WMF 2.2.1.2): height, width, escapement, orientation, weight (i16 each), italic,
-/// underline, strike-out and charset bytes, three precision/quality bytes, pitch and family, then the
-/// face name (up to 32 bytes, NUL-terminated, in the font's character set).
-fn font(r: Bytes) -> Option<LogFont> {
-    let height = r.i16(6)?;
-    let width = r.i16(8).unwrap_or(0);
-    let escapement = r.i16(10).unwrap_or(0);
-    let weight = r.i16(14).unwrap_or(0);
-    let byte = |o: usize| r.0.get(o).copied().unwrap_or(0);
-    let charset = byte(19);
-    let name = r.0.get(24..).unwrap_or(&[]);
-    let name = name.get(..32).unwrap_or(name);
-    let name = name.split(|b| *b == 0).next().unwrap_or(&[]);
-    // Face names are plain ASCII in practice; other bytes go through the Western code page.
-    let (family, _) = decode_bytes(name, 0, &[]);
-    Some(LogFont {
-        font: Font {
-            family: family.trim().to_string(),
-            height: f32::from(height),
-            width: f32::from(width),
-            weight: weight.clamp(0, 1000) as u16,
-            italic: byte(16) != 0,
-            underline: byte(17) != 0,
-            strike: byte(18) != 0,
-            charset,
-        },
-        escapement: f64::from(escapement),
-    })
-}
-
-/// The charset of the selected font, for decoding 8-bit text.
-fn charset(cv: &Canvas) -> u8 {
-    cv.font_charset()
-}
-
-/// EXTTEXTOUT (MS-WMF 2.3.3.5): y, x, string length, options, the rectangle (left, top, right,
-/// bottom) when ETO_OPAQUE or ETO_CLIPPED is set, the string padded to a word, then an optional dx
-/// array of i16 advances.
-fn ext_text_out(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let (y, x) = (r.i16(6)?, r.i16(8)?);
-    let n = usize::from(r.u16(10)?).min(MAX_CHARS);
-    let opts = u32::from(r.u16(12)?);
-    let has_rect = opts & (ETO_OPAQUE | ETO_CLIPPED) != 0;
-    let rect = if has_rect { Some([i16s(r, 14), i16s(r, 16), i16s(r, 18), i16s(r, 20)]) } else { None };
-    let at = if has_rect { 22 } else { 14 };
-    // A string running past the record is cut to what the record holds.
-    let avail = r.0.len().saturating_sub(at);
-    let n = n.min(avail);
-    let bytes = r.slice(at, n)?;
-    let dx_at = at + n.next_multiple_of(2);
-    let dx: Vec<f32> = if r.0.len() >= dx_at + 2 * n { (0..n).filter_map(|i| r.i16(dx_at + 2 * i)).map(f32::from).collect() } else { Vec::new() };
-    let (text, dx) = decode_bytes(bytes, charset(cv), &dx);
-    cv.text((f64::from(x), f64::from(y)), text, dx, opts, rect);
-    Some(())
-}
-
-/// TEXTOUT (MS-WMF 2.3.3.20): string length, the string padded to a word, then y and x.
-fn text_out(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let n = usize::from(r.u16(6)?).min(MAX_CHARS);
-    let bytes = r.slice(8, n)?;
-    let at = 8 + n.next_multiple_of(2);
-    let (y, x) = (r.i16(at)?, r.i16(at + 2)?);
-    let (text, _) = decode_bytes(bytes, charset(cv), &[]);
-    cv.text((f64::from(x), f64::from(y)), text, Vec::new(), 0, None);
-    Some(())
-}
-
-/// (x, y) from a Y-then-X pair stored at `off`.
-fn xy16(r: Bytes, off: usize) -> Option<P> {
-    Some((f64::from(r.i16(off + 2)?), f64::from(r.i16(off)?)))
-}
-
-/// Rectangle stored as bottom, right, top, left (the order MS-WMF uses for RECTANGLE and ELLIPSE).
-fn rect16(r: Bytes, off: usize) -> Option<[f64; 4]> {
-    let (b, rr, t, l) = (r.i16(off)?, r.i16(off + 2)?, r.i16(off + 4)?, r.i16(off + 6)?);
-    Some([f64::from(l), f64::from(t), f64::from(rr), f64::from(b)])
-}
-
-/// ARC, PIE and CHORD: end Y, end X, start Y, start X, then the bounding rectangle (bottom, right, top, left).
-fn arc16(r: Bytes) -> Option<([f64; 4], P, P)> {
-    let end = xy16(r, 6)?;
-    let start = xy16(r, 10)?;
-    let bounds = rect16(r, 14)?;
-    Some((bounds, start, end))
-}
-
-/// A count of 16-bit points, then the points (POLYLINE, POLYGON).
-fn counted_points(r: Bytes) -> Option<Vec<P>> {
-    let n = r.u16(6)? as usize;
-    r.tail(8)?.points(0, n, false)
-}
-
-/// POLYPOLYGON: polygon count, one 16-bit point count per polygon, then all points.
-fn polypolygon(r: Bytes) -> Option<Vec<geom::Op>> {
-    let n = r.u16(6)? as usize;
-    let mut counts = Vec::with_capacity(n);
-    for i in 0..n {
-        counts.push(r.u16(i.checked_mul(2)?.checked_add(8)?)? as usize);
-    }
-    let total = counts.iter().try_fold(0usize, |a, c| a.checked_add(*c))?;
-    if total > MAX_PATH_OPS {
-        return None;
-    }
-    let pts = r.tail(n.checked_mul(2)?.checked_add(8)?)?.points(0, total, false)?;
-    Some(geom::subpaths(&pts, &counts, true))
-}
-
-/// Whether a DIBBITBLT or DIBSTRETCHBLT record carries a bitmap: without one it is exactly
-/// `(function >> 8) + 3` words long (MS-WMF 2.3.1.2, 2.3.1.3).
-fn has_bitmap(func: u16, r: Bytes) -> bool {
-    r.0.len() / 2 > usize::from(func >> 8) + 3
-}
-
-/// META_DIBBITBLT: rop(4), ySrc, xSrc, then height, width, yDest, xDest and the DIB at 22. The
-/// bitmap-less form has a reserved word before the height, so its fields sit 2 bytes later; it, or
-/// a source-less raster operation, fills the destination.
-fn dib_bitblt(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let rop = r.u32(6)?;
-    if !has_bitmap(0x0940, r) {
-        cv.fill_rop([i16s(r, 22), i16s(r, 20), i16s(r, 18), i16s(r, 16)], rop);
-        return Some(());
-    }
-    let dst = [i16s(r, 20), i16s(r, 18), i16s(r, 16), i16s(r, 14)];
-    if Canvas::sourceless(rop) {
-        cv.fill_rop(dst, rop);
-        return Some(());
-    }
-    let src = [i16s(r, 12), i16s(r, 10), dst[2], dst[3]];
-    dib_blit(cv, r, 22, rop, dst, src)
-}
-
-/// META_DIBSTRETCHBLT: rop(4), srcH, srcW, ySrc, xSrc, then destH, destW, yDest, xDest and the DIB at
-/// 26. The bitmap-less form has a reserved word after xSrc, so the destination sits 2 bytes later;
-/// it, or a source-less raster operation, fills the destination.
-fn dib_stretchblt(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let rop = r.u32(6)?;
-    if !has_bitmap(0x0B41, r) {
-        cv.fill_rop([i16s(r, 26), i16s(r, 24), i16s(r, 22), i16s(r, 20)], rop);
-        return Some(());
-    }
-    let dst = [i16s(r, 24), i16s(r, 22), i16s(r, 20), i16s(r, 18)];
-    if Canvas::sourceless(rop) {
-        cv.fill_rop(dst, rop);
-        return Some(());
-    }
-    let src = [i16s(r, 16), i16s(r, 14), i16s(r, 12), i16s(r, 10)];
-    dib_blit(cv, r, 26, rop, dst, src)
-}
-
-/// A DIB at `at`, stretched from source rectangle `src` into `dst` (both in logical units, pixels for `src`).
-/// The raster operation `rop` decides how the pixels combine (see [`dib::prepare`]).
-fn dib_blit(cv: &mut Canvas, r: Bytes, at: usize, rop: u32, dst: [f64; 4], src: [f64; 4]) -> Option<()> {
-    let dib = r.tail(at)?;
-    let n = dib::info_len(dib)?;
-    let info = dib.slice(0, n)?;
-    let bits = dib.tail(n)?;
-    let mut img = dib::decode(Bytes(info), bits, false)?;
-    dib::prepare(&mut img, dib::Blend::Rop(rop));
-    let (img, dst) = dib::clip_blit(&img, src.map(|v| v as i64), dst)?;
-    cv.bitmap(dst, img);
-    Some(())
-}

crates/model/Cargo.toml

@@ -14,4 +14,3 @@ deckcraft-color = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
-unicode-segmentation = { workspace = true }

crates/model/src/anim.rs

@@ -63,7 +63,7 @@ pub static TRANSITIONS: &[(&str, &str, &str, u32, &[&str])] = &[
     ("fracture", "Fracture", "Exciting", 2000, &[]),
     ("crush", "Crush", "Exciting", 2000, &[]),
     ("peelOff", "Peel Off", "Exciting", 1500, &["l", "r"]),
-    ("pageCurlDouble", "Page Curl", "Exciting", 1500, &["l", "r", "singleL", "singleR"]),
+    ("pageCurlDouble", "Page Curl", "Exciting", 1500, &["l", "r"]),
     ("airplane", "Airplane", "Exciting", 2000, &["l", "r"]),
     ("origami", "Origami", "Exciting", 2000, &["l", "r"]),
     ("dissolve", "Dissolve", "Exciting", 1200, &[]),
@@ -72,9 +72,9 @@ pub static TRANSITIONS: &[(&str, &str, &str, u32, &[&str])] = &[
     ("clock", "Clock", "Exciting", 2000, &["clockwise", "counterClockwise", "wedge"]),
     ("ripple", "Ripple", "Exciting", 1400, &["center", "lu", "ru", "ld", "rd"]),
     ("honeycomb", "Honeycomb", "Exciting", 3000, &[]),
-    ("glitter", "Glitter", "Exciting", 2500, &["l", "r", "u", "d", "hexL", "hexR", "hexU", "hexD"]),
+    ("glitter", "Glitter", "Exciting", 2500, &["l", "r", "u", "d"]),
     ("vortex", "Vortex", "Exciting", 3000, &["l", "r", "u", "d"]),
-    ("shred", "Shred", "Exciting", 2000, &["stripsIn", "stripsOut", "particlesIn", "particlesOut"]),
+    ("shred", "Shred", "Exciting", 2000, &["strips", "particles"]),
     ("switch", "Switch", "Exciting", 1250, &["l", "r"]),
     ("flip", "Flip", "Exciting", 1250, &["l", "r"]),
     ("gallery", "Gallery", "Exciting", 1500, &["l", "r"]),
@@ -82,7 +82,7 @@ pub static TRANSITIONS: &[(&str, &str, &str, u32, &[&str])] = &[
     ("doors", "Doors", "Exciting", 1400, &["vert", "horz"]),
     ("box", "Box", "Exciting", 1250, &["l", "r", "u", "d"]),
     ("comb", "Comb", "Exciting", 1000, &["horz", "vert"]),
-    ("zoom", "Zoom", "Exciting", 1000, &["in", "out", "rotate"]),
+    ("zoom", "Zoom", "Exciting", 1000, &["in", "out"]),
     ("random", "Random", "Exciting", 2000, &[]),
     ("pan", "Pan", "Dynamic Content", 1000, &["u", "d", "l", "r"]),
     ("ferris", "Ferris Wheel", "Dynamic Content", 2000, &["l", "r"]),
@@ -93,101 +93,6 @@ pub static TRANSITIONS: &[(&str, &str, &str, u32, &[&str])] = &[
     ("flythrough", "Fly Through", "Dynamic Content", 1000, &["in", "out", "inBounce", "outBounce"]),
 ];
 
-/// The Effect Options label PowerPoint shows for a transition option. Options are stored as the
-/// file format's values: for moving transitions (Push, Wipe, Cover, Pan, Cube…) the direction
-/// things move, so "l" is the effect coming "From Right"; Glitter and the preset effects (Fall
-/// Over, Wind…) name the side itself; Ripple names where the wave heads.
-pub fn transition_option_label(kind: &str, option: &str) -> String {
-    let side = |c: char| match c {
-        'l' => "Left",
-        'r' => "Right",
-        'u' => "Top",
-        _ => "Bottom",
-    };
-    let opposite = |c: char| match c {
-        'l' => 'r',
-        'r' => 'l',
-        'u' => 'd',
-        _ => 'u',
-    };
-    let corner = |o: &str, flip: bool| -> Option<String> {
-        let mut cs = o.chars();
-        let (h, v) = (cs.next()?, cs.next()?);
-        let (h, v) = if flip { (opposite(h), opposite(v)) } else { (h, v) };
-        Some(format!("From {}-{}", side(v), side(h)))
-    };
-    let moving = matches!(
-        kind,
-        "push"
-            | "wipe"
-            | "cover"
-            | "uncover"
-            | "pan"
-            | "vortex"
-            | "cube"
-            | "box"
-            | "rotate"
-            | "orbit"
-            | "gallery"
-            | "conveyor"
-            | "ferris"
-            | "switch"
-            | "flip"
-    );
-    match (kind, option) {
-        (_, "horz") => "Horizontal".into(),
-        (_, "vert") => "Vertical".into(),
-        ("split", o) => format!("{} {}", if o.starts_with("horz") { "Horizontal" } else { "Vertical" }, if o.ends_with("In") { "In" } else { "Out" }),
-        ("fade" | "cut", "throughBlack") => "Through Black".into(),
-        ("fade", _) => "Smoothly".into(),
-        ("cut", _) => "Cut".into(),
-        ("clock", "counterClockwise") => "Counterclockwise".into(),
-        ("clock", "wedge") => "Wedge".into(),
-        ("clock", _) => "Clockwise".into(),
-        ("zoom", "rotate") => "Zoom and Rotate".into(),
-        ("ripple", "center") => "Center".into(),
-        ("ripple", o) => corner(o, true).unwrap_or_else(|| "Center".into()),
-        ("glitter", o) => {
-            let (pat, d) = match o.strip_prefix("hex") {
-                Some(d) => ("Hexagons", d.to_ascii_lowercase()),
-                None => ("Diamonds", o.to_string()),
-            };
-            format!("{pat} From {}", side(d.chars().next().unwrap_or('l')))
-        }
-        ("pageCurlDouble", o) => match o {
-            "singleL" => "Single Left".into(),
-            "singleR" => "Single Right".into(),
-            "r" => "Double Right".into(),
-            _ => "Double Left".into(),
-        },
-        ("shred", o) => {
-            format!("{} {}", if o.starts_with("particles") { "Particles" } else { "Strips" }, if o.ends_with("Out") { "Out" } else { "In" })
-        }
-        ("reveal", o) => format!(
-            "{} {}",
-            if o.starts_with("black") { "Through Black" } else { "Smoothly" },
-            if o.ends_with("Right") { "From Right" } else { "From Left" }
-        ),
-        ("flythrough", o) => {
-            format!("{}{}", if o.starts_with("out") { "Out" } else { "In" }, if o.ends_with("Bounce") { " with Bounce" } else { "" })
-        }
-        ("morph", o) => match o {
-            "words" => "Words".into(),
-            "characters" => "Characters".into(),
-            _ => "Objects".into(),
-        },
-        (_, o) if o.len() == 2 && moving => corner(o, true).unwrap_or_default(),
-        (_, o) if o.len() == 1 && moving => format!("From {}", side(opposite(o.chars().next().unwrap_or('l')))),
-        (_, "l") => "Left".into(),
-        (_, "r") => "Right".into(),
-        (_, "u") => "Top".into(),
-        (_, "d") => "Bottom".into(),
-        (_, "in") => "In".into(),
-        (_, "out") => "Out".into(),
-        (_, o) => o.to_string(),
-    }
-}
-
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum AnimClass {
@@ -386,29 +291,3 @@ pub static ANIMATIONS: &[(&str, &str, AnimClass, u32, u32, &[&str])] = &[
 pub fn animation_info(effect: &str, class: AnimClass) -> Option<&'static (&'static str, &'static str, AnimClass, u32, u32, &'static [&'static str])> {
     ANIMATIONS.iter().find(|a| a.0 == effect && a.2 == class).or_else(|| ANIMATIONS.iter().find(|a| a.0 == effect))
 }
-
-#[cfg(test)]
-mod option_label_tests {
-    use super::*;
-
-    #[test]
-    fn transition_option_labels() {
-        assert_eq!(transition_option_label("push", "l"), "From Right");
-        assert_eq!(transition_option_label("push", "u"), "From Bottom");
-        assert_eq!(transition_option_label("wipe", "r"), "From Left");
-        assert_eq!(transition_option_label("cover", "ru"), "From Bottom-Left");
-        assert_eq!(transition_option_label("ripple", "ru"), "From Bottom-Left");
-        assert_eq!(transition_option_label("glitter", "hexU"), "Hexagons From Top");
-        assert_eq!(transition_option_label("glitter", "l"), "Diamonds From Left");
-        assert_eq!(transition_option_label("wind", "l"), "Left");
-        assert_eq!(transition_option_label("pageCurlDouble", "singleR"), "Single Right");
-        assert_eq!(transition_option_label("shred", "particlesOut"), "Particles Out");
-        assert_eq!(transition_option_label("zoom", "rotate"), "Zoom and Rotate");
-        assert_eq!(transition_option_label("split", "vertIn"), "Vertical In");
-        for (id, _, _, _, opts) in TRANSITIONS {
-            for o in opts.iter() {
-                assert!(!transition_option_label(id, o).is_empty(), "{id}/{o}");
-            }
-        }
-    }
-}

crates/model/src/chart.rs

@@ -134,10 +134,6 @@ pub struct Series {
     /// Combo charts: this series' own type.
     pub kind: Option<ChartType>,
     pub secondary_axis: bool,
-    /// The number format of the series' data labels (Excel code): the labels' own, else the
-    /// source data's.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub number_format: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -148,15 +144,6 @@ pub struct Chart {
     pub categories: Vec<String>,
     pub series: Vec<Series>,
     pub legend: Option<String>,
-    /// `c:legend/c:overlay`: the legend is drawn over the plot instead of shrinking it.
-    pub legend_overlay: bool,
-    /// Text size in points of the axis labels and legend (from their `c:txPr`, else the chart's);
-    /// `None`: the file gives none.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub text_size: Option<f64>,
-    /// Title text size in points (its rich text or `c:txPr`).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub title_size: Option<f64>,
     pub data_labels: bool,
     pub gridlines: bool,
     pub axis_titles: (Option<String>, Option<String>),
@@ -172,20 +159,6 @@ pub struct Chart {
     pub vary_colors: bool,
     pub y_min: Option<f64>,
     pub y_max: Option<f64>,
-    /// The value axis' major unit, when the chart fixes it.
-    pub y_major: Option<f64>,
-    /// The value axis' number format (an Excel format code such as `#,##0` or `0.0%`).
-    pub y_format: Option<String>,
-    /// The value axis is deleted (`c:delete`): no labels, though gridlines may stay.
-    pub y_hidden: bool,
-    /// A combo chart's secondary value axis: bounds, major unit and number format.
-    pub y2_min: Option<f64>,
-    pub y2_max: Option<f64>,
-    pub y2_major: Option<f64>,
-    pub y2_format: Option<String>,
-    pub y2_hidden: bool,
-    /// The chart's language (`c:lang`, e.g. `ru-RU`): digit grouping and decimal mark.
-    pub lang: Option<String>,
     /// Original chart XML part kept for round-trip of unmodelled options.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw: Option<String>,
@@ -199,9 +172,6 @@ impl Default for Chart {
             categories: vec![],
             series: vec![],
             legend: Some("b".into()),
-            legend_overlay: false,
-            text_size: None,
-            title_size: None,
             data_labels: false,
             gridlines: true,
             axis_titles: (None, None),
@@ -216,15 +186,6 @@ impl Default for Chart {
             vary_colors: false,
             y_min: None,
             y_max: None,
-            y_major: None,
-            y_format: None,
-            y_hidden: false,
-            y2_min: None,
-            y2_max: None,
-            y2_major: None,
-            y2_format: None,
-            y2_hidden: false,
-            lang: None,
             raw: None,
         }
     }
@@ -249,81 +210,6 @@ impl Chart {
         c.vary_colors = n_series == 1;
         c
     }
-    /// A series' own chart type: its own in a combo chart (columns when it names none), else the
-    /// chart's.
-    pub fn series_kind(&self, s: &Series) -> ChartType {
-        match (self.kind, s.kind) {
-            (ChartType::Combo, Some(k)) if k != ChartType::Combo => k,
-            (ChartType::Combo, _) => ChartType::Column,
-            (k, _) => k,
-        }
-    }
-
-    /// Whether a series is plotted against the secondary value axis (combo charts only).
-    pub fn on_secondary(&self, s: &Series) -> bool {
-        self.kind == ChartType::Combo && s.secondary_axis
-    }
-
-    /// The value range of one value axis: the primary axis (`y_min`/`y_max` apply), or a combo
-    /// chart's secondary axis. A combo chart stacks only its stacked series. `None` when no series
-    /// uses that axis.
-    pub fn axis_range(&self, secondary: bool) -> Option<(f64, f64)> {
-        if self.kind != ChartType::Combo {
-            return (!secondary).then(|| self.value_range());
-        }
-        let ser: Vec<&Series> = self.series.iter().filter(|s| self.on_secondary(s) == secondary).collect();
-        if ser.is_empty() {
-            return None;
-        }
-        let (mut lo, mut hi) = (0.0_f64, 0.0_f64);
-        let n = ser.iter().map(|s| s.values.len()).max().unwrap_or(0);
-        let mut percent = false;
-        for i in 0..n {
-            let (mut p, mut m) = (0.0, 0.0);
-            for s in &ser {
-                let k = self.series_kind(s);
-                let Some(v) = s.values.get(i).copied().flatten().filter(|v| v.is_finite()) else { continue };
-                if k.percent() {
-                    percent = true;
-                } else if k.stacked() {
-                    if v >= 0.0 { p += v } else { m += v }
-                } else {
-                    hi = hi.max(v);
-                    lo = lo.min(v);
-                }
-            }
-            hi = hi.max(p);
-            lo = lo.min(m);
-        }
-        if percent {
-            hi = hi.max(1.0);
-        }
-        Some(if secondary { (lo, hi) } else { (self.y_min.unwrap_or(lo), self.y_max.unwrap_or(hi)) })
-    }
-
-    /// A value axis' scale — (min, max, major unit) — with at most `max_intervals` intervals:
-    /// the bounds and unit the chart fixes, else PowerPoint's automatic ones (the data plus 5 %
-    /// headroom, rounded out to a 1-2-5 unit). `None` when no series uses the axis.
-    pub fn axis_scale(&self, secondary: bool, max_intervals: usize) -> Option<(f64, f64, f64)> {
-        let (lo, hi) = self.axis_range(secondary)?;
-        let (fmin, fmax, major) = if secondary { (self.y2_min, self.y2_max, self.y2_major) } else { (self.y_min, self.y_max, self.y_major) };
-        let full_percent = !secondary && self.kind.percent();
-        Some(axis_scale(lo, hi, fmin, fmax, major, max_intervals, !full_percent))
-    }
-
-    /// A value axis label in the axis' number format and the chart's language.
-    pub fn axis_label(&self, secondary: bool, v: f64) -> String {
-        let code = if secondary { &self.y2_format } else { &self.y_format };
-        crate::numfmt::format(code.as_deref().unwrap_or("General"), v, self.lang.as_deref())
-    }
-
-    /// A data label of series `s`: its number format, else its axis', in the chart's language.
-    pub fn data_label(&self, s: &Series, v: f64) -> String {
-        let axis = if self.on_secondary(s) { &self.y2_format } else { &self.y_format };
-        let code = s.number_format.as_ref().or(axis.as_ref());
-        crate::numfmt::format(code.map_or("General", String::as_str), v, self.lang.as_deref())
-    }
-
     /// Value range across series (stacked sums for stacked types).
     pub fn value_range(&self) -> (f64, f64) {
         let mut lo: f64 = 0.0;
@@ -356,53 +242,6 @@ impl Chart {
     }
 }
 
-/// The (min, max, major unit) of an axis over the data range [lo, hi]: `fmin`/`fmax`/`major`
-/// where the chart fixes them; otherwise the range takes in zero, gets 5 % headroom (`headroom`)
-/// and rounds out to the smallest 1-2-5 unit giving at most `max_intervals` intervals.
-pub fn axis_scale(
-    lo: f64,
-    hi: f64,
-    fmin: Option<f64>,
-    fmax: Option<f64>,
-    major: Option<f64>,
-    max_intervals: usize,
-    headroom: bool,
-) -> (f64, f64, f64) {
-    // Values past ±1e100 aren't axis values; clamping keeps the arithmetic finite.
-    let fin = |v: Option<f64>| v.filter(|v| v.is_finite()).map(|v| v.clamp(-1e100, 1e100));
-    let (fmin, fmax) = (fin(fmin), fin(fmax));
-    let (lo, hi) = if lo.is_finite() && hi.is_finite() { (lo.min(hi).clamp(-1e100, 1e100), lo.max(hi).clamp(-1e100, 1e100)) } else { (0.0, 1.0) };
-    let mut lo = fmin.unwrap_or(lo.min(0.0));
-    let mut hi = fmax.unwrap_or(hi.max(lo));
-    if hi - lo < 1e-12 {
-        hi = lo + lo.abs().max(1.0);
-    }
-    let span = hi - lo;
-    if headroom && fmax.is_none() && hi > 0.0 {
-        hi += span * 0.05;
-    }
-    if headroom && fmin.is_none() && lo < 0.0 {
-        lo -= span * 0.05;
-    }
-    let n = max_intervals.clamp(1, 50) as f64;
-    let step = match fin(major).filter(|m| *m > 0.0 && (hi - lo) / m <= 1000.0) {
-        Some(m) => m,
-        None => {
-            let mut step = 10f64.powf(((hi - lo) / n).log10().floor());
-            let mut k = 0;
-            // 1, 2, 5, 10, 20… × the magnitude until the intervals fit.
-            while ((hi / step).ceil() - (lo / step).floor()) > n && k < 30 {
-                step *= if matches!(k % 3, 1) { 2.5 } else { 2.0 };
-                k += 1;
-            }
-            step
-        }
-    };
-    let min = fmin.unwrap_or((lo / step + 1e-9).floor() * step);
-    let max = fmax.unwrap_or((hi / step - 1e-9).ceil() * step).max(min + step);
-    (min, max, step)
-}
-
 /// "Nice" axis scale: (min, max, major step) covering [lo, hi].
 pub fn nice_scale(lo: f64, hi: f64) -> (f64, f64, f64) {
     let (lo, hi) = if lo.is_finite() && hi.is_finite() { (lo.min(hi), lo.max(hi)) } else { (0.0, 1.0) };
@@ -441,67 +280,6 @@ mod tests {
         assert!(b > a);
     }
 
-    #[test]
-    fn automatic_axis_scales_like_powerpoint() {
-        // Weekly spend up to ~715 000 on a plot with room for 9 intervals: 0–800 000 by 100 000.
-        assert_eq!(axis_scale(0.0, 715_000.0, None, None, None, 9, true), (0.0, 800_000.0, 100_000.0));
-        // Clicks up to 6 600: 0–7 000 by 1 000.
-        assert_eq!(axis_scale(0.0, 6_600.0, None, None, None, 9, true), (0.0, 7_000.0, 1_000.0));
-        // Fewer intervals fit on a short axis.
-        assert_eq!(axis_scale(0.0, 6_600.0, None, None, None, 4, true), (0.0, 8_000.0, 2_000.0));
-        // Negative data gets room below; fixed bounds and unit are kept.
-        let (min, max, _) = axis_scale(-30.0, 100.0, None, None, None, 8, true);
-        assert!(min <= -30.0 && max >= 105.0);
-        assert_eq!(axis_scale(0.0, 715_000.0, Some(100_000.0), Some(750_000.0), Some(50_000.0), 9, true), (100_000.0, 750_000.0, 50_000.0));
-        // 100 % stacked stays at 0–1 without headroom.
-        assert_eq!(axis_scale(0.0, 1.0, None, None, None, 5, false), (0.0, 1.0, 0.2));
-        // Nonsense never loops or divides by zero.
-        for (lo, hi) in [(f64::NAN, 1.0), (5.0, 5.0), (0.0, 0.0), (-1e300, 1e300)] {
-            let (a, b, s) = axis_scale(lo, hi, None, None, Some(0.0), 0, true);
-            assert!(a.is_finite() && b.is_finite() && s > 0.0 && b > a, "{lo} {hi}: {a} {b} {s}");
-        }
-    }
-
-    #[test]
-    fn axis_labels_use_the_format_and_language() {
-        let mut c = Chart::sample(ChartType::Column);
-        c.y_format = Some(r#"_-* #\ ##0\ "₽"_-;\-* #\ ##0\ "₽"_-;_-* "-"??\ "₽"_-;_-@_-"#.into());
-        c.lang = Some("ru-RU".into());
-        assert_eq!(c.axis_label(false, 800_000.0), "800\u{a0}000 ₽");
-        assert_eq!(c.axis_label(false, 0.0), "- ₽");
-        // No format: General.
-        assert_eq!(c.axis_label(true, 2.5), "2,5");
-        c.lang = None;
-        assert_eq!(c.axis_label(true, 2.5), "2.5");
-        // Data labels: the series' format, else the axis'.
-        c.lang = Some("ru-RU".into());
-        c.series[0].number_format = Some(r#"#,##0\ "₽""#.into());
-        assert_eq!(c.data_label(&c.series[0], 516_600_000.0), "516\u{a0}600\u{a0}000 ₽");
-        assert_eq!(c.data_label(&c.series[1], 0.0), "- ₽");
-    }
-
-    #[test]
-    fn combo_axis_ranges() {
-        // Spend in columns on the primary axis, clicks as a line on the secondary one.
-        let mut c = Chart::sample(ChartType::Combo);
-        c.series.truncate(2);
-        c.series[0].kind = Some(ChartType::Column);
-        c.series[0].values = vec![Some(200_000.0), Some(310_000.0)];
-        c.series[1].kind = Some(ChartType::Line);
-        c.series[1].values = vec![Some(6_000.0), Some(7_400.0)];
-        c.series[1].secondary_axis = true;
-        assert_eq!(c.axis_range(false), Some((0.0, 310_000.0)));
-        assert_eq!(c.axis_range(true), Some((0.0, 7_400.0)));
-        assert_eq!(c.series_kind(&c.series[1]), ChartType::Line);
-        // Without a secondary series there is no secondary axis; a non-combo chart never has one.
-        c.series[1].secondary_axis = false;
-        assert_eq!(c.axis_range(true), None);
-        let col = Chart::sample(ChartType::Column);
-        assert_eq!(col.axis_range(false), Some(col.value_range()));
-        assert_eq!(col.axis_range(true), None);
-        assert!(!col.on_secondary(&col.series[0]));
-    }
-
     #[test]
     fn sample_ranges() {
         let c = Chart::sample(ChartType::StackedColumn);

crates/model/src/defaults.rs

@@ -243,7 +243,6 @@ pub fn build_master(size: Size, theme: Theme, first_id: u32) -> (Master, u32) {
             background: None,
             show_master_shapes: true,
             preserve: true,
-            color_map: None,
             raw_ext: None,
         });
     };
@@ -512,7 +511,6 @@ pub fn blank_presentation(size: Size, theme: Theme, title_slide: bool) -> Presen
         first_slide_number: 1,
         next_id: next.max(256),
         embedded_fonts: vec![],
-        table_styles: vec![],
         raw_ext: None,
     };
     if title_slide {

crates/model/src/edit.rs

@@ -2,7 +2,6 @@
 //! with `\n` splits paragraphs; formatting a range splits runs at its ends.
 
 use crate::text::{Paragraph, Run, RunKind, RunProps, TextBody};
-use crate::words;
 
 /// (paragraph, char offset in the paragraph).
 pub type Pos = (usize, usize);
@@ -276,107 +275,63 @@ pub fn insert_body(body: &mut TextBody, pos: Pos, src: &TextBody) -> Pos {
     caret
 }
 
-fn para_text(body: &TextBody, pi: usize) -> String {
-    body.paragraphs.get(pi).map(Paragraph::text).unwrap_or_default()
+fn is_word(c: char) -> bool {
+    c.is_alphanumeric() || c == '_' || c == '\''
 }
 
-/// The word a double-click selects around `pos` (see [`words::word_at`]): the word without its
-/// trailing spaces, as PowerPoint selects it.
+/// Word boundaries around `pos` (double-click selection).
 pub fn word_at(body: &TextBody, pos: Pos) -> (Pos, Pos) {
     let (pi, ch) = clamp(body, pos);
-    let (s, e) = words::word_at(&para_text(body, pi), ch);
-    ((pi, s), (pi, e))
+    let t: Vec<char> = body.paragraphs.get(pi).map(|p| p.text().chars().collect()).unwrap_or_default();
+    if t.is_empty() {
+        return ((pi, 0), (pi, 0));
+    }
+    let at = ch.min(t.len().saturating_sub(1));
+    let w = t.get(at).copied().is_some_and(is_word);
+    let mut s = at;
+    while s > 0 && t.get(s - 1).copied().is_some_and(|c| is_word(c) == w && !c.is_whitespace() || (w && is_word(c))) {
+        s -= 1;
+    }
+    let mut e = at;
+    while e < t.len() && t.get(e).copied().is_some_and(|c| is_word(c) == w && (w || !c.is_whitespace())) {
+        e += 1;
+    }
+    // Include trailing spaces after a word.
+    while w && e < t.len() && t.get(e) == Some(&' ') {
+        e += 1;
+    }
+    ((pi, s), (pi, e.max(s)))
 }
 
-/// Next/previous word stop (Ctrl+Right/Left on Windows, Option+arrows on the Mac). At the end of
-/// a paragraph Ctrl+Right goes to the start of the next one; at its start Ctrl+Left goes to the
-/// end of the previous one.
+/// Next/previous word start (Option/Ctrl + arrows).
 pub fn word_move(body: &TextBody, pos: Pos, forward: bool) -> Pos {
     let (pi, ch) = clamp(body, pos);
-    let t = para_text(body, pi);
+    let t: Vec<char> = body.paragraphs.get(pi).map(|p| p.text().chars().collect()).unwrap_or_default();
     if forward {
-        match words::next_stop(&t, ch) {
-            Some(s) => (pi, s),
-            None if pi + 1 < body.paragraphs.len() => (pi + 1, 0),
-            None => (pi, ch),
+        if ch >= t.len() {
+            return if pi + 1 < body.paragraphs.len() { (pi + 1, 0) } else { (pi, ch) };
         }
+        let mut i = ch;
+        while i < t.len() && t.get(i).copied().is_some_and(is_word) {
+            i += 1;
+        }
+        while i < t.len() && !t.get(i).copied().is_some_and(is_word) {
+            i += 1;
+        }
+        (pi, i)
     } else {
-        match words::prev_stop(&t, ch) {
-            Some(s) => (pi, s),
-            None if pi > 0 => (pi - 1, body.paragraphs.get(pi - 1).map(Paragraph::char_len).unwrap_or(0)),
-            None => (pi, 0),
+        if ch == 0 {
+            return if pi > 0 { (pi - 1, body.paragraphs.get(pi - 1).map(Paragraph::char_len).unwrap_or(0)) } else { (0, 0) };
         }
-    }
-}
-
-/// Ctrl+Up: the start of the paragraph, or of the previous one when already there.
-pub fn para_up(body: &TextBody, pos: Pos) -> Pos {
-    let (pi, ch) = clamp(body, pos);
-    if ch > 0 { (pi, 0) } else { (pi.saturating_sub(1), 0) }
-}
-
-/// Ctrl+Down: the start of the next paragraph, or the end of the last one.
-pub fn para_down(body: &TextBody, pos: Pos) -> Pos {
-    let (pi, _) = clamp(body, pos);
-    if pi + 1 < body.paragraphs.len() { (pi + 1, 0) } else { (pi, body.paragraphs.get(pi).map(Paragraph::char_len).unwrap_or(0)) }
-}
-
-/// Delete a word from `pos` as Ctrl+Backspace (`forward == false`) or Ctrl+Delete does in
-/// PowerPoint; returns the caret.
-///
-/// Ctrl+Backspace deletes back to the previous word stop (at a paragraph's start it joins the
-/// paragraph to the one before). Ctrl+Delete deletes the rest of the word, or the spaces after a
-/// word and the next word, or up to the next stop (see [`words::delete_forward_end`]), then
-/// tidies the spacing as PowerPoint's smart cut does: spaces left before closing punctuation or
-/// at the end of the paragraph after a word go, and sentence punctuation left against a word
-/// gets a space. At a paragraph's end it joins the next paragraph.
-pub fn delete_word(body: &mut TextBody, pos: Pos, forward: bool) -> Pos {
-    if body.paragraphs.is_empty() {
-        return (0, 0);
-    }
-    let (pi, ch) = clamp(body, pos);
-    let t = para_text(body, pi);
-    if !forward {
-        let to = match words::prev_stop(&t, ch) {
-            Some(s) => (pi, s),
-            None => char_move(body, (pi, ch), false),
-        };
-        return delete(body, to, (pi, ch));
-    }
-    let Some(e) = words::delete_forward_end(&t, ch) else {
-        let to = char_move(body, (pi, ch), true);
-        return delete(body, (pi, ch), to);
-    };
-    let at = delete(body, (pi, ch), (pi, e));
-    smart_space(body, at)
-}
-
-/// PowerPoint's smart-cut spacing after a word was deleted at `at`; returns the caret.
-fn smart_space(body: &mut TextBody, at: Pos) -> Pos {
-    let (pi, s) = at;
-    let chars: Vec<char> = para_text(body, pi).chars().collect();
-    let after = chars.get(s).copied();
-    let before = s.checked_sub(1).and_then(|i| chars.get(i)).copied();
-    if after.is_none_or(words::is_closing_punct) && before.is_some_and(|c| c == ' ') {
-        let mut w = s;
-        while w > 0 && chars.get(w - 1) == Some(&' ') {
-            w -= 1;
+        let mut i = ch;
+        while i > 0 && !t.get(i - 1).copied().is_some_and(is_word) {
+            i -= 1;
         }
-        if w > 0 && chars.get(w - 1).is_some_and(|c| c.is_alphanumeric()) {
-            return delete(body, (pi, w), (pi, s));
+        while i > 0 && t.get(i - 1).copied().is_some_and(is_word) {
+            i -= 1;
         }
-        return at;
+        (pi, i)
     }
-    if let (Some(b), Some(a)) = (before, after)
-        && words::is_sentence_punct(b)
-        && a.is_alphanumeric()
-    {
-        let digits = s >= 2 && chars.get(s - 2).is_some_and(|c| c.is_numeric()) && a.is_numeric();
-        if !digits {
-            return insert(body, at, " ", None);
-        }
-    }
-    at
 }
 
 /// One character left/right across paragraph boundaries.
@@ -406,18 +361,6 @@ pub fn end(body: &TextBody) -> Pos {
     (pi, body.paragraphs.get(pi).map(Paragraph::char_len).unwrap_or(0))
 }
 
-/// The case Shift+F3 changes `s` to next, as PowerPoint cycles it: lowercase → Capitalize Each
-/// Word → UPPERCASE → lowercase; any other mix goes to UPPERCASE first.
-pub fn next_case(s: &str) -> &'static str {
-    if s == s.to_lowercase() && s.chars().any(char::is_alphabetic) {
-        "title"
-    } else if s == s.to_uppercase() && s.chars().any(char::is_alphabetic) {
-        "lower"
-    } else {
-        "upper"
-    }
-}
-
 /// Change case: `upper`, `lower`, `sentence`, `title`, `toggle`.
 pub fn change_case(s: &str, mode: &str) -> String {
     match mode {
@@ -513,7 +456,7 @@ mod tests {
     #[test]
     fn words_and_moves() {
         let b = body("Hello brave world");
-        assert_eq!(word_at(&b, (0, 7)), ((0, 6), (0, 11)));
+        assert_eq!(word_at(&b, (0, 7)), ((0, 6), (0, 12)));
         assert_eq!(word_move(&b, (0, 0), true), (0, 6));
         assert_eq!(word_move(&b, (0, 8), false), (0, 6));
         assert_eq!(char_move(&b, (0, 17), true), (0, 17));
@@ -529,150 +472,4 @@ mod tests {
         assert_eq!(b.paragraphs[0].char_len(), 3);
         assert_eq!(b.paragraphs.len(), 1);
     }
-
-    /// Ctrl+Backspace / Ctrl+Delete from `at`: the text and caret after (PowerPoint's results).
-    fn del_word(text: &str, at: Pos, forward: bool) -> (String, Pos) {
-        let mut b = body(text);
-        let c = delete_word(&mut b, at, forward);
-        (b.text(), c)
-    }
-
-    #[test]
-    fn ctrl_backspace_like_powerpoint() {
-        let t = "ab   cd...ef gh";
-        let want = [
-            ("ab   cd...ef gh", 0),
-            ("b   cd...ef gh", 0),
-            ("   cd...ef gh", 0),
-            ("  cd...ef gh", 0),
-            (" cd...ef gh", 0),
-            ("cd...ef gh", 0),
-            ("ab   d...ef gh", 5),
-            ("ab   ...ef gh", 5),
-            ("ab   cd..ef gh", 7),
-            ("ab   cd.ef gh", 7),
-            ("ab   cdef gh", 7),
-            ("ab   cd...f gh", 10),
-            ("ab   cd... gh", 10),
-            ("ab   cd...gh", 10),
-            ("ab   cd...ef h", 13),
-            ("ab   cd...ef ", 13),
-        ];
-        for (c, (txt, caret)) in want.iter().enumerate() {
-            assert_eq!(del_word(t, (0, c), false), (txt.to_string(), (0, *caret)), "caret {c}");
-        }
-        let w = "Hello world  foo, bar\nnext para";
-        assert_eq!(del_word(w, (0, 12), false), ("Hello  foo, bar\nnext para".into(), (0, 6)));
-        assert_eq!(del_word(w, (0, 17), false), ("Hello world  foo bar\nnext para".into(), (0, 16)));
-        // At a paragraph's start it joins the paragraph before.
-        assert_eq!(del_word(w, (1, 0), false), ("Hello world  foo, barnext para".into(), (0, 21)));
-        assert_eq!(del_word("ab\n  cd", (1, 2), false), ("ab\ncd".into(), (1, 0)));
-        // A line break is a word of its own.
-        let mut b = body("ab");
-        insert(&mut b, (0, 2), "\u{b}cd", None);
-        assert_eq!(delete_word(&mut b, (0, 3), false), (0, 2));
-        assert_eq!(b.text(), "abcd");
-        let mut b = body("ab");
-        insert(&mut b, (0, 2), "\u{b}cd", None);
-        assert_eq!(delete_word(&mut b, (0, 2), true), (0, 2));
-        assert_eq!(b.text(), "abcd");
-        assert_eq!(del_word("x", (0, 0), false), ("x".into(), (0, 0)));
-        // Emoji sequences and combining marks are never split.
-        assert_eq!(del_word("a 👨\u{200d}👩\u{200d}👧", (0, 7), false), ("a ".into(), (0, 2)));
-        assert_eq!(del_word("ce\u{301}te x", (0, 5), false), (" x".into(), (0, 0)));
-        assert_eq!(del_word("ce\u{301}te x", (0, 6), false), ("x".into(), (0, 0)));
-        // Each CJK character is a word.
-        assert_eq!(del_word("日本語", (0, 3), false), ("日本".into(), (0, 2)));
-    }
-
-    #[test]
-    fn ctrl_delete_like_powerpoint() {
-        let t = "ab   cd...ef gh";
-        let want = [
-            ("cd...ef gh", 0),
-            ("a   cd...ef gh", 1),
-            ("ab...ef gh", 2),
-            ("ab cd...ef gh", 3),
-            ("ab  cd...ef gh", 4),
-            ("ab...ef gh", 2),
-            ("ab   c...ef gh", 6),
-            ("ab   cdef gh", 7),
-            ("ab   cd. ef gh", 9),
-            ("ab   cd.. ef gh", 10),
-            ("ab   cd... gh", 11),
-            ("ab   cd...e gh", 11),
-            ("ab   cd...ef", 12),
-            ("ab   cd...ef", 12),
-            ("ab   cd...ef g", 14),
-            ("ab   cd...ef gh", 15),
-        ];
-        for (c, (txt, caret)) in want.iter().enumerate() {
-            assert_eq!(del_word(t, (0, c), true), (txt.to_string(), (0, *caret)), "caret {c}");
-        }
-        let w = "Hello world  foo, bar\nnext para";
-        let want = [
-            (0, "world  foo, bar\nnext para", 0),
-            (2, "He world  foo, bar\nnext para", 2),
-            (5, "Hello  foo, bar\nnext para", 5),
-            (6, "Hello foo, bar\nnext para", 6),
-            (8, "Hello wo  foo, bar\nnext para", 8),
-            (11, "Hello world, bar\nnext para", 11),
-            (12, "Hello world foo, bar\nnext para", 12),
-            (16, "Hello world  foobar\nnext para", 16),
-            (17, "Hello world  foo,\nnext para", 17),
-            (18, "Hello world  foo, \nnext para", 18),
-            (21, "Hello world  foo, barnext para", 21),
-        ];
-        for (c, txt, caret) in want {
-            assert_eq!(del_word(w, (0, c), true), (txt.to_string(), (0, caret)), "caret {c}");
-        }
-        assert_eq!(del_word(w, (1, 0), true), ("Hello world  foo, bar\npara".into(), (1, 0)));
-        assert_eq!(del_word(w, (1, 2), true), ("Hello world  foo, bar\nne para".into(), (1, 2)));
-        assert_eq!(del_word("ab  \ncd", (0, 2), true), ("ab\ncd".into(), (0, 2)));
-        assert_eq!(del_word("ab  \ncd", (0, 3), true), ("ab\ncd".into(), (0, 2)));
-        assert_eq!(del_word("ab\t cd", (0, 2), true), ("ab cd".into(), (0, 2)));
-        assert_eq!(del_word("ab cd(x) ef", (0, 3), true), ("ab (x) ef".into(), (0, 3)));
-        assert_eq!(del_word("ab cd, ef", (0, 3), true), ("ab, ef".into(), (0, 2)));
-        assert_eq!(del_word("ab. (cd) ef", (0, 5), true), ("ab. () ef".into(), (0, 5)));
-        assert_eq!(del_word("ab \"cd\" ef", (0, 4), true), ("ab \"\" ef".into(), (0, 4)));
-        assert_eq!(del_word("ab, cd", (0, 4), true), ("ab, ".into(), (0, 4)));
-        // Right-to-left text deletes in logical order like any other.
-        assert_eq!(del_word("مرحبا بالعالم hello", (0, 6), true), ("مرحبا hello".into(), (0, 6)));
-        assert_eq!(del_word("مرحبا بالعالم hello", (0, 8), false), ("مرحبا لعالم hello".into(), (0, 6)));
-        // Numbers keep their separators: no space is pushed into "3.14".
-        assert_eq!(del_word("3.x 14", (0, 2), true), ("3.14".into(), (0, 2)));
-        // Hostile positions clamp.
-        assert_eq!(del_word("ab", (9, 9), true).0, "ab");
-        assert_eq!(del_word("", (0, 0), false).0, "");
-        let mut empty = TextBody::default();
-        assert_eq!(delete_word(&mut empty, (3, 3), true), (0, 0));
-    }
-
-    #[test]
-    fn paragraph_moves() {
-        let b = body("one two\nthree\n\nfour");
-        assert_eq!(para_down(&b, (0, 2)), (1, 0));
-        assert_eq!(para_down(&b, (1, 0)), (2, 0));
-        assert_eq!(para_down(&b, (3, 1)), (3, 4));
-        assert_eq!(para_up(&b, (3, 2)), (3, 0));
-        assert_eq!(para_up(&b, (3, 0)), (2, 0));
-        assert_eq!(para_up(&b, (0, 0)), (0, 0));
-        assert_eq!(word_move(&b, (0, 4), true), (0, 7));
-        assert_eq!(word_move(&b, (0, 7), true), (1, 0));
-        assert_eq!(word_move(&b, (1, 0), false), (0, 7));
-        assert_eq!(word_move(&b, (2, 0), true), (3, 0));
-        assert_eq!(word_move(&b, (3, 4), true), (3, 4));
-        assert_eq!(word_move(&b, (0, 0), false), (0, 0));
-    }
-
-    #[test]
-    fn case_cycle() {
-        assert_eq!(next_case("hello world"), "title");
-        assert_eq!(next_case("Hello World"), "upper");
-        assert_eq!(next_case("HELLO WORLD"), "lower");
-        assert_eq!(next_case("Hello world"), "upper");
-        assert_eq!(next_case("hELLO wORLD"), "upper");
-        assert_eq!(next_case("hello. world is HERE"), "upper");
-        assert_eq!(next_case("123"), "upper");
-    }
 }

crates/model/src/lib.rs

@@ -11,13 +11,11 @@ pub mod anim;
 pub mod chart;
 pub mod defaults;
 pub mod edit;
-pub mod numfmt;
 pub mod resolve;
 pub mod style;
 pub mod table;
 pub mod text;
 pub mod theme;
-pub mod words;
 
 use std::sync::Arc;
 
@@ -445,46 +443,6 @@ pub fn find_shape_mut(shapes: &mut [Shape], id: ShapeId) -> Option<&mut Shape> {
     rec(shapes, id, 0)
 }
 
-/// The list holding `id` among its siblings: the tree's top level, or a group's children.
-pub fn sibling_list_mut(shapes: &mut Vec<Shape>, id: ShapeId) -> Option<&mut Vec<Shape>> {
-    fn rec(shapes: &mut Vec<Shape>, id: ShapeId, depth: usize) -> Option<&mut Vec<Shape>> {
-        if depth > 64 {
-            return None;
-        }
-        if shapes.iter().any(|s| s.id == id) {
-            return Some(shapes);
-        }
-        for s in shapes.iter_mut() {
-            if let ShapeKind::Group { children, .. } = &mut s.kind
-                && let Some(f) = rec(children, id, depth + 1)
-            {
-                return Some(f);
-            }
-        }
-        None
-    }
-    rec(shapes, id, 0)
-}
-
-/// The group directly holding `id`: `Some(None)` for a top-level shape, `None` when absent.
-pub fn parent_of(shapes: &[Shape], id: ShapeId) -> Option<Option<ShapeId>> {
-    fn rec(shapes: &[Shape], parent: Option<ShapeId>, id: ShapeId, depth: usize) -> Option<Option<ShapeId>> {
-        if depth > 64 {
-            return None;
-        }
-        for s in shapes {
-            if s.id == id {
-                return Some(parent);
-            }
-            if let Some(f) = rec(s.children(), Some(s.id), id, depth + 1) {
-                return Some(f);
-            }
-        }
-        None
-    }
-    rec(shapes, None, id, 0)
-}
-
 /// Background of a slide, layout or master.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", tag = "kind")]
@@ -530,10 +488,6 @@ pub struct Slide {
     /// Speaker notes.
     pub notes: TextBody,
     pub comments: Vec<Comment>,
-    /// `clrMapOvr`: a colour map replacing the layout's or master's (`bg1`→`dk1`…); None follows
-    /// the layout.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub color_map: Option<Vec<(String, String)>>,
     /// Unmodelled XML kept for round-trip (custom data, tags).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_ext: Option<String>,
@@ -553,7 +507,6 @@ impl Default for Slide {
             animations: vec![],
             notes: TextBody::default(),
             comments: vec![],
-            color_map: None,
             raw_ext: None,
         }
     }
@@ -643,10 +596,6 @@ pub struct Layout {
     pub background: Option<Background>,
     pub show_master_shapes: bool,
     pub preserve: bool,
-    /// `clrMapOvr`: a colour map replacing the master's for this layout and the slides using it
-    /// (dark "section" layouts map `bg1` to `dk1`); None follows the master.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub color_map: Option<Vec<(String, String)>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_ext: Option<String>,
 }
@@ -692,17 +641,24 @@ impl Master {
     }
     /// Resolve `bg1`/`tx1`/`bg2`/`tx2` through the colour map.
     pub fn map_slot(&self, slot: SchemeSlot) -> SchemeSlot {
-        map_slot(&self.color_map, slot)
+        let key = match slot {
+            SchemeSlot::Bg1 => "bg1",
+            SchemeSlot::Tx1 => "tx1",
+            SchemeSlot::Bg2 => "bg2",
+            SchemeSlot::Tx2 => "tx2",
+            other => return other,
+        };
+        self.color_map.iter().find(|(k, _)| k == key).and_then(|(_, v)| SchemeSlot::from_xml(v)).unwrap_or(match slot {
+            SchemeSlot::Bg1 => SchemeSlot::Lt1,
+            SchemeSlot::Tx1 => SchemeSlot::Dk1,
+            SchemeSlot::Bg2 => SchemeSlot::Lt2,
+            _ => SchemeSlot::Dk2,
+        })
     }
     /// The theme's colour scheme with the colour map applied (`bg1`… resolve to mapped colours).
     pub fn scheme(&self) -> ColorScheme {
-        self.scheme_with(&self.color_map)
-    }
-    /// The theme's colour scheme with `map` (a layout's or slide's override, or the master's own)
-    /// applied.
-    pub fn scheme_with(&self, map: &[(String, String)]) -> ColorScheme {
         let mut s = self.theme.colors.clone();
-        if map.is_empty() {
+        if self.color_map.is_empty() {
             return s;
         }
         let base = self.theme.colors.clone();
@@ -712,30 +668,12 @@ impl Master {
             (SchemeSlot::Bg2, SchemeSlot::Lt2),
             (SchemeSlot::Tx2, SchemeSlot::Dk2),
         ] {
-            s.set(slot, base.get(map_slot(map, alias)));
+            s.set(slot, base.get(self.map_slot(alias)));
         }
         s
     }
 }
 
-/// Resolve `bg1`/`tx1`/`bg2`/`tx2` through the colour map `map` (the default mapping when it has
-/// no entry).
-pub fn map_slot(map: &[(String, String)], slot: SchemeSlot) -> SchemeSlot {
-    let key = match slot {
-        SchemeSlot::Bg1 => "bg1",
-        SchemeSlot::Tx1 => "tx1",
-        SchemeSlot::Bg2 => "bg2",
-        SchemeSlot::Tx2 => "tx2",
-        other => return other,
-    };
-    map.iter().find(|(k, _)| k == key).and_then(|(_, v)| SchemeSlot::from_xml(v)).unwrap_or(match slot {
-        SchemeSlot::Bg1 => SchemeSlot::Lt1,
-        SchemeSlot::Tx1 => SchemeSlot::Dk1,
-        SchemeSlot::Bg2 => SchemeSlot::Lt2,
-        _ => SchemeSlot::Dk2,
-    })
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Section {
@@ -840,9 +778,6 @@ pub struct Presentation {
     pub next_id: u32,
     /// Embedded fonts (family names; bytes in `media`).
     pub embedded_fonts: Vec<(String, MediaId)>,
-    /// Table styles defined in the file (`ppt/tableStyles.xml`).
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub table_styles: Vec<table::TableStyleDef>,
     /// Unmodelled presentation-level XML kept for round-trip.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_ext: Option<String>,

crates/model/src/numfmt.rs

@@ -1,256 +0,0 @@
-//! Number formats: Excel format codes (`#,##0`, `0.0%`, `_-* # ##0 "₽"_-;…`, `General`) as chart
-//! axes and data labels show them, in the chart's language (digit grouping and decimal mark).
-
-/// Digit grouping and decimal mark for a language tag (`ru-RU`, `de-DE`, `en-US`).
-fn marks(lang: Option<&str>) -> (char, char) {
-    let l = lang.unwrap_or("en").split(['-', '_']).next().unwrap_or("en").to_ascii_lowercase();
-    match l.as_str() {
-        // Space-grouped, comma decimal.
-        "ru" | "uk" | "be" | "kk" | "fr" | "pl" | "cs" | "sk" | "sv" | "fi" | "nb" | "nn" | "no" | "bg" | "lt" | "lv" | "et" | "hu" | "uz" | "hy"
-        | "ka" | "az" => ('\u{a0}', ','),
-        // Dot-grouped, comma decimal.
-        "de" | "es" | "it" | "pt" | "nl" | "da" | "tr" | "el" | "ro" | "id" | "sr" | "hr" | "sl" | "vi" => ('.', ','),
-        _ => (',', '.'),
-    }
-}
-
-#[derive(Debug, PartialEq)]
-enum Tok {
-    /// Text shown as is.
-    Lit(String),
-    /// A digit placeholder: `0`, `#` or `?`.
-    Digit(char),
-    Dot,
-    Comma,
-    Percent,
-}
-
-/// A section's tokens (`[$₽-419]` gives its symbol; colours, conditions and locales drop out).
-fn tokens(section: &str) -> Vec<Tok> {
-    let mut out = vec![];
-    let mut it = section.chars().peekable();
-    while let Some(c) = it.next() {
-        match c {
-            '"' => {
-                let mut s = String::new();
-                for d in it.by_ref() {
-                    if d == '"' {
-                        break;
-                    }
-                    s.push(d);
-                }
-                out.push(Tok::Lit(s));
-            }
-            '\\' => {
-                if let Some(d) = it.next() {
-                    out.push(Tok::Lit(d.to_string()));
-                }
-            }
-            // Padding the width of the next character: a space.
-            '_' => {
-                it.next();
-                out.push(Tok::Lit(" ".into()));
-            }
-            // Repeat-to-fill: nothing on an axis.
-            '*' => {
-                it.next();
-            }
-            '[' => {
-                let mut s = String::new();
-                for d in it.by_ref() {
-                    if d == ']' {
-                        break;
-                    }
-                    s.push(d);
-                }
-                if let Some(sym) = s.strip_prefix('$') {
-                    let sym = sym.split('-').next().unwrap_or("");
-                    if !sym.is_empty() {
-                        out.push(Tok::Lit(sym.to_string()));
-                    }
-                }
-            }
-            '0' | '#' | '?' => out.push(Tok::Digit(c)),
-            '.' => out.push(Tok::Dot),
-            ',' => out.push(Tok::Comma),
-            '%' => out.push(Tok::Percent),
-            '@' => {}
-            _ => out.push(Tok::Lit(c.to_string())),
-        }
-    }
-    out
-}
-
-/// The format's sections split at `;` (outside quotes, brackets and escapes).
-fn sections(code: &str) -> Vec<&str> {
-    let mut out = vec![];
-    let (mut start, mut quoted, mut bracket, mut escaped) = (0, false, false, false);
-    for (i, c) in code.char_indices() {
-        if escaped {
-            escaped = false;
-            continue;
-        }
-        match c {
-            '\\' if !quoted => escaped = true,
-            '"' => quoted = !quoted,
-            '[' if !quoted => bracket = true,
-            ']' if !quoted => bracket = false,
-            ';' if !quoted && !bracket => {
-                out.push(code.get(start..i).unwrap_or(""));
-                start = i + 1;
-            }
-            _ => {}
-        }
-    }
-    out.push(code.get(start..).unwrap_or(""));
-    out
-}
-
-/// `v` in the General format: up to 10 significant digits, no grouping.
-fn general(v: f64, dec: char) -> String {
-    if v == 0.0 {
-        return "0".into();
-    }
-    let a = v.abs();
-    let s = if !(1e-9..1e11).contains(&a) {
-        format!("{v:.5E}")
-    } else {
-        let digits = (10 - (a.log10().floor() as i32 + 1)).clamp(0, 10) as usize;
-        let s = format!("{v:.digits$}");
-        if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.').to_string() } else { s }
-    };
-    s.replace('.', &dec.to_string())
-}
-
-/// Group an integer's digits in threes with `sep`.
-fn group(digits: &str, sep: char) -> String {
-    let n = digits.chars().count();
-    let mut out = String::new();
-    for (i, d) in digits.chars().enumerate() {
-        if i > 0 && (n - i).is_multiple_of(3) {
-            out.push(sep);
-        }
-        out.push(d);
-    }
-    out
-}
-
-/// `v` formatted with the Excel number format `code` in language `lang` (axis labels: the text
-/// section of a format doesn't apply).
-pub fn format(code: &str, v: f64, lang: Option<&str>) -> String {
-    let (sep, dec) = marks(lang);
-    if !v.is_finite() {
-        return String::new();
-    }
-    let secs = sections(code);
-    // The section for the value's sign; a negative or zero section shows the value unsigned.
-    let (sec, v, minus) = match (secs.as_slice(), v) {
-        ([_, neg, ..], v) if v < 0.0 => (*neg, -v, false),
-        ([_, _, zero, ..], v) if v == 0.0 => (*zero, v, false),
-        ([pos, ..], v) => (*pos, v.abs(), v < 0.0),
-        ([], v) => ("General", v.abs(), v < 0.0),
-    };
-    if sec.trim().eq_ignore_ascii_case("general") || sec.trim().is_empty() {
-        let s = general(v, dec);
-        return if minus { format!("-{s}") } else { s };
-    }
-    let toks = tokens(sec);
-    let first = toks.iter().position(|t| matches!(t, Tok::Digit(_)));
-    let last = toks.iter().rposition(|t| matches!(t, Tok::Digit(_)));
-    let (Some(first), Some(last)) = (first, last) else {
-        // No digits: just the section's text ("-" for zero, a label).
-        let s: String = toks.iter().filter_map(|t| if let Tok::Lit(s) = t { Some(s.as_str()) } else { None }).collect();
-        return s.trim().to_string();
-    };
-    let percent = toks.contains(&Tok::Percent);
-    let number = toks.get(first..=last).unwrap_or(&[]);
-    let dot = number.iter().position(|t| *t == Tok::Dot);
-    let (int_part, frac_part) = match dot {
-        Some(d) => (number.get(..d).unwrap_or(&[]), number.get(d + 1..).unwrap_or(&[])),
-        None => (number, &[][..]),
-    };
-    // Grouping: a comma (or the locale's space, written literally) between integer digits.
-    let grouping = int_part.iter().any(|t| *t == Tok::Comma || matches!(t, Tok::Lit(s) if s.trim().is_empty()));
-    // Commas right after the last digit scale by a thousand each (`#,##0,` = thousands).
-    let after = toks.get(last + 1..).unwrap_or(&[]);
-    let scale_commas = if dot.is_none() { after.iter().take_while(|t| **t == Tok::Comma).count() } else { 0 };
-    let min_int = int_part.iter().filter(|t| **t == Tok::Digit('0')).count();
-    let frac_digits: Vec<char> = frac_part.iter().filter_map(|t| if let Tok::Digit(c) = t { Some(*c) } else { None }).collect();
-    let max_frac = frac_digits.len();
-    let min_frac = frac_digits.iter().filter(|c| **c == '0').count();
-    let mut x = v * if percent { 100.0 } else { 1.0 } / 1000f64.powi(scale_commas as i32);
-    if !x.is_finite() {
-        x = 0.0;
-    }
-    let s = format!("{x:.max_frac$}");
-    let (ip, fp) = s.split_once('.').unwrap_or((s.as_str(), ""));
-    let mut fp = fp.to_string();
-    while fp.len() > min_frac && fp.ends_with('0') {
-        fp.pop();
-    }
-    let ip = ip.trim_start_matches('0');
-    let ip = if ip.len() < min_int { format!("{}{ip}", "0".repeat(min_int - ip.len())) } else { ip.to_string() };
-    let mut num = if grouping { group(&ip, sep) } else { ip };
-    if !fp.is_empty() {
-        num.push(dec);
-        num.push_str(&fp);
-    }
-    let lits = |ts: &[Tok]| -> String {
-        ts.iter()
-            .filter_map(|t| match t {
-                Tok::Lit(s) => Some(s.clone()),
-                Tok::Percent => Some("%".into()),
-                _ => None,
-            })
-            .collect()
-    };
-    let before = lits(toks.get(..first).unwrap_or(&[]));
-    let after = lits(toks.get(last + 1..).unwrap_or(&[]));
-    let out = format!("{before}{num}{after}");
-    let out = out.trim();
-    if minus && !out.is_empty() { format!("-{out}") } else { out.to_string() }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const RUB: &str = r#"_-* #\ ##0\ "₽"_-;\-* #\ ##0\ "₽"_-;_-* "-"??\ "₽"_-;_-@_-"#;
-
-    #[test]
-    fn russian_accounting_roubles() {
-        assert_eq!(format(RUB, 800_000.0, Some("ru-RU")), "800\u{a0}000 ₽");
-        assert_eq!(format(RUB, 1_234_567.0, Some("ru-RU")), "1\u{a0}234\u{a0}567 ₽");
-        assert_eq!(format(RUB, -5_000.0, Some("ru-RU")), "-5\u{a0}000 ₽");
-        assert_eq!(format(RUB, 0.0, Some("ru-RU")), "- ₽");
-    }
-
-    #[test]
-    fn common_codes() {
-        assert_eq!(format("#,##0", 7000.0, Some("ru-RU")), "7\u{a0}000");
-        assert_eq!(format("#,##0", 7000.0, Some("en-US")), "7,000");
-        assert_eq!(format("#,##0", 7000.0, Some("de-DE")), "7.000");
-        assert_eq!(format("0.0%", 0.125, Some("ru-RU")), "12,5%");
-        assert_eq!(format("0.0%", 0.125, None), "12.5%");
-        assert_eq!(format("0%", 0.0, None), "0%");
-        assert_eq!(format("General", 2.5, Some("ru-RU")), "2,5");
-        assert_eq!(format("General", 400_000.0, Some("ru-RU")), "400000");
-        assert_eq!(format("0.00", 1.23456, None), "1.23");
-        assert_eq!(format("#,##0.0#", 1234.5, None), "1,234.5");
-        assert_eq!(format("#,##0,", 12_345_678.0, None), "12,346");
-        assert_eq!(format("[$₽-419]#,##0", 1500.0, Some("ru-RU")), "₽1\u{a0}500");
-        assert_eq!(format("0;[Red]-0", -3.0, None), "-3");
-        assert_eq!(format("0;0", -3.0, None), "3");
-        assert_eq!(format("0", -3.0, None), "-3");
-        assert_eq!(format("\"x\"0", 5.0, None), "x5");
-    }
-
-    #[test]
-    fn never_panics() {
-        for code in ["", ";", ";;;", "\"", "[", "\\", "0.", ".", "#,", "%", "_", "*", "@", "0E+00", "[$", "\"unterminated"] {
-            for v in [0.0, -1.5, 1e300, f64::NAN, f64::INFINITY, 1e-300] {
-                let _ = format(code, v, Some("ru"));
-            }
-        }
-    }
-}

crates/model/src/resolve.rs

@@ -22,27 +22,23 @@ pub struct Ctx<'a> {
     pub layout: Option<&'a Layout>,
     pub owner: Owner,
     pub scheme: ColorScheme,
-    /// The colour map in force: the slide's override, else its layout's, else the master's.
-    pub color_map: Vec<(String, String)>,
 }
 
 impl<'a> Ctx<'a> {
     pub fn for_slide(pres: &'a Presentation, slide: &Slide) -> Option<Ctx<'a>> {
         let (master, layout) = pres.master_for(slide)?;
-        let map = slide.color_map.as_ref().or(layout.and_then(|l| l.color_map.as_ref())).unwrap_or(&master.color_map).clone();
-        Some(Ctx { pres, master, layout, owner: Owner::Slide, scheme: master.scheme_with(&map), color_map: map })
+        Some(Ctx { pres, master, layout, owner: Owner::Slide, scheme: master.scheme() })
     }
     pub fn for_layout(pres: &'a Presentation, master: &'a Master, layout: &'a Layout) -> Ctx<'a> {
-        let map = layout.color_map.as_ref().unwrap_or(&master.color_map).clone();
-        Ctx { pres, master, layout: Some(layout), owner: Owner::Layout, scheme: master.scheme_with(&map), color_map: map }
+        Ctx { pres, master, layout: Some(layout), owner: Owner::Layout, scheme: master.scheme() }
     }
     pub fn for_master(pres: &'a Presentation, master: &'a Master) -> Ctx<'a> {
-        Ctx { pres, master, layout: None, owner: Owner::Master, scheme: master.scheme(), color_map: master.color_map.clone() }
+        Ctx { pres, master, layout: None, owner: Owner::Master, scheme: master.scheme() }
     }
     pub fn color(&self, c: &ColorRef, ph: Option<Rgba>) -> Rgba {
         let c = match &c.base {
             crate::ColorBase::Scheme { slot } if matches!(slot, SchemeSlot::Bg1 | SchemeSlot::Tx1 | SchemeSlot::Bg2 | SchemeSlot::Tx2) => {
-                ColorRef { base: crate::ColorBase::Scheme { slot: crate::map_slot(&self.color_map, *slot) }, mods: c.mods.clone() }
+                ColorRef { base: crate::ColorBase::Scheme { slot: self.master.map_slot(*slot) }, mods: c.mods.clone() }
             }
             _ => c.clone(),
         };
@@ -134,8 +130,11 @@ pub fn xfrm(ctx: &Ctx, shape: &Shape) -> Xfrm {
 /// Effective fill and the style colour (`phClr`) to resolve it with.
 pub fn fill(ctx: &Ctx, shape: &Shape) -> (Option<Fill>, Option<Rgba>) {
     let (lp, mp) = parents(ctx, shape);
-    let style_fill = |s: &Shape| {
-        s.style.as_ref().map(|st| {
+    for s in [Some(shape), lp, mp].into_iter().flatten() {
+        if let Some(f) = &s.fill {
+            return (Some(f.clone()), None);
+        }
+        if let Some(st) = &s.style {
             let (idx, col) = &st.fill_ref;
             let ph = ctx.color(col, None);
             let f = match *idx {
@@ -143,25 +142,7 @@ pub fn fill(ctx: &Ctx, shape: &Shape) -> (Option<Fill>, Option<Rgba>) {
                 i if i >= 1001 => ctx.master.theme.format.bg_fills.get((i - 1001) as usize).cloned(),
                 i => ctx.master.theme.format.fills.get((i - 1) as usize).cloned(),
             };
-            (f, Some(ph))
-        })
-    };
-    for s in [Some(shape), lp, mp].into_iter().flatten() {
-        if let Some(f) = &s.fill {
-            // A gradient without stops (`a:gradFill` with no `a:gsLst`) takes them from the
-            // gradient its style refers to, keeping its own direction, as PowerPoint draws it.
-            if let Fill::Gradient(g) = f
-                && g.stops.is_empty()
-                && let Some((Some(Fill::Gradient(sg)), ph)) = style_fill(s)
-            {
-                let mut g = g.clone();
-                g.stops = sg.stops;
-                return (Some(Fill::Gradient(g)), ph);
-            }
-            return (Some(f.clone()), None);
-        }
-        if let Some(r) = style_fill(s) {
-            return r;
+            return (f, Some(ph));
         }
     }
     if shape.text_box {
@@ -238,7 +219,6 @@ pub fn body(ctx: &Ctx, shape: &Shape) -> BodyProps {
         columns: Some(1),
         col_spacing: Some(0.0),
         warp: None,
-        warp_adj: Vec::new(),
         rtl_col: Some(false),
         upright: Some(false),
     });

crates/model/src/style.rs

@@ -92,15 +92,6 @@ pub struct Gradient {
     pub shape: GradientShape,
     #[serde(default = "crate::yes")]
     pub rotate_with_shape: bool,
-    /// `a:tileRect`: the box the gradient is laid out in, as insets from the shape's box
-    /// (fractions; negative reaches outside it). PowerPoint's "from corner" radial presets use it
-    /// to centre the gradient on the corner.
-    #[serde(default, skip_serializing_if = "is_zero4")]
-    pub tile: [f64; 4],
-}
-
-fn is_zero4(v: &[f64; 4]) -> bool {
-    v.iter().all(|x| *x == 0.0)
 }
 
 /// How a picture fills its box: stretched into a (fractional) inset rect, or tiled.
@@ -139,10 +130,6 @@ pub struct PictureFill {
     /// 0–1 opacity of the picture.
     pub alpha: Option<f64>,
     pub adjust: PictureAdjust,
-    /// `rotWithShape="0"`: the picture keeps to the slide's axes when its shape is rotated or
-    /// flipped.
-    #[serde(skip_serializing_if = "std::ops::Not::not")]
-    pub upright: bool,
 }
 
 /// Picture corrections and colour (Picture Format ▸ Corrections / Color / Transparency).
@@ -161,12 +148,6 @@ pub struct PictureAdjust {
     /// Make a colour transparent (Set Transparent Color).
     pub clear_color: Option<Rgba>,
     pub sharpen: f64,
-    /// `a:biLevel`: black and white, split at this luminance (0–1).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bilevel: Option<f64>,
-    /// `a:alphaInv`: opacity inverted.
-    #[serde(skip_serializing_if = "std::ops::Not::not")]
-    pub alpha_inv: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -406,16 +387,6 @@ pub struct Effects {
     pub bevel: Option<String>,
     /// Unmodelled 3-D XML kept for round-trip (`scene3d`, `sp3d`).
     pub raw3d: Option<String>,
-    /// `a:fillOverlay`: a fill blended over the shape's fill (`blend`: `over`, `mult`, `screen`,
-    /// `darken`, `lighten`). Only solid and gradient overlays are kept.
-    pub fill_overlay: Option<FillOverlay>,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FillOverlay {
-    pub blend: String,
-    pub fill: Fill,
 }
 
 impl Effects {
@@ -426,7 +397,6 @@ impl Effects {
             && self.soft_edge.is_none()
             && self.reflection.is_none()
             && self.bevel.is_none()
-            && self.fill_overlay.is_none()
     }
 }
 

crates/model/src/table.rs

@@ -2,7 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 
-use crate::style::{ColorRef, Fill, Line};
+use crate::style::{Fill, Line};
 use crate::text::{Anchor, TextBody};
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
@@ -55,9 +55,6 @@ pub struct Table {
     pub last_col: bool,
     pub band_row: bool,
     pub band_col: bool,
-    /// `a:tblPr` fill: a fill behind the whole table (over the style's own background).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub background: Option<Fill>,
 }
 
 impl Default for Table {
@@ -72,7 +69,6 @@ impl Default for Table {
             last_col: false,
             band_row: true,
             band_col: false,
-            background: None,
         }
     }
 }
@@ -203,110 +199,6 @@ impl Table {
     }
 }
 
-/// A table style defined in the file (`ppt/tableStyles.xml`), as PowerPoint writes the built-in
-/// styles a deck uses: how each part of a table (whole table, banded rows and columns, first and
-/// last rows and columns, corner cells) is filled, bordered and lettered.
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default, rename_all = "camelCase")]
-pub struct TableStyleDef {
-    /// The style's GUID (`a:tableStyleId` on tables).
-    pub id: String,
-    pub name: String,
-    pub parts: Vec<(TablePart, TablePartStyle)>,
-    /// `a:tblBg`: a fill behind the whole table (only `fill` and `fill_ref` are used).
-    pub background: Option<TablePartStyle>,
-    /// The definition as read, written back unchanged.
-    #[serde(skip_serializing_if = "String::is_empty")]
-    pub raw: String,
-}
-
-impl TableStyleDef {
-    pub fn part(&self, p: TablePart) -> Option<&TablePartStyle> {
-        self.parts.iter().find(|(k, _)| *k == p).map(|(_, s)| s)
-    }
-}
-
-/// The parts of a table style, in the order they apply (later ones win).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum TablePart {
-    WholeTbl,
-    Band1H,
-    Band2H,
-    Band1V,
-    Band2V,
-    LastCol,
-    FirstCol,
-    LastRow,
-    FirstRow,
-    SeCell,
-    SwCell,
-    NeCell,
-    NwCell,
-}
-
-impl TablePart {
-    pub const ALL: [TablePart; 13] = [
-        TablePart::WholeTbl,
-        TablePart::Band1H,
-        TablePart::Band2H,
-        TablePart::Band1V,
-        TablePart::Band2V,
-        TablePart::LastCol,
-        TablePart::FirstCol,
-        TablePart::LastRow,
-        TablePart::FirstRow,
-        TablePart::SeCell,
-        TablePart::SwCell,
-        TablePart::NeCell,
-        TablePart::NwCell,
-    ];
-
-    pub fn xml(self) -> &'static str {
-        match self {
-            TablePart::WholeTbl => "wholeTbl",
-            TablePart::Band1H => "band1H",
-            TablePart::Band2H => "band2H",
-            TablePart::Band1V => "band1V",
-            TablePart::Band2V => "band2V",
-            TablePart::LastCol => "lastCol",
-            TablePart::FirstCol => "firstCol",
-            TablePart::LastRow => "lastRow",
-            TablePart::FirstRow => "firstRow",
-            TablePart::SeCell => "seCell",
-            TablePart::SwCell => "swCell",
-            TablePart::NeCell => "neCell",
-            TablePart::NwCell => "nwCell",
-        }
-    }
-
-    pub fn from_xml(s: &str) -> Option<TablePart> {
-        TablePart::ALL.into_iter().find(|p| p.xml() == s)
-    }
-}
-
-/// One part of a table style. A theme reference (`a:fillRef`, `a:lnRef`) is kept as the theme's
-/// style index with its colour.
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default, rename_all = "camelCase")]
-pub struct TablePartStyle {
-    pub fill: Option<Fill>,
-    pub fill_ref: Option<(u32, ColorRef)>,
-    /// Left, right, top, bottom, inside horizontal, inside vertical.
-    pub borders: [Option<TableBorder>; 6],
-    pub text_color: Option<ColorRef>,
-    pub bold: Option<bool>,
-    pub italic: Option<bool>,
-}
-
-/// A border of a table style part: a line, or a theme line style reference.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", tag = "kind")]
-pub enum TableBorder {
-    Line { line: Line },
-    Ref { idx: u32, color: ColorRef },
-}
-
 /// Built-in table styles: (id, label). Styles are generated from the theme accents.
 pub fn table_styles() -> Vec<(String, String)> {
     let mut v = vec![("none".to_string(), "No Style, No Grid".to_string()), ("grid".to_string(), "No Style, Table Grid".to_string())];

crates/model/src/tests.rs

@@ -62,30 +62,6 @@ fn shape_style_fill_resolves_through_theme() {
     assert!(ph.is_some());
 }
 
-#[test]
-fn a_gradient_without_stops_takes_them_from_its_style() {
-    // `a:gradFill` with only a direction: PowerPoint fills it with the stops of the theme gradient
-    // the style's fillRef names, in the style's colour, along the shape's own direction.
-    let p = Presentation::default();
-    let s = &p.slides[0];
-    let ctx = Ctx::for_slide(&p, s).unwrap();
-    let own =
-        style::Gradient { tile: [0.0; 4], stops: vec![], shape: style::GradientShape::Linear { angle: 45.0, scaled: true }, rotate_with_shape: true };
-    let mut st = ShapeStyle::accent(SchemeSlot::Accent2);
-    st.fill_ref.0 = 3;
-    let sh = Shape { style: Some(st.clone()), fill: Some(Fill::Gradient(own.clone())), ..Default::default() };
-    let (f, ph) = resolve::fill(&ctx, &sh);
-    let Some(Fill::Gradient(g)) = f else { panic!("expected a gradient") };
-    let Some(Fill::Gradient(theme)) = p.masters[0].theme.format.fills.get(2).cloned() else { panic!("theme fill 3 is a gradient") };
-    assert_eq!(g.stops, theme.stops);
-    assert_eq!(g.shape, own.shape, "the shape's own direction");
-    assert_eq!(ph, Some(p.masters[0].theme.colors.get(SchemeSlot::Accent2)));
-    // A solid style fill has no stops to give: the gradient stays empty (draws nothing).
-    st.fill_ref.0 = 1;
-    let sh = Shape { style: Some(st), fill: Some(Fill::Gradient(own.clone())), ..Default::default() };
-    assert_eq!(resolve::fill(&ctx, &sh).0, Some(Fill::Gradient(own)));
-}
-
 #[test]
 fn serde_roundtrip() {
     let p = Presentation::default();
@@ -183,51 +159,3 @@ fn hyperlinked_runs_take_the_theme_hyperlink_look() {
     let dbl = resolve::run(&ctx, title, &para, &RunProps { link, underline: Some("dbl".into()), ..Default::default() });
     assert_eq!((dbl.fill, dbl.underline.as_deref()), (hlink, Some("dbl")));
 }
-
-#[test]
-fn a_layout_colour_map_override_applies_to_its_slides() {
-    // A dark "section" layout maps bg1→dk1 and tx1→lt1; a slide on it that keeps the master
-    // mapping (`masterClrMapping`) follows the layout, as PowerPoint draws it.
-    let mut p = Presentation::default();
-    let dark: Vec<(String, String)> =
-        [("bg1", "dk1"), ("tx1", "lt1"), ("bg2", "dk2"), ("tx2", "lt2")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect();
-    let layout = p.slides[0].layout;
-    let m = std::sync::Arc::make_mut(&mut p.masters[0]);
-    let colors = m.theme.colors.clone();
-    m.layouts.iter_mut().find(|l| l.id == layout).unwrap().color_map = Some(dark.clone());
-    let s: Slide = (*p.slides[0]).clone();
-    let ctx = Ctx::for_slide(&p, &s).unwrap();
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Dk1));
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Tx2), None), colors.get(SchemeSlot::Lt2));
-    assert_eq!(ctx.scheme.get(SchemeSlot::Lt1), colors.get(SchemeSlot::Dk1));
-    // The slide's own override wins over the layout's.
-    let mut own = s.clone();
-    own.color_map = Some([("bg1", "lt1"), ("tx1", "dk1")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect());
-    let ctx = Ctx::for_slide(&p, &own).unwrap();
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Lt1));
-    // The layout itself draws with its override; the master keeps its own map.
-    let m = &p.masters[0];
-    let l = m.layout(layout).unwrap();
-    assert_eq!(Ctx::for_layout(&p, m, l).color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Dk1));
-    assert_eq!(Ctx::for_master(&p, m).color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Lt1));
-}
-
-#[test]
-fn sibling_lists_and_parents_reach_into_groups() {
-    let leaf = |id: u32| Shape { id: ShapeId(id), ..Default::default() };
-    let group = |id: u32, children: Vec<Shape>| Shape {
-        id: ShapeId(id),
-        kind: ShapeKind::Group { children, child: Default::default() },
-        ..Default::default()
-    };
-    let mut tree = vec![leaf(1), group(2, vec![leaf(3), group(4, vec![leaf(5)])]), leaf(6)];
-    assert_eq!(parent_of(&tree, ShapeId(1)), Some(None));
-    assert_eq!(parent_of(&tree, ShapeId(3)), Some(Some(ShapeId(2))));
-    assert_eq!(parent_of(&tree, ShapeId(5)), Some(Some(ShapeId(4))));
-    assert_eq!(parent_of(&tree, ShapeId(9)), None);
-    let ids = |v: &Vec<Shape>| v.iter().map(|s| s.id.0).collect::<Vec<_>>();
-    assert_eq!(sibling_list_mut(&mut tree, ShapeId(6)).map(|v| ids(v)), Some(vec![1, 2, 6]));
-    assert_eq!(sibling_list_mut(&mut tree, ShapeId(4)).map(|v| ids(v)), Some(vec![3, 4]));
-    assert_eq!(sibling_list_mut(&mut tree, ShapeId(5)).map(|v| ids(v)), Some(vec![5]));
-    assert!(sibling_list_mut(&mut tree, ShapeId(9)).is_none());
-}

crates/model/src/text.rs

@@ -55,10 +55,6 @@ pub enum TextDir {
     Vertical270,
     Stacked,
     EaVertical,
-    /// `mongolianVert`: turned like `vert`, lines running from left to right.
-    MongolianVertical,
-    /// `wordArtVertRtl`: stacked, lines running from right to left.
-    StackedRtl,
 }
 
 impl TextDir {
@@ -69,18 +65,14 @@ impl TextDir {
             TextDir::Vertical270 => "vert270",
             TextDir::Stacked => "wordArtVert",
             TextDir::EaVertical => "eaVert",
-            TextDir::MongolianVertical => "mongolianVert",
-            TextDir::StackedRtl => "wordArtVertRtl",
         }
     }
     pub fn from_xml(s: &str) -> Option<Self> {
         Some(match s {
             "horz" => TextDir::Horizontal,
-            "vert" => TextDir::Vertical,
-            "mongolianVert" => TextDir::MongolianVertical,
+            "vert" | "mongolianVert" => TextDir::Vertical,
             "vert270" => TextDir::Vertical270,
-            "wordArtVert" => TextDir::Stacked,
-            "wordArtVertRtl" => TextDir::StackedRtl,
+            "wordArtVert" | "wordArtVertRtl" => TextDir::Stacked,
             "eaVert" => TextDir::EaVertical,
             _ => return None,
         })
@@ -106,10 +98,6 @@ pub struct BodyProps {
     pub col_spacing: Option<f64>,
     /// WordArt transform (`prstTxWarp`), e.g. `textArchUp`.
     pub warp: Option<String>,
-    /// The warp's adjust values (`prstTxWarp/avLst`: `adj` or `adj1`, `adj2`…, raw guide values);
-    /// empty = the preset's defaults.
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub warp_adj: Vec<f64>,
     pub rtl_col: Option<bool>,
     /// Keep text upright when the shape rotates.
     pub upright: Option<bool>,
@@ -131,7 +119,6 @@ impl BodyProps {
         self.col_spacing = self.col_spacing.or(p.col_spacing);
         if self.warp.is_none() {
             self.warp.clone_from(&p.warp);
-            self.warp_adj.clone_from(&p.warp_adj);
         }
         self.rtl_col = self.rtl_col.or(p.rtl_col);
         self.upright = self.upright.or(p.upright);
@@ -236,10 +223,6 @@ pub struct ParaProps {
     pub rtl: Option<bool>,
     pub font_align: Option<String>,
     pub east_asian_line_break: Option<bool>,
-    /// `latinLnBrk`: Latin words may break inside (after `/`, `\`); off by default.
-    pub latin_line_break: Option<bool>,
-    /// `hangingPunct`: closing East Asian punctuation may hang past the end of a line.
-    pub hanging_punct: Option<bool>,
 }
 
 impl ParaProps {
@@ -270,8 +253,6 @@ impl ParaProps {
             self.font_align.clone_from(&p.font_align);
         }
         self.east_asian_line_break = self.east_asian_line_break.or(p.east_asian_line_break);
-        self.latin_line_break = self.latin_line_break.or(p.latin_line_break);
-        self.hanging_punct = self.hanging_punct.or(p.hanging_punct);
     }
 }
 

crates/model/src/theme.rs

@@ -108,7 +108,6 @@ fn ph() -> ColorRef {
 pub fn default_format() -> FormatScheme {
     let grad = |a: i32, b: i32| {
         Fill::Gradient(Gradient {
-            tile: [0.0; 4],
             stops: vec![
                 GradientStop { pos: 0.0, color: ph().with(ColorTransform::LumMod(a)).with(ColorTransform::SatMod(103000)) },
                 GradientStop { pos: 1.0, color: ph().with(ColorTransform::LumMod(b)) },

crates/model/src/words.rs

@@ -1,420 +0,0 @@
-//! Word boundaries in a paragraph, as PowerPoint's Ctrl+arrow, Ctrl+Backspace/Delete and
-//! double-click see them (observed black-box on PowerPoint for Windows, see
-//! `docs/ui-parity.md`, Text editing keys).
-//!
-//! A paragraph splits into *tokens*. Each token is a run of one class of grapheme clusters plus
-//! the spaces that follow it:
-//!
-//! - **word**: letters, digits and combining marks. An apostrophe (`'` or `’`) joins a word when a
-//!   letter or digit follows it (`it's`, `'tis`, but `dogs'` ends before it); a hyphen joins when
-//!   a letter or digit comes before it (`a-b`, `1-2`, `a-`); `.`, `,` and `:` join between digits
-//!   (`3.14`, `1,000`, `3:45`, but `e.g.` is five tokens).
-//! - **punctuation**: everything else that is not a symbol; a run of it is one token (`...`,
-//!   `?!`, `),`, `。。`). `_`, `@`, `/`, `#`, quotes and brackets are punctuation.
-//! - **symbol**: emoji and pictographs (a run of them is one token, `👍👍`), `©`, `®`, `™`.
-//! - **ideograph**: each CJK ideograph, kana or Hangul syllable is a token of its own.
-//! - **tab** and **line break**: each is a token of its own, and spaces after one form their own
-//!   token instead of joining it.
-//! - **space**: U+0020, no-break space, ideographic space and the other fixed-width spaces. Spaces
-//!   join the token before them; spaces at the start of a paragraph (or after a tab or line break)
-//!   are a token of their own.
-//!
-//! Positions are character (Unicode scalar) offsets in the paragraph text, where a line break is
-//! one `\u{b}` character. A token never splits a grapheme cluster, so the caret never lands
-//! inside an emoji sequence or between a letter and its combining marks.
-
-use unicode_segmentation::UnicodeSegmentation;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Class {
-    Space,
-    Tab,
-    Break,
-    Word,
-    Ideo,
-    Punct,
-    Symbol,
-}
-
-/// One grapheme cluster: its first character offset and class.
-#[derive(Clone, Copy, Debug)]
-struct Cluster {
-    start: usize,
-    class: Class,
-}
-
-/// A space for word movement: absorbed into the token before it.
-pub fn is_space(c: char) -> bool {
-    matches!(c, ' ' | '\u{a0}' | '\u{1680}' | '\u{2000}'..='\u{200a}' | '\u{202f}' | '\u{205f}' | '\u{3000}')
-}
-
-/// CJK ideographs, kana and Hangul: every one is a word of its own.
-fn is_ideo(c: char) -> bool {
-    matches!(c,
-        '\u{1100}'..='\u{11ff}'
-        | '\u{2e80}'..='\u{2fdf}'
-        | '\u{3005}'..='\u{3007}'
-        | '\u{3021}'..='\u{3029}'
-        | '\u{3031}'..='\u{3035}'
-        | '\u{3038}'..='\u{303c}'
-        | '\u{3040}'..='\u{309f}'
-        | '\u{30a0}'..='\u{30ff}'
-        | '\u{3100}'..='\u{318f}'
-        | '\u{31a0}'..='\u{31ff}'
-        | '\u{3400}'..='\u{4dbf}'
-        | '\u{4e00}'..='\u{9fff}'
-        | '\u{a960}'..='\u{a97f}'
-        | '\u{ac00}'..='\u{d7ff}'
-        | '\u{f900}'..='\u{faff}'
-        | '\u{ff66}'..='\u{ffdc}'
-        | '\u{20000}'..='\u{3134f}')
-}
-
-/// Emoji, pictographs and the common letter-like symbols.
-fn is_symbol(c: char) -> bool {
-    matches!(c,
-        '\u{a9}' | '\u{ae}' | '\u{2122}'
-        | '\u{2190}'..='\u{21ff}'
-        | '\u{2300}'..='\u{23ff}'
-        | '\u{25a0}'..='\u{27bf}'
-        | '\u{2b00}'..='\u{2bff}'
-        | '\u{1f000}'..='\u{1faff}')
-}
-
-fn base_class(c: char) -> Class {
-    match c {
-        '\u{b}' | '\n' | '\r' | '\u{2028}' | '\u{2029}' => Class::Break,
-        '\t' => Class::Tab,
-        c if is_space(c) => Class::Space,
-        c if is_ideo(c) => Class::Ideo,
-        c if c.is_alphanumeric() => Class::Word,
-        c if is_symbol(c) => Class::Symbol,
-        // A combining mark with no base (or any other mark) stays with letters.
-        '\u{300}'..='\u{36f}' | '\u{1ab0}'..='\u{1aff}' | '\u{1dc0}'..='\u{1dff}' | '\u{20d0}'..='\u{20ff}' | '\u{fe20}'..='\u{fe2f}' => Class::Word,
-        _ => Class::Punct,
-    }
-}
-
-fn clusters(text: &str) -> Vec<Cluster> {
-    let mut out: Vec<Cluster> = Vec::new();
-    let mut firsts: Vec<char> = Vec::new();
-    let mut pos = 0;
-    for g in text.graphemes(true) {
-        let n = g.chars().count();
-        let first = g.chars().next().unwrap_or(' ');
-        // "\r\n" is one grapheme; any other cluster takes the class of its first character.
-        out.push(Cluster { start: pos, class: base_class(first) });
-        firsts.push(first);
-        pos += n;
-    }
-    // Context: apostrophes, hyphens and number separators that belong to a word.
-    let classes: Vec<Class> = out.iter().map(|c| c.class).collect();
-    for (i, cl) in out.iter_mut().enumerate() {
-        let Some(&c) = firsts.get(i) else { continue };
-        let prev = i.checked_sub(1).and_then(|j| firsts.get(j)).copied();
-        let next = firsts.get(i + 1).copied();
-        let joins = match c {
-            '\'' | '\u{2019}' => next.is_some_and(char::is_alphanumeric),
-            '-' => prev.is_some_and(char::is_alphanumeric),
-            '.' | ',' | ':' => prev.is_some_and(char::is_numeric) && next.is_some_and(char::is_numeric),
-            _ => false,
-        };
-        if joins && classes.get(i) == Some(&Class::Punct) {
-            cl.class = Class::Word;
-        }
-    }
-    out
-}
-
-/// Does a token start at cluster `cur` (after `prev`)?
-fn starts_token(prev: Class, cur: Class) -> bool {
-    if cur == Class::Space {
-        // Spaces join the token before them, except after a tab or a line break.
-        return matches!(prev, Class::Tab | Class::Break);
-    }
-    prev == Class::Space || prev != cur || matches!(cur, Class::Ideo | Class::Tab | Class::Break)
-}
-
-/// The word stops of a paragraph's text in ascending order: 0, the start of every token, and the
-/// end of the text. Ctrl+Right goes to the next one.
-pub fn stops(text: &str) -> Vec<usize> {
-    let cs = clusters(text);
-    let mut out = vec![0];
-    for w in cs.windows(2) {
-        if let [a, b] = w
-            && starts_token(a.class, b.class)
-        {
-            out.push(b.start);
-        }
-    }
-    let n = text.chars().count();
-    if out.last() != Some(&n) {
-        out.push(n);
-    }
-    out
-}
-
-/// The stops Ctrl+Left uses. PowerPoint's backward scan differs from the forward one in two
-/// observed details: a no-break or other non-ASCII space is a stop of its own (unless an ASCII
-/// space follows it), and a symbol followed by punctuation (`👍?`) is one token.
-pub fn back_stops(text: &str) -> Vec<usize> {
-    let cs = clusters(text);
-    let chars: Vec<char> = text.chars().collect();
-    let mut out = vec![0];
-    for w in cs.windows(2) {
-        if let [a, b] = w {
-            let symbol_punct = matches!((a.class, b.class), (Class::Symbol, Class::Punct) | (Class::Punct, Class::Symbol));
-            if starts_token(a.class, b.class) && !symbol_punct {
-                out.push(b.start);
-            }
-        }
-    }
-    for (i, c) in chars.iter().enumerate() {
-        if *c != ' ' && is_space(*c) && chars.get(i + 1) != Some(&' ') && i > 0 {
-            out.push(i);
-        }
-    }
-    out.sort_unstable();
-    out.dedup();
-    let n = chars.len();
-    if out.last() != Some(&n) {
-        out.push(n);
-    }
-    out
-}
-
-/// The next stop after `ch` (Ctrl+Right), or `None` at the end of the text.
-pub fn next_stop(text: &str, ch: usize) -> Option<usize> {
-    stops(text).into_iter().find(|s| *s > ch)
-}
-
-/// The previous stop before `ch` (Ctrl+Left), or `None` at the start.
-pub fn prev_stop(text: &str, ch: usize) -> Option<usize> {
-    back_stops(text).into_iter().rev().find(|s| *s < ch)
-}
-
-/// Is the character at `i` a space (for word purposes)?
-fn space_at(chars: &[char], i: usize) -> bool {
-    chars.get(i).is_some_and(|c| is_space(*c))
-}
-
-/// The end of the token's text (before its trailing spaces) for the token containing `ch`.
-fn content_end(text: &str, ch: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let next = next_stop(text, ch).unwrap_or(chars.len());
-    let mut e = ch;
-    while e < next && !space_at(&chars, e) {
-        e += 1;
-    }
-    // A token made only of spaces (leading spaces) ends at the next stop.
-    if e == ch && space_at(&chars, ch) { next } else { e }
-}
-
-/// The word a double-click at `ch` selects: the token under the caret without its trailing
-/// spaces; on a space just after a token, that token; in a run of spaces, the spaces.
-pub fn word_at(text: &str, ch: usize) -> (usize, usize) {
-    let chars: Vec<char> = text.chars().collect();
-    let n = chars.len();
-    if n == 0 {
-        return (0, 0);
-    }
-    let ch = ch.min(n);
-    let on_space = ch >= n || space_at(&chars, ch);
-    let after_token = ch > 0 && !space_at(&chars, ch - 1);
-    let at = if on_space && after_token { ch - 1 } else { ch.min(n - 1) };
-    if space_at(&chars, at) {
-        let mut s = at;
-        while s > 0 && space_at(&chars, s - 1) {
-            s -= 1;
-        }
-        let mut e = at;
-        while e < n && space_at(&chars, e) {
-            e += 1;
-        }
-        return (s, e);
-    }
-    let s = stops(text).into_iter().rev().find(|s| *s <= at).unwrap_or(0);
-    (s, content_end(text, s).max(at + 1).min(n))
-}
-
-/// What Ctrl+Delete removes from `ch` (before smart spacing): inside a token, the rest of its
-/// text; on spaces right after a token, those spaces and the next token's text; anywhere else up
-/// to the next stop. `None` at the end of the text.
-pub fn delete_forward_end(text: &str, ch: usize) -> Option<usize> {
-    let chars: Vec<char> = text.chars().collect();
-    let n = chars.len();
-    if ch >= n {
-        return None;
-    }
-    let st = stops(text);
-    let at_stop = st.contains(&ch);
-    if !at_stop && !space_at(&chars, ch) {
-        return Some(content_end(text, ch));
-    }
-    let prev_is_text = ch > 0 && chars.get(ch - 1).is_some_and(|c| !is_space(*c) && !matches!(base_class(*c), Class::Tab | Class::Break));
-    if space_at(&chars, ch) && prev_is_text {
-        let mut j = ch;
-        while j < n && space_at(&chars, j) {
-            j += 1;
-        }
-        if j >= n {
-            return Some(n);
-        }
-        return Some(content_end(text, j));
-    }
-    st.into_iter().find(|s| *s > ch)
-}
-
-/// Closing punctuation that a smart delete pulls its word's spaces up to (`ab cd, ef` → Ctrl+Delete
-/// on `cd` gives `ab, ef`).
-pub fn is_closing_punct(c: char) -> bool {
-    matches!(c, '.' | ',' | ';' | ':' | '!' | '?' | ')' | ']' | '}' | '%' | '\u{2026}' | '\u{201d}' | '\u{2019}' | '\u{bb}')
-}
-
-/// Punctuation that a smart delete keeps a space after when a word follows (`cd...ef gh` →
-/// Ctrl+Delete on `ef` gives `cd... gh`).
-pub fn is_sentence_punct(c: char) -> bool {
-    matches!(c, '.' | ',' | ';' | ':' | '!' | '?' | '\u{2026}')
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Stops drawn as `|` in the text, for readable assertions.
-    fn marked(text: &str, st: &[usize]) -> String {
-        let mut out = String::new();
-        for (i, c) in text.chars().enumerate() {
-            if st.contains(&i) {
-                out.push('|');
-            }
-            out.push(match c {
-                '\u{b}' => '↵',
-                '\t' => '→',
-                c => c,
-            });
-        }
-        if st.contains(&text.chars().count()) {
-            out.push('|');
-        }
-        out
-    }
-    fn fwd(text: &str) -> String {
-        marked(text, &stops(text))
-    }
-    fn back(text: &str) -> String {
-        marked(text, &back_stops(text))
-    }
-
-    // Every expected string below is a stop trace observed in PowerPoint for Windows.
-    #[test]
-    fn punctuation_and_spaces() {
-        let t = "Hello, world!  Foo...bar baz-qux it's 3.14 e.g. a_b x@y.com (end) \"q\" end.";
-        let want = "|Hello|, |world|!  |Foo|...|bar |baz-qux |it's |3.14 |e|.|g|. |a|_|b |x|@|y|.|com |(|end|) |\"|q|\" |end|.|";
-        assert_eq!(fwd(t), want);
-        assert_eq!(back(t), want);
-    }
-
-    #[test]
-    fn hyphens_apostrophes_numbers() {
-        let t = "a-b -b a--b a - b a- b dogs' x 'q' 1,000.5 3:45 v1.2.3 $5 50% a/b x&y #tag a+b c++ end";
-        assert_eq!(
-            fwd(t),
-            "|a-b |-|b |a-|-|b |a |- |b |a- |b |dogs|' |x |'q|' |1,000.5 |3:45 |v1.2.3 |$|5 |50|% |a|/|b |x|&|y |#|tag |a|+|b |c|++ |end|"
-        );
-        let t = "it’s x a?!b a.)b a),b 1.a a1.b 1.5.x 1-2 a1-b A-1 —x x— a's 'tis o'clock ‘q’ end";
-        assert_eq!(fwd(t), "|it’s |x |a|?!|b |a|.)|b |a|),|b |1|.|a |a1|.|b |1.5|.|x |1-2 |a1-b |A-1 |—|x |x|— |a's |'tis |o'clock |‘|q|’ |end|");
-    }
-
-    #[test]
-    fn marks_emoji_symbols() {
-        let t = "café e\u{301}te 👍🏽 x 👨\u{200d}👩\u{200d}👧 y ½ ®z «q» “w” ¿no? ok—em dash–en x";
-        let want = "|café |e\u{301}te |👍🏽 |x |👨\u{200d}👩\u{200d}👧 |y |½ |®|z |«|q|» |“|w|” |¿|no|? |ok|—|em |dash|–|en |x|";
-        assert_eq!(fwd(t), want);
-        assert_eq!(back(t), want);
-        // A run of emoji is one token; emoji then punctuation is two going right, one going left.
-        assert_eq!(fwd("👍👍 x 👍? x👍y"), "|👍👍 |x |👍|? |x|👍|y|");
-        assert_eq!(back("👍👍 x 👍? x👍y"), "|👍👍 |x |👍? |x|👍|y|");
-    }
-
-    #[test]
-    fn cjk_each_character() {
-        let t = "日本語のテキストです。カタカナ漢字 abc 中文字符，标点。한국어 문장 a。。b";
-        assert_eq!(fwd(t), "|日|本|語|の|テ|キ|ス|ト|で|す|。|カ|タ|カ|ナ|漢|字 |abc |中|文|字|符|，|标|点|。|한|국|어 |문|장 |a|。。|b|");
-        assert_eq!(back(t), fwd(t));
-    }
-
-    #[test]
-    fn rtl_words_in_logical_order() {
-        let t = "Hello مرحبا بالعالم world שלום עולם end";
-        assert_eq!(fwd(t), "|Hello |مرحبا |بالعالم |world |שלום |עולם |end|");
-    }
-
-    #[test]
-    fn tabs_breaks_and_other_spaces() {
-        assert_eq!(fwd("  lead x   mid  "), "|  |lead |x   |mid  |");
-        assert_eq!(fwd("Five\u{b}six seven\tTab   x"), "|Five|↵|six |seven|→|Tab   |x|");
-        assert_eq!(fwd("a\t  b x  \u{b}  y q\u{b}\u{b}z"), "|a|→|  |b |x  |↵|  |y |q|↵|↵|z|");
-        let t = "a\u{a0}\u{a0}b a\u{3000}b a\u{2003}b a \u{a0}b a\t\tb a \tb a\u{a0} b end";
-        assert_eq!(fwd(t), "|a\u{a0}\u{a0}|b |a\u{3000}|b |a\u{2003}|b |a \u{a0}|b |a|→|→|b |a |→|b |a\u{a0} |b |end|");
-        assert_eq!(back(t), "|a|\u{a0}|\u{a0}|b |a|\u{3000}|b |a|\u{2003}|b |a |\u{a0}|b |a|→|→|b |a |→|b |a\u{a0} |b |end|");
-    }
-
-    #[test]
-    fn next_and_prev() {
-        let t = "  lead x   mid  ";
-        assert_eq!(next_stop(t, 1), Some(2));
-        assert_eq!(next_stop(t, 9), Some(11));
-        assert_eq!(next_stop(t, 16), None);
-        assert_eq!(prev_stop(t, 1), Some(0));
-        assert_eq!(prev_stop(t, 9), Some(7));
-        assert_eq!(prev_stop(t, 15), Some(11));
-        assert_eq!(prev_stop(t, 0), None);
-        assert_eq!(next_stop("", 0), None);
-        assert_eq!(prev_stop("", 0), None);
-    }
-
-    #[test]
-    fn double_click_word() {
-        let t = "Hello world,  foo bar";
-        assert_eq!(word_at(t, 7), (6, 11));
-        assert_eq!(word_at(t, 15), (14, 17));
-        assert_eq!(word_at(t, 11), (11, 12));
-        assert_eq!(word_at(t, 12), (11, 12));
-        assert_eq!(word_at(t, 13), (12, 14));
-        assert_eq!(word_at(t, 21), (18, 21));
-        assert_eq!(word_at("日本語のテキスト abc", 5), (5, 6));
-        assert_eq!(word_at("", 3), (0, 0));
-        assert_eq!(word_at("x👨\u{200d}👩\u{200d}👧y", 2), (1, 6));
-    }
-
-    #[test]
-    fn delete_forward_extent() {
-        let t = "ab   cd...ef gh";
-        let ends: Vec<Option<usize>> = (0..=t.len()).map(|c| delete_forward_end(t, c)).collect();
-        // Before smart spacing: PowerPoint's results after it are tested in `edit`.
-        assert_eq!(
-            ends,
-            vec![
-                Some(5),
-                Some(2),
-                Some(7),
-                Some(5),
-                Some(5),
-                Some(7),
-                Some(7),
-                Some(10),
-                Some(10),
-                Some(10),
-                Some(13),
-                Some(12),
-                Some(15),
-                Some(15),
-                Some(15),
-                None
-            ]
-        );
-        assert_eq!(delete_forward_end("ab\t cd", 2), Some(3));
-        assert_eq!(delete_forward_end("ab  ", 2), Some(4));
-    }
-}

crates/pptx/src/maps.rs

@@ -17,12 +17,7 @@ pub fn transition_from_xml(e: &El) -> Option<(String, String)> {
     Some((k, if has_opts { o } else { String::new() }))
 }
 
-/// Preset transitions (`p15:prstTrans`) whose "Left" option PowerPoint writes with `invX="1"`
-/// (the others write it for "Right"), as observed on PowerPoint's own files.
-const INVX_LEFT: &[&str] = &["wind", "airplane", "origami"];
-
 fn transition_from_xml_raw(e: &El) -> Option<(String, String)> {
-    // Defaults are what PowerPoint leaves out: e.g. it writes Push Left as `<p:push/>`.
     let dir = |d: &str| e.attr("dir").unwrap_or(d).to_string();
     let k = |s: &str| s.to_string();
     Some(match e.local() {
@@ -30,22 +25,16 @@ fn transition_from_xml_raw(e: &El) -> Option<(String, String)> {
         "cut" => (k("cut"), if e.bool("thruBlk") == Some(true) { k("throughBlack") } else { String::new() }),
         "push" => (k("push"), dir("l")),
         "wipe" => (k("wipe"), dir("l")),
-        // Diagonal wipes.
-        "strips" => (k("wipe"), dir("lu")),
         "split" => {
             let o = e.attr("orient").unwrap_or("horz");
             let d = e.attr("dir").unwrap_or("out");
             (k("split"), format!("{o}{}", if d == "in" { "In" } else { "Out" }))
         }
-        "randomBar" => (k("randomBar"), dir("horz")),
+        "randomBar" => (k("randomBar"), dir("vert")),
         "circle" => (k("shape"), k("circle")),
         "diamond" => (k("shape"), k("diamond")),
         "plus" => (k("shape"), k("plus")),
-        // Shape In / Out (the slide zooming in a box).
-        "zoom" => (k("shape"), if e.attr("dir") == Some("in") { k("in") } else { k("out") }),
-        // The Zoom transition, and its Zoom and Rotate option.
-        "warp" => (k("zoom"), if e.attr("dir") == Some("in") { k("in") } else { k("out") }),
-        "newsflash" => (k("zoom"), k("rotate")),
+        "zoom" => (k("zoom"), dir("in")),
         "pull" => (k("uncover"), dir("l")),
         "cover" => (k("cover"), dir("l")),
         "checker" => (k("checker"), dir("horz")),
@@ -58,22 +47,14 @@ fn transition_from_xml_raw(e: &El) -> Option<(String, String)> {
         "switch" => (k("switch"), dir("r")),
         "flip" => (k("flip"), dir("r")),
         "ripple" => (k("ripple"), dir("center")),
-        "doors" => (k("doors"), dir("horz")),
-        "window" => (k("window"), dir("horz")),
+        "doors" => (k("doors"), dir("vert")),
+        "window" => (k("window"), dir("vert")),
         "ferris" => (k("ferris"), dir("l")),
         "gallery" => (k("gallery"), dir("l")),
         "conveyor" => (k("conveyor"), dir("l")),
-        "pan" => (k("pan"), dir("l")),
-        "glitter" => {
-            let d = dir("l");
-            if e.attr("pattern") == Some("hexagon") { (k("glitter"), format!("hex{}", d.to_ascii_uppercase())) } else { (k("glitter"), d) }
-        }
-        "shred" => {
-            // `crush` is what DeckCraft wrote before it knew PowerPoint's `rectangle`.
-            let particles = matches!(e.attr("pattern"), Some("rectangle" | "crush"));
-            let out = e.attr("dir") == Some("out");
-            (k("shred"), format!("{}{}", if particles { "particles" } else { "strips" }, if out { "Out" } else { "In" }))
-        }
+        "pan" => (k("pan"), dir("d")),
+        "glitter" => (k("glitter"), dir("l")),
+        "shred" => (k("shred"), if e.attr("pattern") == Some("crush") { k("particles") } else { k("strips") }),
         "reveal" => {
             let black = e.bool("thruBlk") == Some(true);
             let right = e.attr("dir") == Some("r");
@@ -97,16 +78,11 @@ fn transition_from_xml_raw(e: &El) -> Option<(String, String)> {
         }
         "prstTrans" => {
             let prst = e.attr("prst").unwrap_or("fallOver");
-            let inv = e.bool("invX") == Some(true);
-            if prst == "pageCurlSingle" {
-                return Some((k("pageCurlDouble"), if inv { k("singleR") } else { k("singleL") }));
-            }
             let known = deckcraft_model::anim::TRANSITIONS.iter().any(|t| t.0 == prst);
             if !known {
                 return None;
             }
-            let left = if INVX_LEFT.contains(&prst) { inv } else { !inv };
-            (k(prst), if left { k("l") } else { k("r") })
+            (k(prst), if e.bool("invX") == Some(true) { k("r") } else { k("l") })
         }
         "morph" => (
             k("morph"),
@@ -143,10 +119,7 @@ pub fn transition_to_xml(w: &mut W, kind: &str, option: &str) -> Option<&'static
         "fade" => w.empty("p:fade", A::new().t("thruBlk", option == "throughBlack")),
         "cut" => w.empty("p:cut", A::new().t("thruBlk", option == "throughBlack")),
         "push" => w.empty("p:push", A::new().a("dir", lrud("u"))),
-        "wipe" => match option {
-            "lu" | "ru" | "ld" | "rd" => w.empty("p:strips", A::new().a("dir", option)),
-            _ => w.empty("p:wipe", A::new().a("dir", lrud("r"))),
-        },
+        "wipe" => w.empty("p:wipe", A::new().a("dir", lrud("r"))),
         "split" => {
             let (o, d) = match option {
                 "vertIn" => ("vert", "in"),
@@ -163,13 +136,7 @@ pub fn transition_to_xml(w: &mut W, kind: &str, option: &str) -> Option<&'static
             "in" | "out" => w.empty("p:zoom", A::new().a("dir", option)),
             _ => w.empty0("p:circle"),
         },
-        "zoom" => match option {
-            "rotate" => w.empty0("p:newsflash"),
-            _ => {
-                w.empty("p14:warp", A::new().a("dir", if option == "out" { "out" } else { "in" }));
-                return Some("p14");
-            }
-        },
+        "zoom" => w.empty("p:zoom", A::new().a("dir", if option == "out" { "out" } else { "in" })),
         "uncover" => w.empty("p:pull", A::new().a("dir", eight("l"))),
         "cover" => w.empty("p:cover", A::new().a("dir", eight("l"))),
         "checker" => w.empty("p:checker", A::new().a("dir", hv("horz"))),
@@ -193,15 +160,9 @@ pub fn transition_to_xml(w: &mut W, kind: &str, option: &str) -> Option<&'static
             w.empty0("p14:flash");
             return Some("p14");
         }
-        "vortex" => {
-            w.empty("p14:vortex", A::new().a("dir", lrud("l")));
-            return Some("p14");
-        }
-        "glitter" => {
-            let hex = option.starts_with("hex");
-            let d = option.trim_start_matches("hex").to_ascii_lowercase();
-            let d = if matches!(d.as_str(), "l" | "r" | "u" | "d") { d } else { "l".to_string() };
-            w.empty("p14:glitter", A::new().a("dir", d).o("pattern", hex.then_some("hexagon")));
+        "vortex" | "glitter" => {
+            let name = if kind == "vortex" { "p14:vortex" } else { "p14:glitter" };
+            w.empty(name, A::new().a("dir", lrud("l")));
             return Some("p14");
         }
         "switch" | "flip" | "gallery" | "conveyor" | "ferris" => {
@@ -233,11 +194,7 @@ pub fn transition_to_xml(w: &mut W, kind: &str, option: &str) -> Option<&'static
             return Some("p14");
         }
         "shred" => {
-            let particles = option.starts_with("particles");
-            w.empty(
-                "p14:shred",
-                A::new().a("pattern", if particles { "rectangle" } else { "strip" }).a("dir", if option.ends_with("Out") { "out" } else { "in" }),
-            );
+            w.empty("p14:shred", A::new().a("pattern", if option == "particles" { "crush" } else { "strip" }));
             return Some("p14");
         }
         "reveal" => {
@@ -258,13 +215,8 @@ pub fn transition_to_xml(w: &mut W, kind: &str, option: &str) -> Option<&'static
             );
             return Some("p14");
         }
-        "pageCurlDouble" if option.starts_with("single") => {
-            w.empty("p15:prstTrans", A::new().a("prst", "pageCurlSingle").t("invX", option == "singleR"));
-            return Some("p15");
-        }
         "fallOver" | "drape" | "curtains" | "wind" | "prestige" | "fracture" | "crush" | "peelOff" | "pageCurlDouble" | "airplane" | "origami" => {
-            let inv = if INVX_LEFT.contains(&kind) { option == "l" } else { option == "r" };
-            w.empty("p15:prstTrans", A::new().a("prst", kind).t("invX", inv));
+            w.empty("p15:prstTrans", A::new().a("prst", kind).t("invX", option == "r"));
             return Some("p15");
         }
         "morph" => {
@@ -390,7 +342,16 @@ mod tests {
                 assert!(!ns.is_empty());
                 let d = parse(w.s.as_bytes()).unwrap();
                 let (k, opt) = transition_from_xml(&d.root).unwrap_or_else(|| panic!("no read for {kind}"));
+                // `shape` in/out are written as zoom; everything else must come back.
+                if *kind == "shape" && (o == "in" || o == "out") {
+                    assert_eq!(k, "zoom");
+                    continue;
+                }
                 assert_eq!(k, *kind, "kind for {kind}/{o}");
+                // PresentationML wipes have no diagonal directions.
+                if *kind == "wipe" && o.len() == 2 {
+                    continue;
+                }
                 if !o.is_empty() {
                     assert_eq!(opt, o, "option for {kind}");
                 }

crates/pptx/src/read/chart.rs

@@ -97,30 +97,10 @@ pub(crate) fn chart_from(root: &El) -> Option<Chart> {
         c.title = None;
     }
     c.legend = ch.child("legend").map(|l| l.child_val("legendPos").unwrap_or("r").to_string());
-    c.legend_overlay = ch.child("legend").and_then(|l| l.child("overlay")).and_then(|o| o.bool("val")).unwrap_or(false);
     c.chart_fill = simple_fill(root.child("spPr"));
     c.plot_fill = simple_fill(pa.child("spPr"));
 
     let mut kinds: Vec<ChartType> = vec![];
-    // The value axis the first plot group uses is the primary one; a group on another value axis
-    // (a combo chart's line on the right) is on the secondary axis.
-    let val_ids: Vec<(&str, bool)> =
-        pa.children_named("valAx").filter_map(|a| Some((a.child_val("axId")?, matches!(a.child_val("axPos"), Some("l" | "r"))))).collect();
-    // A group's value axis: its vertical one when it has two (scatter), else its one.
-    let group_val_axis = |g: &El| {
-        let ids: Vec<(&str, bool)> =
-            g.children_named("axId").filter_map(|a| a.attr("val")).filter_map(|id| val_ids.iter().find(|(v, _)| *v == id).copied()).collect();
-        ids.iter().find(|(_, vertical)| *vertical).or(ids.first()).map(|(id, _)| id.to_string())
-    };
-    // The primary value axis is the one on the left (bottom for bar charts); the secondary one
-    // sits on the right or top, or crosses the category axis at its maximum.
-    let secondary_placed = |a: &El| a.child_val("crosses") == Some("max") || matches!(a.child_val("axPos"), Some("r" | "t"));
-    let used: Vec<String> = pa.elements().filter(|g| g.local().ends_with("Chart")).filter_map(group_val_axis).collect();
-    let primary_val: Option<String> = used
-        .iter()
-        .find(|id| pa.children_named("valAx").find(|a| a.child_val("axId") == Some(id.as_str())).is_some_and(|a| !secondary_placed(a)))
-        .or(used.first())
-        .cloned();
     for g in pa.elements() {
         let name = g.local();
         if !name.ends_with("Chart") {
@@ -186,8 +166,6 @@ pub(crate) fn chart_from(root: &El) -> Option<Chart> {
             c.data_labels = true;
         }
         kinds.push(kind);
-        let val_axis = group_val_axis(g);
-        let secondary = val_axis.is_some() && val_axis != primary_val;
         for s in g.children_named("ser").take(1000) {
             let mut ser = Series {
                 name: s.child("tx").map(strings).and_then(|v| v.into_iter().next()).unwrap_or_default(),
@@ -196,22 +174,11 @@ pub(crate) fn chart_from(root: &El) -> Option<Chart> {
                 smooth: s.child("smooth").and_then(|v| v.bool("val")).unwrap_or(false),
                 marker: s.path(&["marker", "symbol"]).and_then(|m| m.attr("val")).filter(|m| *m != "none").map(String::from),
                 kind: Some(kind),
-                secondary_axis: secondary,
                 ..Default::default()
             };
             if let Some(d) = s.child("dLbls").and_then(|d| d.child("showVal")).and_then(|v| v.bool("val")) {
                 ser.data_labels = Some(d);
             }
-            // Data labels' number format: the series' labels', the group's, else the source data's.
-            let label_fmt = |d: Option<&El>| {
-                d.and_then(|d| d.child("numFmt"))
-                    .filter(|n| n.attr("sourceLinked") != Some("1"))
-                    .and_then(|n| n.attr("formatCode"))
-                    .map(str::to_string)
-            };
-            let source =
-                s.child("val").or_else(|| s.child("yVal")).and_then(|v| v.find("numCache")).and_then(|c| c.child("formatCode")).map(|f| f.text());
-            ser.number_format = label_fmt(s.child("dLbls")).or_else(|| label_fmt(g.child("dLbls"))).or(source).filter(|f| !f.is_empty());
             for dp in s.children_named("dPt") {
                 if let (Some(i), Some(f)) = (dp.child("idx").and_then(|i| i.u32("val")), simple_fill(dp.child("spPr"))) {
                     ser.point_fills.push((i as usize, f));
@@ -240,29 +207,11 @@ pub(crate) fn chart_from(root: &El) -> Option<Chart> {
     if c.kind != ChartType::Combo {
         for s in &mut c.series {
             s.kind = None;
-            s.secondary_axis = false;
         }
     }
     // Axes.
-    c.lang = root.child_val("lang").map(str::to_string);
     let vertical = |a: &&El| matches!(a.child_val("axPos"), Some("l" | "r"));
-    let by_id = |id: &Option<String>| pa.children_named("valAx").find(|a| id.is_some() && a.child_val("axId") == id.as_deref());
-    let val_ax = by_id(&primary_val).or_else(|| pa.children_named("valAx").find(vertical)).or_else(|| pa.children_named("valAx").last());
-    let num = |a: &El, k: &str| a.child_val(k).and_then(|v| v.parse::<f64>().ok()).filter(|v| v.is_finite());
-    let format_code = |a: &El| a.child("numFmt").and_then(|n| n.attr("formatCode")).map(str::to_string);
-    let deleted = |a: &El| a.child("delete").and_then(|d| d.bool("val")) == Some(true);
-    if c.kind == ChartType::Combo && c.series.iter().any(|s| s.secondary_axis) {
-        let primary_id = val_ax.and_then(|a| a.child_val("axId"));
-        // The other vertical value axis is the secondary one.
-        if let Some(a) = pa.children_named("valAx").find(|a| a.child_val("axId") != primary_id && vertical(a)) {
-            let sc = a.child("scaling");
-            c.y2_min = sc.and_then(|s| num(s, "min"));
-            c.y2_max = sc.and_then(|s| num(s, "max"));
-            c.y2_major = num(a, "majorUnit");
-            c.y2_format = format_code(a);
-            c.y2_hidden = deleted(a);
-        }
-    }
+    let val_ax = pa.children_named("valAx").find(vertical).or_else(|| pa.children_named("valAx").last());
     let cat_ax = pa.child("catAx").or_else(|| pa.child("dateAx")).or_else(|| pa.children_named("valAx").find(|a| !vertical(a)));
     if let Some(v) = val_ax {
         c.gridlines = v.child("majorGridlines").is_some();
@@ -270,122 +219,9 @@ pub(crate) fn chart_from(root: &El) -> Option<Chart> {
         c.y_min = sc.and_then(|s| s.child_val("min")).and_then(|v| v.parse().ok()).filter(|v: &f64| v.is_finite());
         c.y_max = sc.and_then(|s| s.child_val("max")).and_then(|v| v.parse().ok()).filter(|v: &f64| v.is_finite());
         c.axis_titles.1 = v.child("title").map(|t| rich_text(t).unwrap_or_else(|| "Axis Title".into()));
-        c.y_major = num(v, "majorUnit");
-        c.y_format = format_code(v);
-        c.y_hidden = deleted(v);
     }
     if let Some(a) = cat_ax {
         c.axis_titles.0 = a.child("title").map(|t| rich_text(t).unwrap_or_else(|| "Axis Title".into()));
     }
-    // Text sizes as the file sets them (PowerPoint draws chart text at these sizes, not scaled to
-    // the chart): the axes' and legend's, else the whole chart's; the title's own.
-    let chart_size = text_size(root.child("txPr"));
-    c.text_size = [val_ax, cat_ax, ch.child("legend")].into_iter().flatten().find_map(|e| text_size(e.child("txPr"))).or(chart_size);
-    c.title_size = ch.child("title").and_then(|t| text_size(t.child("tx").and_then(|x| x.child("rich"))).or_else(|| text_size(t.child("txPr"))));
     Some(c)
 }
-
-/// The size in points of the first `a:defRPr` or `a:rPr` with one under `e` (`sz` in hundredths).
-fn text_size(e: Option<&El>) -> Option<f64> {
-    fn rec(e: &El, depth: usize) -> Option<f64> {
-        if depth > 8 {
-            return None;
-        }
-        for c in e.elements() {
-            if (c.is("defRPr") || c.is("rPr"))
-                && let Some(v) = c.attr("sz").and_then(|v| v.parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0)
-            {
-                return Some((v / 100.0).clamp(1.0, 400.0));
-            }
-            if let Some(v) = rec(c, depth + 1) {
-                return Some(v);
-            }
-        }
-        None
-    }
-    rec(e?, 0)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn legend_position_and_overlay_are_read() {
-        let legend = r#"<c:legend><c:legendPos val="r"/><c:overlay val="1"/></c:legend>"#;
-        let xml = format!(
-            r#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart><c:plotArea><c:barChart><c:barDir val="col"/></c:barChart></c:plotArea>{legend}</c:chart></c:chartSpace>"#
-        );
-        let c = read_chart_xml(xml.as_bytes()).unwrap();
-        assert_eq!(c.legend.as_deref(), Some("r"));
-        assert!(c.legend_overlay);
-        let xml = br#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart><c:plotArea><c:barChart><c:barDir val="col"/></c:barChart></c:plotArea><c:legend/></c:chart></c:chartSpace>"#;
-        let c = read_chart_xml(xml).unwrap();
-        assert_eq!(c.legend.as_deref(), Some("r"));
-        assert!(!c.legend_overlay);
-    }
-
-    #[test]
-    fn combo_chart_with_a_secondary_axis() {
-        // Columns on axes 1/2, a line on axes 3/4 whose value axis is on the right.
-        let xml = br##"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><c:lang val="ru-RU"/><c:chart><c:plotArea>
-<c:barChart><c:barDir val="col"/><c:grouping val="clustered"/><c:ser><c:idx val="0"/><c:tx><c:v>Spend</c:v></c:tx><c:cat><c:strLit><c:ptCount val="2"/><c:pt idx="0"><c:v>W1</c:v></c:pt><c:pt idx="1"><c:v>W2</c:v></c:pt></c:strLit></c:cat><c:val><c:numLit><c:ptCount val="2"/><c:pt idx="0"><c:v>200000</c:v></c:pt><c:pt idx="1"><c:v>310000</c:v></c:pt></c:numLit></c:val></c:ser><c:axId val="1"/><c:axId val="2"/></c:barChart>
-<c:lineChart><c:grouping val="standard"/><c:ser><c:idx val="1"/><c:tx><c:v>Clicks</c:v></c:tx><c:spPr><a:ln w="28575"><a:solidFill><a:srgbClr val="00B050"/></a:solidFill></a:ln></c:spPr><c:val><c:numLit><c:ptCount val="2"/><c:pt idx="0"><c:v>6000</c:v></c:pt><c:pt idx="1"><c:v>7400</c:v></c:pt></c:numLit></c:val></c:ser><c:marker val="1"/><c:axId val="3"/><c:axId val="4"/></c:lineChart>
-<c:catAx><c:axId val="1"/><c:axPos val="b"/><c:crossAx val="2"/></c:catAx><c:valAx><c:axId val="2"/><c:axPos val="l"/><c:numFmt formatCode="#,##0" sourceLinked="1"/><c:crossAx val="1"/><c:majorUnit val="100000"/></c:valAx>
-<c:valAx><c:axId val="4"/><c:scaling><c:max val="8000"/></c:scaling><c:axPos val="r"/><c:numFmt formatCode="0.0" sourceLinked="0"/><c:crossAx val="3"/></c:valAx><c:catAx><c:axId val="3"/><c:delete val="1"/><c:axPos val="b"/><c:crossAx val="4"/></c:catAx>
-</c:plotArea></c:chart></c:chartSpace>"##;
-        let c = read_chart_xml(xml).unwrap();
-        assert_eq!(c.kind, ChartType::Combo);
-        assert_eq!(c.series.len(), 2);
-        assert!(!c.series[0].secondary_axis);
-        assert!(c.series[1].secondary_axis);
-        assert_eq!(c.series[1].kind, Some(ChartType::LineMarkers));
-        assert!(c.series[1].line.as_ref().is_some_and(|l| l.width.is_some_and(|w| (w - 2.25).abs() < 0.01)));
-        // Each value axis' number format, bounds and unit; the chart's language.
-        assert_eq!(c.y_format.as_deref(), Some("#,##0"));
-        assert_eq!((c.y_major, c.y2_max, c.y2_format.as_deref()), (Some(100000.0), Some(8000.0), Some("0.0")));
-        assert_eq!(c.lang.as_deref(), Some("ru-RU"));
-        // Group order doesn't decide: columns on the right-hand axis are the secondary series even
-        // when their group comes first, and the line on the left is primary.
-        let swapped = String::from_utf8_lossy(xml)
-            .replace(
-                "<c:axPos val=\"l\"/><c:numFmt formatCode=\"#,##0\"",
-                "<c:axPos val=\"r\"/><c:crosses val=\"max\"/><c:numFmt formatCode=\"#,##0\"",
-            )
-            .replace("<c:axPos val=\"r\"/><c:numFmt formatCode=\"0.0\"", "<c:axPos val=\"l\"/><c:numFmt formatCode=\"0.0\"");
-        let c2 = read_chart_xml(swapped.as_bytes()).unwrap();
-        assert!(c2.series[0].secondary_axis && !c2.series[1].secondary_axis);
-        assert_eq!((c2.y_format.as_deref(), c2.y2_format.as_deref()), (Some("0.0"), Some("#,##0")));
-        // A chart of one type on one axis has no secondary series.
-        let single = String::from_utf8_lossy(xml)
-            .replace("<c:axId val=\"3\"/><c:axId val=\"4\"/></c:lineChart>", "<c:axId val=\"1\"/><c:axId val=\"2\"/></c:lineChart>");
-        let c = read_chart_xml(single.as_bytes()).unwrap();
-        assert!(c.series.iter().all(|s| !s.secondary_axis));
-    }
-
-    #[test]
-    fn text_sizes_are_read_from_the_file() {
-        // PowerPoint's new charts set the axes' and legend's text to 11.97 pt and the title's to
-        // 18.62 pt; a chart that only sets its overall text size uses it everywhere.
-        let ns =
-            r#"xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main""#;
-        let tx = |sz: u32| format!(r#"<c:txPr><a:bodyPr/><a:p><a:pPr><a:defRPr sz="{sz}"/></a:pPr></a:p></c:txPr>"#);
-        let xml = format!(
-            r#"<c:chartSpace {ns}><c:chart><c:title><c:tx><c:rich><a:bodyPr/><a:p><a:pPr><a:defRPr sz="1862"/></a:pPr><a:r><a:t>T</a:t></a:r></a:p></c:rich></c:tx></c:title><c:plotArea><c:barChart><c:barDir val="col"/><c:axId val="1"/><c:axId val="2"/></c:barChart><c:catAx><c:axId val="1"/>{}</c:catAx><c:valAx><c:axId val="2"/>{}</c:valAx></c:plotArea></c:chart></c:chartSpace>"#,
-            tx(1197),
-            tx(1197)
-        );
-        let c = read_chart_xml(xml.as_bytes()).unwrap();
-        assert_eq!((c.text_size, c.title_size), (Some(11.97), Some(18.62)));
-        let xml = format!(
-            r#"<c:chartSpace {ns}><c:chart><c:plotArea><c:barChart><c:barDir val="col"/></c:barChart></c:plotArea></c:chart>{}</c:chartSpace>"#,
-            tx(1400)
-        );
-        let c = read_chart_xml(xml.as_bytes()).unwrap();
-        assert_eq!((c.text_size, c.title_size), (Some(14.0), None));
-        let xml = format!(
-            r#"<c:chartSpace {ns}><c:chart><c:plotArea><c:barChart><c:barDir val="col"/></c:barChart></c:plotArea></c:chart></c:chartSpace>"#
-        );
-        assert_eq!(read_chart_xml(xml.as_bytes()).unwrap().text_size, None, "no sizes: the renderer picks one");
-    }
-}

crates/pptx/src/read/dml.rs

@@ -77,12 +77,6 @@ pub fn fill_el(imp: &mut Imp, part: &Part, f: &El) -> Option<Fill> {
         "solidFill" => Fill::Solid { color: color(f).unwrap_or(ColorRef::rgb(Rgba::BLACK)) },
         "gradFill" => Fill::Gradient(gradient(f)),
         "blipFill" => match blip_fill(imp, part, f) {
-            // A picture filling a shape or background with neither `a:stretch` nor `a:tile` is
-            // tiled at its own size, as PowerPoint draws it.
-            Some(mut p) if f.child("stretch").is_none() && f.child("tile").is_none() => {
-                p.mode = PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 1.0, sy: 1.0, flip: "none".into(), align: "tl".into() };
-                Fill::Picture(p)
-            }
             Some(p) => Fill::Picture(p),
             None => Fill::None,
         },
@@ -116,8 +110,7 @@ pub fn gradient(f: &El) -> Gradient {
     } else {
         GradientShape::Linear { angle: 90.0, scaled: false }
     };
-    let tile = f.child("tileRect").map(|r| [pct(r, "l"), pct(r, "t"), pct(r, "r"), pct(r, "b")].map(|v| v.unwrap_or(0.0).clamp(-10.0, 10.0)));
-    Gradient { tile: tile.unwrap_or_default(), stops, shape, rotate_with_shape: f.bool("rotWithShape").unwrap_or(true) }
+    Gradient { stops, shape, rotate_with_shape: f.bool("rotWithShape").unwrap_or(true) }
 }
 
 /// `blipFill` (either `a:` or `p:`) → picture fill, registering the image as media.
@@ -125,7 +118,7 @@ pub fn blip_fill(imp: &mut Imp, part: &Part, bf: &El) -> Option<PictureFill> {
     let blip = bf.child("blip");
     let media = blip.and_then(|b| media_ref(imp, part, b));
     let media = media?;
-    let mut pf = PictureFill { media, upright: !bf.bool("rotWithShape").unwrap_or(true), ..Default::default() };
+    let mut pf = PictureFill { media, ..Default::default() };
     if let Some(b) = blip {
         for e in b.elements() {
             match e.local() {
@@ -135,8 +128,6 @@ pub fn blip_fill(imp: &mut Imp, part: &Part, bf: &El) -> Option<PictureFill> {
                     pf.adjust.contrast = pct(e, "contrast").unwrap_or(0.0).clamp(-1.0, 1.0);
                 }
                 "grayscl" => pf.adjust.grayscale = true,
-                "biLevel" => pf.adjust.bilevel = Some(pct(e, "thresh").unwrap_or(0.5).clamp(0.0, 1.0)),
-                "alphaInv" => pf.adjust.alpha_inv = true,
                 "duotone" => {
                     let cs: Vec<ColorRef> = e.elements().filter_map(color_el).collect();
                     if let [a, b] = cs.as_slice() {
@@ -260,14 +251,6 @@ pub fn effects(el: &El) -> Effects {
             "innerShdw" => fx.inner_shadow = Some(shadow(e, true)),
             "glow" => fx.glow = Some(Glow { color: color(e).unwrap_or(ColorRef::rgb(Rgba::BLACK)), radius: pt(e, "rad").unwrap_or(0.0).max(0.0) }),
             "softEdge" => fx.soft_edge = Some(pt(e, "rad").unwrap_or(0.0).max(0.0)),
-            "fillOverlay" => {
-                let fill = e.elements().find_map(|f| match f.local() {
-                    "solidFill" => color(f).map(|c| Fill::Solid { color: c }),
-                    "gradFill" => Some(Fill::Gradient(gradient(f))),
-                    _ => None,
-                });
-                fx.fill_overlay = fill.map(|fill| deckcraft_model::style::FillOverlay { blend: e.attr("blend").unwrap_or("over").to_string(), fill });
-            }
             "reflection" => {
                 fx.reflection = Some(Reflection {
                     blur: pt(e, "blurRad").unwrap_or(0.0),
@@ -332,45 +315,13 @@ pub fn body_pr(b: &El) -> BodyProps {
             }
             "spAutoFit" => p.autofit = Some(AutoFit::Shape),
             "noAutofit" => p.autofit = Some(AutoFit::None),
-            "prstTxWarp" => {
-                p.warp = e.attr("prst").filter(|w| *w != "textNoShape" && !w.is_empty()).map(String::from);
-                p.warp_adj = p.warp.as_deref().map(|w| warp_adjusts(w, e)).unwrap_or_default();
-            }
+            "prstTxWarp" => p.warp = e.attr("prst").filter(|w| *w != "textNoShape").map(String::from),
             _ => {}
         }
     }
     p
 }
 
-/// `prstTxWarp/avLst` guides `adj` / `adj1`… as raw values by index (empty when none is given);
-/// slots the file leaves out keep the preset's default.
-fn warp_adjusts(preset: &str, e: &El) -> Vec<f64> {
-    let mut adj: Vec<f64> = Vec::new();
-    let Some(av) = e.child("avLst") else { return adj };
-    let defaults = deckcraft_geom::warp::adjust_defaults(preset);
-    for gd in av.children_named("gd").take(16) {
-        let n = gd.attr("name").unwrap_or("");
-        let idx = if n == "adj" {
-            0
-        } else if let Some(k) = n.strip_prefix("adj").and_then(|k| k.parse::<usize>().ok()).filter(|k| (1..=8).contains(k)) {
-            k - 1
-        } else {
-            continue;
-        };
-        let Some(v) = gd.attr("fmla").and_then(|f| f.trim().strip_prefix("val")).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite())
-        else {
-            continue;
-        };
-        while adj.len() <= idx {
-            adj.push(defaults.get(adj.len()).copied().unwrap_or(0.0));
-        }
-        if let Some(slot) = adj.get_mut(idx) {
-            *slot = v.clamp(-1.0e9, 1.0e9);
-        }
-    }
-    adj
-}
-
 fn spacing(e: &El) -> Option<Spacing> {
     if let Some(p) = e.child("spcPct") {
         return Some(Spacing::Pct(pct(p, "val").unwrap_or(1.0).clamp(0.0, 100.0)));
@@ -388,8 +339,6 @@ pub fn ppr(imp: &mut Imp, part: &Part, p: &El) -> (Option<u8>, ParaProps, Option
         rtl: p.bool("rtl"),
         font_align: p.attr("fontAlgn").map(String::from),
         east_asian_line_break: p.bool("eaLnBrk"),
-        latin_line_break: p.bool("latinLnBrk"),
-        hanging_punct: p.bool("hangingPunct"),
         default_tab: pt(p, "defTabSz"),
         ..Default::default()
     };
@@ -619,13 +568,5 @@ mod tests {
         assert_eq!(b.vert, Some(TextDir::Vertical270));
         assert_eq!(b.columns, Some(2));
         assert_eq!(b.autofit, Some(AutoFit::Shrink { font_scale: 0.625, line_reduction: 0.2 }));
-        // mongolianVert is its own direction (PowerPoint runs its lines left to right) and is
-        // written back as it was read.
-        let d = parse(br#"<a:bodyPr vert="mongolianVert"/>"#).unwrap();
-        let b = body_pr(&d.root);
-        assert_eq!(b.vert, Some(TextDir::MongolianVertical));
-        assert_eq!(b.vert.map(|v| v.xml()), Some("mongolianVert"));
-        let d = parse(br#"<a:bodyPr vert="wordArtVertRtl"/>"#).unwrap();
-        assert_eq!(body_pr(&d.root).vert.map(|v| v.xml()), Some("wordArtVertRtl"));
     }
 }

crates/pptx/src/read/mod.rs

@@ -14,7 +14,7 @@ use std::sync::Arc;
 use deckcraft_geom::{Size, emu_to_pt};
 use deckcraft_model::text::TextBody;
 use deckcraft_model::{
-    Background, Comment, CustomShow, Geom, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
+    Background, Comment, CustomShow, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
     Properties, Section, ShowSettings, Slide, SlideId, defaults,
 };
 
@@ -30,8 +30,6 @@ pub struct Imp<'a> {
     pub next: u32,
     pub slide_by_part: HashMap<String, SlideId>,
     pub custom_show_names: HashMap<String, String>,
-    /// GUIDs (upper case) of the table styles the file defines.
-    pub table_style_ids: Vec<String>,
 }
 
 impl Imp<'_> {
@@ -232,7 +230,6 @@ pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
         next: max_id.max(1),
         slide_by_part: HashMap::new(),
         custom_show_names: HashMap::new(),
-        table_style_ids: Vec::new(),
     };
     // Slide ids first so hyperlinks anywhere can point at slides.
     let mut slide_ids: Vec<(u32, String, SlideId)> = vec![];
@@ -272,13 +269,6 @@ pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
     if let Some(dts) = pres_el.child("defaultTextStyle") {
         p.default_text_style = dml::list_style(&mut imp, &pres_part, dts);
     }
-    if let Some(r) = pres_part.rels.first_of("tableStyles")
-        && let Some(d) = load(&pkg, &r.target)
-    {
-        let part = Part::new(&pkg, &r.target, &d);
-        p.table_styles = table_styles(&mut imp, &part, &d.root);
-        imp.table_style_ids = p.table_styles.iter().map(|s| s.id.clone()).collect();
-    }
 
     // Masters and layouts.
     let mut layout_by_part: HashMap<String, LayoutId> = HashMap::new();
@@ -397,7 +387,6 @@ pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
         p.props.company = d.root.child("Company").map(|c| c.text()).unwrap_or_default();
     }
 
-    inherit_placeholder_geometry(&mut p);
     p.header_footer = header_footer(&p);
     p.media = std::mem::take(&mut imp.media);
     p.next_id = imp.next;
@@ -430,154 +419,6 @@ pub fn color_map(cm: &El) -> Vec<(String, String)> {
     cm.attrs.iter().filter(|(k, _)| !k.starts_with("xmlns")).map(|(k, v)| (k.clone(), v.clone())).collect()
 }
 
-/// Placeholders read without a geometry (an empty custom geometry, see `shapes::sp`) take the
-/// geometry of the layout or master placeholder they inherit from, as PowerPoint draws them: a
-/// layout's picture placeholder cut into a shape keeps that shape on the slide. Anything left
-/// is a rectangle.
-fn inherit_placeholder_geometry(p: &mut Presentation) {
-    let unset = |g: &Geom| matches!(g, Geom::Custom { paths } if paths.is_empty());
-    // Masters first, then layouts (from their masters), then slides (from layouts and masters).
-    for m in &mut p.masters {
-        let m = Arc::make_mut(m);
-        walk_shapes_mut(&mut m.shapes, &mut |s| {
-            if unset(&s.geom) {
-                s.geom = Geom::default();
-            }
-        });
-    }
-    let mut layout_geoms: Vec<(LayoutId, usize, Geom)> = vec![];
-    for m in &p.masters {
-        for l in &m.layouts {
-            let ctx = deckcraft_model::resolve::Ctx::for_layout(p, m, l);
-            for (i, s) in l.shapes.iter().enumerate() {
-                if unset(&s.geom) {
-                    let (_, mp) = deckcraft_model::resolve::parents(&ctx, s);
-                    layout_geoms.push((l.id, i, mp.map(|m| m.geom.clone()).filter(|g| !unset(g)).unwrap_or_default()));
-                }
-            }
-        }
-    }
-    for m in &mut p.masters {
-        let m = Arc::make_mut(m);
-        for l in &mut m.layouts {
-            for (id, i, g) in layout_geoms.iter().filter(|(id, _, _)| *id == l.id) {
-                let _ = id;
-                if let Some(s) = l.shapes.get_mut(*i) {
-                    s.geom = g.clone();
-                }
-            }
-        }
-    }
-    let mut slide_geoms: Vec<(usize, usize, Geom)> = vec![];
-    for (si, sl) in p.slides.iter().enumerate() {
-        let Some(ctx) = deckcraft_model::resolve::Ctx::for_slide(p, sl) else { continue };
-        for (i, s) in sl.shapes.iter().enumerate() {
-            if unset(&s.geom) {
-                let (lp, mp) = deckcraft_model::resolve::parents(&ctx, s);
-                let g = lp.map(|l| l.geom.clone()).filter(|g| !unset(g)).or_else(|| mp.map(|m| m.geom.clone()).filter(|g| !unset(g)));
-                slide_geoms.push((si, i, g.unwrap_or_default()));
-            }
-        }
-    }
-    for (si, i, g) in slide_geoms {
-        if let Some(sl) = p.slides.get_mut(si)
-            && let Some(s) = Arc::make_mut(sl).shapes.get_mut(i)
-        {
-            s.geom = g;
-        }
-    }
-    // Placeholders inside groups (rare) and anything still unset: rectangles.
-    for sl in &mut p.slides {
-        walk_shapes_mut(&mut Arc::make_mut(sl).shapes, &mut |s| {
-            if unset(&s.geom) {
-                s.geom = Geom::default();
-            }
-        });
-    }
-    for m in &mut p.masters {
-        for l in &mut Arc::make_mut(m).layouts {
-            walk_shapes_mut(&mut l.shapes, &mut |s| {
-                if unset(&s.geom) {
-                    s.geom = Geom::default();
-                }
-            });
-        }
-    }
-}
-
-/// Every shape, groups included.
-fn walk_shapes_mut(shapes: &mut [deckcraft_model::Shape], f: &mut dyn FnMut(&mut deckcraft_model::Shape)) {
-    for s in shapes {
-        f(s);
-        if let deckcraft_model::ShapeKind::Group { children, .. } = &mut s.kind {
-            walk_shapes_mut(children, f);
-        }
-    }
-}
-
-/// `a:tblStyleLst`: the table styles the file defines.
-fn table_styles(imp: &mut Imp, part: &Part, root: &El) -> Vec<deckcraft_model::table::TableStyleDef> {
-    use deckcraft_model::table::{TableBorder, TablePart, TablePartStyle, TableStyleDef};
-    root.children_named("tblStyle")
-        .take(256)
-        .filter_map(|st| {
-            let id = st.attr("styleId")?.to_ascii_uppercase();
-            let mut def = TableStyleDef { id, name: st.attr("styleName").unwrap_or("").to_string(), raw: part.keep(st), ..Default::default() };
-            if let Some(bg) = st.child("tblBg") {
-                let mut ps = TablePartStyle::default();
-                if let Some(f) = bg.elements().find(|e| e.local().ends_with("Fill")) {
-                    ps.fill = dml::fill_el(imp, part, f);
-                }
-                if let Some(fr) = bg.child("fillRef") {
-                    ps.fill_ref = Some((
-                        fr.u32("idx").unwrap_or(0),
-                        dml::color(fr).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent1)),
-                    ));
-                }
-                def.background = Some(ps);
-            }
-            for el in st.elements() {
-                let Some(kind) = TablePart::from_xml(el.local()) else { continue };
-                let mut ps = TablePartStyle::default();
-                if let Some(tx) = el.child("tcTxStyle") {
-                    ps.text_color = dml::color(tx);
-                    ps.bold = tx.attr("b").map(|v| v == "on");
-                    ps.italic = tx.attr("i").map(|v| v == "on");
-                }
-                if let Some(tc) = el.child("tcStyle") {
-                    if let Some(f) = tc.child("fill").and_then(|f| f.elements().next()) {
-                        ps.fill = dml::fill_el(imp, part, f);
-                    }
-                    if let Some(fr) = tc.child("fillRef") {
-                        ps.fill_ref = Some((
-                            fr.u32("idx").unwrap_or(0),
-                            dml::color(fr).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent1)),
-                        ));
-                    }
-                    if let Some(bd) = tc.child("tcBdr") {
-                        for (i, side) in ["left", "right", "top", "bottom", "insideH", "insideV"].iter().enumerate() {
-                            let Some(b) = bd.child(side) else { continue };
-                            let border = if let Some(ln) = b.child("ln") {
-                                Some(TableBorder::Line { line: dml::line(imp, part, ln) })
-                            } else {
-                                b.child("lnRef").map(|r| TableBorder::Ref {
-                                    idx: r.u32("idx").unwrap_or(0),
-                                    color: dml::color(r).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent1)),
-                                })
-                            };
-                            if let Some(slot) = ps.borders.get_mut(i) {
-                                *slot = border;
-                            }
-                        }
-                    }
-                }
-                def.parts.push((kind, ps));
-            }
-            Some(def)
-        })
-        .collect()
-}
-
 fn background(imp: &mut Imp, part: &Part, csld: &El) -> Option<Background> {
     let bg = csld.child("bg")?;
     if let Some(pr) = bg.child("bgPr") {
@@ -682,18 +523,12 @@ fn read_layout(imp: &mut Imp, part: &Part, doc: &Doc) -> Layout {
             l.shapes = shapes::sp_tree(imp, part, &mut ctx, tree, 0);
         }
     }
-    l.color_map = color_map_override(root);
     if let Some(ext) = root.child("extLst").filter(|e| !has_rel_refs(e)) {
         l.raw_ext = Some(ext.elements().map(|e| part.keep(e)).collect());
     }
     l
 }
 
-/// A layout's or slide's `clrMapOvr/overrideClrMapping` (None for `masterClrMapping` or none).
-fn color_map_override(root: &El) -> Option<Vec<(String, String)>> {
-    root.child("clrMapOvr")?.child("overrideClrMapping").map(color_map)
-}
-
 fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: LayoutId) -> Slide {
     let root = &doc.root;
     let mut s = Slide {
@@ -701,7 +536,6 @@ fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: Layout
         layout,
         hidden: root.bool("show") == Some(false),
         show_master_shapes: root.bool("showMasterSp").unwrap_or(true),
-        color_map: color_map_override(root),
         ..Default::default()
     };
     let mut ctx = shapes::IdCtx::default();
@@ -711,10 +545,6 @@ fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: Layout
         if let Some(tree) = csld.child("spTree") {
             s.shapes = shapes::sp_tree(imp, part, &mut ctx, tree, 0);
         }
-        if let Some(c) = csld.child("controls") {
-            let pics = shapes::controls(imp, part, &mut ctx, c);
-            s.shapes.extend(pics);
-        }
     }
     if let Some(t) = root.child("transition") {
         s.transition = timing::transition(imp, part, t);

crates/pptx/src/read/shapes.rs

@@ -87,22 +87,6 @@ pub fn sp_tree(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, tree: &El, depth: us
     out
 }
 
-/// ActiveX controls (`p:controls`): each control's picture (`p:pic`), the image PowerPoint shows
-/// for it, as a picture above the slide's shapes. Controls without one are left out.
-pub fn controls(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, controls: &El) -> Vec<Shape> {
-    let mut out = vec![];
-    for c in controls.children_named("control") {
-        if ctx.count >= MAX_SHAPES {
-            break;
-        }
-        if let Some(p) = c.child("pic") {
-            ctx.count += 1;
-            out.push(pic(imp, part, ctx, p));
-        }
-    }
-    out
-}
-
 fn remap_connectors(shapes: &mut [Shape], ctx: &IdCtx, depth: usize) {
     if depth > MAX_TREE_DEPTH {
         return;
@@ -120,18 +104,6 @@ fn remap_connectors(shapes: &mut [Shape], ctx: &IdCtx, depth: usize) {
     }
 }
 
-/// PowerPoint's Lock (right-click > Lock, the Selection pane padlock) writes a full set of locking
-/// attributes; it reads an object as locked only when the whole set for its kind is there, so a
-/// lone `noMove` or `noResize` (other tools' partial locks) isn't Lock.
-fn is_locked(l: &El) -> bool {
-    let set: &[&str] = match l.local() {
-        "grpSpLocks" => &["noGrp", "noUngrp", "noRot", "noMove", "noResize"],
-        "graphicFrameLocks" => &["noGrp", "noDrilldown", "noMove", "noResize"],
-        _ => &["noGrp", "noRot", "noMove", "noResize", "noEditPoints", "noAdjustHandles", "noChangeArrowheads", "noChangeShapeType"],
-    };
-    set.iter().all(|a| l.bool(a) == Some(true))
-}
-
 /// Common non-visual properties (`p:nvSpPr`, `p:nvPicPr`…).
 fn base(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, nv: Option<&El>) -> Shape {
     let c = nv.and_then(|n| n.child("cNvPr"));
@@ -150,10 +122,10 @@ fn base(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, nv: Option<&El>) -> Shape {
             match e.local() {
                 "cNvSpPr" => {
                     s.text_box = e.bool("txBox").unwrap_or(false);
-                    s.locked = e.child("spLocks").is_some_and(is_locked);
+                    s.locked = e.child("spLocks").is_some_and(|l| l.bool("noMove") == Some(true) && l.bool("noResize") == Some(true));
                 }
                 "cNvPicPr" | "cNvGrpSpPr" | "cNvCxnSpPr" | "cNvGraphicFramePr" => {
-                    s.locked = e.elements().find(|l| l.local().ends_with("Locks")).is_some_and(is_locked);
+                    s.locked = e.elements().next().is_some_and(|l| l.bool("noMove") == Some(true) && l.bool("noResize") == Some(true));
                 }
                 "nvPr" => {
                     if let Some(ph) = e.child("ph") {
@@ -208,15 +180,6 @@ fn preset_geom(pg: &El) -> Geom {
     Geom::Preset { name, adj }
 }
 
-/// A placeholder whose `spPr` names no geometry takes its layout's (or master's) placeholder's:
-/// marked here with an empty custom geometry, filled in once the layouts are read
-/// (`inherit_placeholder_geometry`).
-fn mark_inherited_geometry(s: &mut Shape, pr: Option<&El>) {
-    if s.ph.is_some() && pr.is_none_or(|pr| pr.child("prstGeom").is_none() && pr.child("custGeom").is_none()) {
-        s.geom = Geom::Custom { paths: vec![] };
-    }
-}
-
 /// `spPr` → transform, geometry, fill, line, effects.
 fn sp_pr(imp: &mut Imp, part: &Part, s: &mut Shape, pr: &El) {
     if let Some(x) = pr.child("xfrm") {
@@ -266,7 +229,6 @@ fn sp(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
     if let Some(pr) = e.child("spPr") {
         sp_pr(imp, part, &mut s, pr);
     }
-    mark_inherited_geometry(&mut s, e.child("spPr"));
     if e.bool("useBgFill") == Some(true) {
         s.fill = Some(Fill::Background);
     }
@@ -384,8 +346,7 @@ fn frame(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El, depth: usize) -> S
         let mut pics = vec![];
         e.find_all("blip", &mut pics);
         pics.into_iter().find_map(|b| dml::media_ref(imp, part, b))
-    }
-    .or_else(|| gd.and_then(|g| g.find("oleObj")).and_then(|o| vml_preview(imp, part, o.attr("spid")?)));
+    };
     let label = if let Some(o) = gd.and_then(|g| g.find("oleObj")) {
         o.attr("progId").or(o.attr("name")).unwrap_or("Object").to_string()
     } else if uri.ends_with("/diagram") {
@@ -399,21 +360,6 @@ fn frame(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El, depth: usize) -> S
     s
 }
 
-/// The preview picture of an old-style embedded object (`p:oleObj spid` with no `p:pic`): the
-/// `v:imagedata` of the legacy VML drawing shape with that id, as PowerPoint 2007 wrote them.
-fn vml_preview(imp: &mut Imp, part: &Part, spid: &str) -> Option<deckcraft_model::MediaId> {
-    for rel in part.rels.items.iter().filter(|r| r.kind == "vmlDrawing" && !r.external) {
-        let Some(doc) = imp.pkg.xml(&rel.target) else { continue };
-        let mut shapes = vec![];
-        doc.root.find_all("shape", &mut shapes);
-        let Some(img) = shapes.into_iter().find(|s| s.attr("id") == Some(spid)).and_then(|s| s.find("imagedata")) else { continue };
-        let Some(id) = img.attr("o:relid").or(img.attr("r:id")) else { continue };
-        let target = imp.pkg.rels(&rel.target).get(id).filter(|r| !r.external).map(|r| r.target.clone())?;
-        return imp.media_for(&target);
-    }
-    None
-}
-
 /// SmartArt: read the pre-drawn shapes of its drawing part as a group.
 fn smartart(imp: &mut Imp, part: &Part, gd: &El, frame: &Shape, depth: usize) -> Option<Shape> {
     let rel_ids = gd.child("relIds")?;
@@ -436,11 +382,8 @@ fn smartart(imp: &mut Imp, part: &Part, gd: &El, frame: &Shape, depth: usize) ->
 }
 
 fn table(imp: &mut Imp, part: &Part, tbl: &El) -> Table {
-    // A table naming no style is drawn by PowerPoint with thin dark grid lines ("No Style, Table
-    // Grid"), not without lines.
-    let mut t = Table { style: "grid".into(), first_row: false, band_row: false, ..Default::default() };
+    let mut t = Table { style: "none".into(), first_row: false, band_row: false, ..Default::default() };
     if let Some(pr) = tbl.child("tblPr") {
-        t.background = pr.elements().find(|e| e.local().ends_with("Fill") && e.local() != "noFill").and_then(|f| dml::fill_el(imp, part, f));
         t.first_row = pr.bool("firstRow").unwrap_or(false);
         t.first_col = pr.bool("firstCol").unwrap_or(false);
         t.last_row = pr.bool("lastRow").unwrap_or(false);
@@ -448,11 +391,7 @@ fn table(imp: &mut Imp, part: &Part, tbl: &El) -> Table {
         t.band_row = pr.bool("bandRow").unwrap_or(false);
         t.band_col = pr.bool("bandCol").unwrap_or(false);
         if let Some(id) = pr.child("tableStyleId").map(|e| e.text()) {
-            // A style the file defines is drawn from its definition (by its GUID).
-            // DeckCraft's own styles (written with GUIDs derived from their ids) map back to them.
-            let up = id.trim().to_ascii_uppercase();
-            t.style =
-                if imp.table_style_ids.contains(&up) && !crate::tables::is_own_guid(&up) { up } else { crate::tables::style_from_guid(id.trim()) };
+            t.style = crate::tables::style_from_guid(id.trim());
         }
     }
     t.cols = tbl

crates/pptx/src/tables.rs

@@ -47,12 +47,6 @@ fn own_guid(style: &str) -> String {
     guid(&format!("deckcraft-table-style:{style}"))
 }
 
-/// Is `g` the GUID DeckCraft writes for one of its own styles?
-pub fn is_own_guid(g: &str) -> bool {
-    let up = g.to_ascii_uppercase();
-    deckcraft_model::table::table_styles().iter().any(|(id, _)| own_guid(id) == up)
-}
-
 /// Table style GUID → our style id (or the GUID itself when unknown).
 pub fn style_from_guid(g: &str) -> String {
     let up = g.to_ascii_uppercase();
@@ -204,9 +198,8 @@ fn style_def(w: &mut W, id: &str, name: &str) {
     w.close("a:tblStyle");
 }
 
-/// `ppt/tableStyles.xml` with definitions for the styles in `used`: ours, generated, and those the
-/// opened file defined (`defs`), written back as they were read.
-pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec<u8> {
+/// `ppt/tableStyles.xml` with definitions for the styles in `used`.
+pub fn table_styles_xml(used: &[String]) -> Vec<u8> {
     let mut w = W::new();
     w.open("a:tblStyleLst", A::new().a("xmlns:a", NS_A).a("def", "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"));
     let names = deckcraft_model::table::table_styles();
@@ -216,12 +209,6 @@ pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableSt
             continue;
         }
         done.push(s);
-        if let Some(d) = defs.iter().find(|d| d.id.eq_ignore_ascii_case(s))
-            && crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle"))
-        {
-            w.raw(&d.raw);
-            continue;
-        }
         let (_, define) = guid_for_style(s);
         if !define {
             continue;
@@ -244,7 +231,7 @@ mod tests {
             "nwCell",
         ];
         let used: Vec<String> = deckcraft_model::table::table_styles().into_iter().map(|(id, _)| id).collect();
-        let d = crate::xml::parse(&table_styles_xml(&used, &[])).unwrap();
+        let d = crate::xml::parse(&table_styles_xml(&used)).unwrap();
         let mut n = 0;
         for st in d.root.children_named("tblStyle") {
             n += 1;

crates/pptx/src/write/chart.rs

@@ -467,7 +467,7 @@ pub fn chart_xml(c: &Chart) -> Vec<u8> {
         };
         w.open0("c:legend");
         w.val("c:legendPos", p);
-        w.val("c:overlay", u8::from(c.legend_overlay));
+        w.val("c:overlay", 0);
         w.close("c:legend");
     }
     w.val("c:plotVisOnly", 1);

crates/pptx/src/write/dml.rs

@@ -76,7 +76,40 @@ pub fn fill(w: &mut W, x: &mut Exp, o: &mut Out, f: &Fill) {
     match f {
         Fill::None => w.empty0("a:noFill"),
         Fill::Solid { color: c } => solid(w, c),
-        Fill::Gradient(g) => gradient(w, g),
+        Fill::Gradient(g) => {
+            w.open("a:gradFill", A::new().a("rotWithShape", if g.rotate_with_shape { "1" } else { "0" }));
+            w.open0("a:gsLst");
+            let mut stops = g.stops.clone();
+            if stops.is_empty() {
+                stops.push(deckcraft_model::style::GradientStop { pos: 0.0, color: ColorRef::rgb(deckcraft_color::Rgba::WHITE) });
+            }
+            if stops.len() == 1 {
+                let mut s = stops[0].clone();
+                s.pos = 1.0;
+                stops.push(s);
+            }
+            for s in &stops {
+                w.open("a:gs", A::new().a("pos", pct(s.pos.clamp(0.0, 1.0))));
+                color(w, &s.color);
+                w.close("a:gs");
+            }
+            w.close("a:gsLst");
+            match &g.shape {
+                GradientShape::Linear { angle, scaled } => {
+                    w.empty("a:lin", A::new().a("ang", ang(*angle)).a("scaled", if *scaled { "1" } else { "0" }))
+                }
+                GradientShape::Path { path, focus } => {
+                    let p = match path.as_str() {
+                        "rect" | "shape" | "circle" => path.as_str(),
+                        _ => "circle",
+                    };
+                    w.open("a:path", A::new().a("path", p));
+                    w.empty("a:fillToRect", A::new().a("l", pct(focus[0])).a("t", pct(focus[1])).a("r", pct(focus[2])).a("b", pct(focus[3])));
+                    w.close("a:path");
+                }
+            }
+            w.close("a:gradFill");
+        }
         Fill::Picture(pf) => blip_fill(w, x, o, "a:blipFill", pf),
         Fill::Pattern(p) => {
             w.open("a:pattFill", A::new().a("prst", if p.preset.is_empty() { "pct5" } else { &p.preset }));
@@ -96,16 +129,10 @@ pub fn fill(w: &mut W, x: &mut Exp, o: &mut Out, f: &Fill) {
 /// `a:blipFill` / `p:blipFill`.
 pub fn blip_fill(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, pf: &PictureFill) {
     let rid = x.media_rel(o, pf.media, "image").unwrap_or_else(|| x.placeholder_rel(o));
-    w.open(tag, A::new().a("rotWithShape", if pf.upright { "0" } else { "1" }));
+    w.open(tag, A::new().a("rotWithShape", "1"));
     let adj = &pf.adjust;
-    let has_kids = pf.alpha.is_some()
-        || adj.brightness != 0.0
-        || adj.contrast != 0.0
-        || adj.grayscale
-        || adj.duotone.is_some()
-        || adj.clear_color.is_some()
-        || adj.bilevel.is_some()
-        || adj.alpha_inv;
+    let has_kids =
+        pf.alpha.is_some() || adj.brightness != 0.0 || adj.contrast != 0.0 || adj.grayscale || adj.duotone.is_some() || adj.clear_color.is_some();
     let a = A::new().a("r:embed", &rid);
     if has_kids {
         w.open("a:blip", a);
@@ -122,12 +149,6 @@ pub fn blip_fill(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, pf: &PictureFil
         if let Some(al) = pf.alpha {
             w.empty("a:alphaModFix", A::new().a("amt", pct(al.clamp(0.0, 1.0))));
         }
-        if adj.alpha_inv {
-            w.empty0("a:alphaInv");
-        }
-        if let Some(t) = adj.bilevel {
-            w.empty("a:biLevel", A::new().a("thresh", pct(t.clamp(0.0, 1.0))));
-        }
         if let Some((d, l)) = &adj.duotone {
             w.open0("a:duotone");
             color(w, d);
@@ -254,59 +275,8 @@ fn shadow(w: &mut W, tag: &str, s: &deckcraft_model::style::Shadow) {
     w.close(tag);
 }
 
-fn gradient(w: &mut W, g: &deckcraft_model::style::Gradient) {
-    w.open("a:gradFill", A::new().a("rotWithShape", if g.rotate_with_shape { "1" } else { "0" }));
-    // No stops: no `a:gsLst`, so the gradient keeps taking them from its style's fill.
-    let mut stops = g.stops.clone();
-    if stops.len() == 1 {
-        let mut s = stops[0].clone();
-        s.pos = 1.0;
-        stops.push(s);
-    }
-    if !stops.is_empty() {
-        w.open0("a:gsLst");
-        for s in &stops {
-            w.open("a:gs", A::new().a("pos", pct(s.pos.clamp(0.0, 1.0))));
-            color(w, &s.color);
-            w.close("a:gs");
-        }
-        w.close("a:gsLst");
-    }
-    match &g.shape {
-        GradientShape::Linear { angle, scaled } => w.empty("a:lin", A::new().a("ang", ang(*angle)).a("scaled", if *scaled { "1" } else { "0" })),
-        GradientShape::Path { path, focus } => {
-            let p = match path.as_str() {
-                "rect" | "shape" | "circle" => path.as_str(),
-                _ => "circle",
-            };
-            w.open("a:path", A::new().a("path", p));
-            w.empty("a:fillToRect", A::new().a("l", pct(focus[0])).a("t", pct(focus[1])).a("r", pct(focus[2])).a("b", pct(focus[3])));
-            w.close("a:path");
-        }
-    }
-    if g.tile.iter().any(|v| *v != 0.0) {
-        let [l, t, r, b] = g.tile;
-        w.empty("a:tileRect", A::new().a("l", pct(l)).a("t", pct(t)).a("r", pct(r)).a("b", pct(b)));
-    }
-    w.close("a:gradFill");
-}
-
 pub fn effects(w: &mut W, fx: &Effects) {
     w.open0("a:effectLst");
-    // Schema order: blur, fillOverlay, glow, innerShdw, outerShdw, prstShdw, reflection, softEdge.
-    if let Some(ov) = &fx.fill_overlay {
-        let blend = match ov.blend.as_str() {
-            b @ ("over" | "mult" | "screen" | "darken" | "lighten") => b,
-            _ => "over",
-        };
-        w.open("a:fillOverlay", A::new().a("blend", blend));
-        match &ov.fill {
-            Fill::Solid { color: c } => solid(w, c),
-            Fill::Gradient(g) => gradient(w, g),
-            _ => w.empty0("a:noFill"),
-        }
-        w.close("a:fillOverlay");
-    }
     if let Some(g) = &fx.glow {
         w.open("a:glow", A::new().a("rad", emu(g.radius).max(0)));
         color(w, &g.color);
@@ -422,19 +392,7 @@ pub fn body_pr(w: &mut W, b: &BodyProps) {
     w.open("a:bodyPr", a);
     if let Some(p) = warp {
         w.open("a:prstTxWarp", A::new().a("prst", p));
-        let adj: Vec<(usize, i64)> =
-            b.warp_adj.iter().take(8).enumerate().filter(|(_, v)| v.is_finite()).map(|(i, v)| (i, v.round().clamp(-2.0e9, 2.0e9) as i64)).collect();
-        if adj.is_empty() {
-            w.empty0("a:avLst");
-        } else {
-            let single = deckcraft_geom::warp::adjust_count(p) <= 1 && b.warp_adj.len() == 1;
-            w.open0("a:avLst");
-            for (i, v) in adj {
-                let n = if single { "adj".to_string() } else { format!("adj{}", i + 1) };
-                w.empty("a:gd", A::new().a("name", n).a("fmla", format!("val {v}")));
-            }
-            w.close("a:avLst");
-        }
+        w.empty0("a:avLst");
         w.close("a:prstTxWarp");
     }
     match b.autofit {
@@ -474,8 +432,6 @@ pub fn ppr(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, level: Option<u8>, p:
         .o("defTabSz", p.default_tab.map(|v| emu(v).max(0)))
         .b("rtl", p.rtl)
         .b("eaLnBrk", p.east_asian_line_break)
-        .b("latinLnBrk", p.latin_line_break)
-        .b("hangingPunct", p.hanging_punct)
         .o("fontAlgn", p.font_align.as_deref().filter(|f| matches!(*f, "auto" | "t" | "ctr" | "base" | "b")));
     let has_kids = p.line_spacing.is_some()
         || p.space_before.is_some()

crates/pptx/src/write/mod.rs

@@ -227,21 +227,6 @@ const CLR_KEYS: [(&str, &str); 12] = [
 ];
 
 fn clr_map(w: &mut W, map: &[(String, String)]) {
-    w.empty("p:clrMap", clr_map_attrs(map));
-}
-
-/// `p:clrMapOvr`: the layout's or slide's own colour map, else `a:masterClrMapping`.
-fn clr_map_ovr(w: &mut W, map: Option<&[(String, String)]>) {
-    w.open0("p:clrMapOvr");
-    match map {
-        Some(m) => w.empty("a:overrideClrMapping", clr_map_attrs(m)),
-        None => w.empty0("a:masterClrMapping"),
-    }
-    w.close("p:clrMapOvr");
-}
-
-/// The twelve colour map attributes, each a theme slot (the default for anything else).
-fn clr_map_attrs(map: &[(String, String)]) -> A {
     let mut a = A::new();
     for (k, d) in CLR_KEYS {
         let v = map
@@ -252,7 +237,7 @@ fn clr_map_attrs(map: &[(String, String)]) -> A {
             .unwrap_or(d);
         a = a.a(k, v);
     }
-    a
+    w.empty("p:clrMap", a);
 }
 
 fn ext_list(w: &mut W, raw: Option<&str>) {
@@ -512,7 +497,7 @@ pub fn export(p: &Presentation) -> Result<Vec<u8>, PptxError> {
     pres.rels.add("tableStyles", "tableStyles.xml", false);
     x.pkg.xml_part("ppt/presProps.xml", CT_PRES_PROPS, pres_props_xml(p));
     x.pkg.xml_part("ppt/viewProps.xml", CT_VIEW_PROPS, view_props_xml());
-    let ts = crate::tables::table_styles_xml(&x.table_styles, &p.table_styles);
+    let ts = crate::tables::table_styles_xml(&x.table_styles);
     x.pkg.xml_part("ppt/tableStyles.xml", CT_TABLE_STYLES, ts);
     let pxml = presentation_xml(&mut x, &mut pres, &master_rids, notes_master_rid.as_deref(), &slide_rids);
     x.pkg.xml_part("ppt/presentation.xml", CT_PRES, pxml);
@@ -537,7 +522,9 @@ fn layout_xml(x: &mut Exp, o: &mut Out, l: &Layout) -> Vec<u8> {
         A::new().o("showMasterSp", (!l.show_master_shapes).then_some("0")).a("type", l.kind.xml()).t("preserve", l.preserve),
     );
     csld(&mut w, x, o, &l.name, l.background.as_ref(), &l.shapes);
-    clr_map_ovr(&mut w, l.color_map.as_deref());
+    w.open0("p:clrMapOvr");
+    w.empty0("a:masterClrMapping");
+    w.close("p:clrMapOvr");
     ext_list(&mut w, ext_children(l.raw_ext.as_deref()).as_deref());
     w.close("p:sldLayout");
     w.finish()
@@ -569,7 +556,9 @@ fn slide_xml(x: &mut Exp, o: &mut Out, s: &Slide) -> Vec<u8> {
     let mut w = W::new();
     root_open(&mut w, "p:sld", A::new().o("showMasterSp", (!s.show_master_shapes).then_some("0")).o("show", s.hidden.then_some("0")));
     let ids = csld(&mut w, x, o, &s.name, s.background.as_ref(), &s.shapes);
-    clr_map_ovr(&mut w, s.color_map.as_deref());
+    w.open0("p:clrMapOvr");
+    w.empty0("a:masterClrMapping");
+    w.close("p:clrMapOvr");
     if let Some(t) = &s.transition {
         timing::transition(&mut w, x, o, t);
     }

crates/pptx/src/write/shapes.rs

@@ -177,24 +177,8 @@ fn nv_pr(w: &mut W, s: &Shape) {
     }
 }
 
-/// Locking attributes. Lock writes the full set PowerPoint writes for the element's kind (and
-/// reads back as locked): see `read::shapes::is_locked`.
 fn locks(w: &mut W, tag: &str, s: &Shape, extra: A) {
-    let a = extra.t("noGrp", s.ph.is_some() || s.locked);
-    let a = match tag {
-        "a:grpSpLocks" => a.t("noUngrp", s.locked).t("noRot", s.locked).t("noMove", s.locked).t("noResize", s.locked),
-        _ => {
-            let a = a
-                .t("noRot", s.locked)
-                .t("noMove", s.locked)
-                .t("noResize", s.locked)
-                .t("noEditPoints", s.locked)
-                .t("noAdjustHandles", s.locked)
-                .t("noChangeArrowheads", s.locked)
-                .t("noChangeShapeType", s.locked);
-            if tag == "a:picLocks" { a.t("noCrop", s.locked) } else { a }
-        }
-    };
+    let a = extra.t("noGrp", s.ph.is_some()).t("noMove", s.locked).t("noResize", s.locked);
     if a.v.is_empty() {
         return;
     }
@@ -474,7 +458,7 @@ fn frame_open(w: &mut W, x: &mut Exp, o: &mut Out, id: u32, s: &Shape) {
     w.open0("p:nvGraphicFramePr");
     cnvpr(w, x, o, id, s);
     w.open0("p:cNvGraphicFramePr");
-    w.empty("a:graphicFrameLocks", A::new().a("noGrp", "1").t("noDrilldown", s.locked).t("noMove", s.locked).t("noResize", s.locked));
+    w.empty("a:graphicFrameLocks", A::new().a("noGrp", "1").t("noMove", s.locked).t("noResize", s.locked));
     w.close("p:cNvGraphicFramePr");
     nv_pr(w, s);
     w.close("p:nvGraphicFramePr");
@@ -510,9 +494,6 @@ fn table(w: &mut W, x: &mut Exp, o: &mut Out, t: &Table) {
             .t("bandRow", t.band_row)
             .t("bandCol", t.band_col),
     );
-    if let Some(f) = &t.background {
-        dml::fill(w, x, o, f);
-    }
     w.elt("a:tableStyleId", &guid);
     w.close("a:tblPr");
     w.open0("a:tblGrid");

crates/pptx/tests/fills.rs

@@ -1,251 +0,0 @@
-//! Fills read from decks written by other tools.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_geom::Xfrm;
-use deckcraft_model::style::{Fill, PictureFill, PictureMode};
-use deckcraft_model::{Shape, ShapeId, defaults};
-
-/// `bytes` with `edit` applied to every slide part.
-fn edit_slides(bytes: &[u8], edit: impl Fn(String) -> String) -> Vec<u8> {
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        let name = f.name().to_string();
-        if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
-            d = edit(String::from_utf8(d).expect("utf8")).into_bytes();
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-fn png() -> Vec<u8> {
-    let mut out = Cursor::new(vec![]);
-    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(4, 4, image::Rgb([10, 200, 30])))
-        .write_to(&mut out, image::ImageFormat::Png)
-        .expect("png");
-    out.into_inner()
-}
-
-/// A deck with one shape filled with a stretched picture, exported.
-fn deck() -> Vec<u8> {
-    let mut p = defaults::new_presentation(None);
-    let media = p.add_media("tile.png", "image/png", png());
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Textured".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::Picture(PictureFill { media, ..Default::default() })),
-        ..Default::default()
-    });
-    deckcraft_pptx::export(&p).expect("export")
-}
-
-fn textured_mode(bytes: &[u8]) -> PictureMode {
-    let q = deckcraft_pptx::import(bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Textured").expect("shape");
-    match &s.fill {
-        Some(Fill::Picture(pf)) => pf.mode.clone(),
-        other => panic!("{other:?}"),
-    }
-}
-
-#[test]
-fn a_shape_picture_fill_without_stretch_or_tile_tiles() {
-    // tdf#128596: `<a:blipFill><a:blip/></a:blipFill>` on a shape, as some tools write it;
-    // PowerPoint tiles the picture at its own size.
-    let bare = edit_slides(&deck(), |s| {
-        let s = regex_free_strip(&s, "<a:stretch>", "</a:stretch>");
-        assert!(!s.contains("<a:stretch"), "the test deck lost its stretch");
-        s
-    });
-    assert!(matches!(textured_mode(&bare), PictureMode::Tile { sx, sy, .. } if sx == 1.0 && sy == 1.0));
-    // An explicit stretch is still a stretch.
-    assert!(matches!(textured_mode(&deck()), PictureMode::Stretch { .. }));
-}
-
-/// `s` without the first `open`…`close` span inside a `blipFill`.
-fn regex_free_strip(s: &str, open: &str, close: &str) -> String {
-    let Some(b) = s.find("<a:blipFill") else { return s.to_string() };
-    let Some(i) = s[b..].find(open).map(|i| i + b) else { return s.to_string() };
-    let Some(j) = s[i..].find(close).map(|j| j + i + close.len()) else { return s.to_string() };
-    format!("{}{}", &s[..i], &s[j..])
-}
-
-#[test]
-fn a_gradient_without_stops_is_saved_without_stops() {
-    // `a:gradFill` with no `a:gsLst` takes its stops from the style's fill in PowerPoint; saving
-    // must not turn it into a gradient of its own (it used to become solid white).
-    use deckcraft_model::style::{Gradient, GradientShape};
-    let mut p = defaults::new_presentation(None);
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    let own = Gradient { tile: [0.0; 4], stops: vec![], shape: GradientShape::Linear { angle: 45.0, scaled: true }, rotate_with_shape: true };
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Styled".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::Gradient(own.clone())),
-        style: Some(deckcraft_model::ShapeStyle::accent(deckcraft_color::SchemeSlot::Accent1)),
-        ..Default::default()
-    });
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let q = deckcraft_pptx::import(&bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Styled").expect("shape");
-    assert_eq!(s.fill, Some(Fill::Gradient(own)));
-}
-
-#[test]
-fn a_fill_overlay_round_trips() {
-    use deckcraft_model::style::{FillOverlay, Gradient, GradientShape, GradientStop};
-    let mut p = defaults::new_presentation(None);
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    let overlay = FillOverlay {
-        blend: "mult".into(),
-        fill: Fill::Gradient(Gradient {
-            tile: [0.0; 4],
-            stops: vec![
-                GradientStop { pos: 0.0, color: deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent1) },
-                GradientStop { pos: 1.0, color: deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(10, 20, 30)) },
-            ],
-            shape: GradientShape::Linear { angle: 4.5, scaled: true },
-            rotate_with_shape: true,
-        }),
-    };
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Overlaid".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::solid(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::WHITE))),
-        effects: Some(deckcraft_model::Effects { fill_overlay: Some(overlay.clone()), ..Default::default() }),
-        ..Default::default()
-    });
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let q = deckcraft_pptx::import(&bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Overlaid").expect("shape");
-    assert_eq!(s.effects.as_ref().and_then(|e| e.fill_overlay.clone()), Some(overlay));
-}
-
-#[test]
-fn a_gradient_tile_rect_is_read_and_round_trips() {
-    use deckcraft_model::style::{Gradient, GradientShape, GradientStop};
-    // PowerPoint's "from top-left corner" radial: focus on the corner, tile reaching a box up and
-    // to the left so it centres on that corner.
-    let g = Gradient {
-        stops: vec![
-            GradientStop { pos: 0.0, color: deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(0, 128, 255)) },
-            GradientStop { pos: 1.0, color: deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::WHITE) },
-        ],
-        shape: GradientShape::Path { path: "circle".into(), focus: [0.0, 0.0, 1.0, 1.0] },
-        rotate_with_shape: true,
-        tile: [-1.0, -1.0, 0.0, 0.0],
-    };
-    let mut p = defaults::new_presentation(None);
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Corner".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::Gradient(g.clone())),
-        ..Default::default()
-    });
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let q = deckcraft_pptx::import(&bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Corner").expect("shape");
-    assert_eq!(s.fill, Some(Fill::Gradient(g)));
-    // As written by PowerPoint (attributes it leaves out are 0).
-    let edited =
-        edit_slides(&bytes, |x| x.replace("<a:tileRect l=\"-100000\" t=\"-100000\" r=\"0\" b=\"0\"/>", "<a:tileRect l=\"-100000\" t=\"-100000\"/>"));
-    let q = deckcraft_pptx::import(&edited).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Corner").expect("shape");
-    assert!(matches!(&s.fill, Some(Fill::Gradient(g)) if g.tile == [-1.0, -1.0, 0.0, 0.0]), "{:?}", s.fill);
-}
-
-#[test]
-fn a_table_naming_no_style_is_drawn_with_the_table_grid() {
-    let mut p = defaults::new_presentation(None);
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    let mut t = deckcraft_model::Table::new(2, 2, 200.0, 40.0);
-    t.style = "none".into();
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Grid".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 80.0)),
-        kind: deckcraft_model::ShapeKind::Table(t),
-        ..Default::default()
-    });
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let style = |bytes: &[u8]| {
-        let q = deckcraft_pptx::import(bytes).expect("import");
-        let s = q.slides[0].shapes.iter().find(|s| s.name == "Grid").expect("shape").clone();
-        match s.kind {
-            deckcraft_model::ShapeKind::Table(t) => t.style,
-            other => panic!("{other:?}"),
-        }
-    };
-    // Written with its style, it reads back as written.
-    assert_eq!(style(&bytes), "none");
-    // Without a:tableStyleId PowerPoint draws thin dark grid lines.
-    let bare = edit_slides(&bytes, |x| {
-        let (Some(a), Some(b)) = (x.find("<a:tableStyleId>"), x.find("</a:tableStyleId>")) else { return x };
-        format!("{}{}", &x[..a], &x[b + "</a:tableStyleId>".len()..])
-    });
-    assert_eq!(style(&bare), "grid");
-}
-
-#[test]
-fn black_and_white_and_inverted_alpha_pictures_round_trip() {
-    let mut p = defaults::new_presentation(None);
-    let media = p.add_media("tile.png", "image/png", png());
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    let mut pf = PictureFill { media, ..Default::default() };
-    pf.adjust.bilevel = Some(0.3);
-    pf.adjust.alpha_inv = true;
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "BW".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::Picture(pf)),
-        ..Default::default()
-    });
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let q = deckcraft_pptx::import(&bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "BW").expect("shape");
-    match &s.fill {
-        Some(Fill::Picture(pf)) => assert_eq!((pf.adjust.bilevel, pf.adjust.alpha_inv), (Some(0.3), true)),
-        other => panic!("{other:?}"),
-    }
-}
-
-#[test]
-fn an_upright_picture_fill_round_trips() {
-    let bytes = deck();
-    let edited = edit_slides(&bytes, |x| x.replacen("rotWithShape=\"1\"", "rotWithShape=\"0\"", 1));
-    let q = deckcraft_pptx::import(&edited).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Textured").expect("shape");
-    let Some(Fill::Picture(pf)) = &s.fill else { panic!("{:?}", s.fill) };
-    assert!(pf.upright);
-    let again = deckcraft_pptx::export(&q).expect("export");
-    let r = deckcraft_pptx::import(&again).expect("import");
-    let s = r.slides[0].shapes.iter().find(|s| s.name == "Textured").expect("shape");
-    assert!(matches!(&s.fill, Some(Fill::Picture(pf)) if pf.upright));
-    // Rotating with the shape is the default.
-    assert!(matches!(textured_fill(&bytes), Some(Fill::Picture(pf)) if !pf.upright));
-}
-
-fn textured_fill(bytes: &[u8]) -> Option<Fill> {
-    let q = deckcraft_pptx::import(bytes).expect("import");
-    q.slides[0].shapes.iter().find(|s| s.name == "Textured").and_then(|s| s.fill.clone())
-}

crates/pptx/tests/locks.rs

@@ -1,211 +0,0 @@
-//! Lock and hidden state (Selection pane): what PowerPoint writes for Lock, and what it reads as locked.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_geom::Xfrm;
-use deckcraft_model::style::PictureFill;
-use deckcraft_model::table::Table;
-use deckcraft_model::{Presentation, Shape, ShapeId, ShapeKind, Slide, defaults};
-
-fn png() -> Vec<u8> {
-    let img = image::RgbImage::from_pixel(4, 4, image::Rgb([10, 200, 30]));
-    let mut out = Cursor::new(vec![]);
-    image::DynamicImage::ImageRgb8(img).write_to(&mut out, image::ImageFormat::Png).expect("png");
-    out.into_inner()
-}
-
-fn shape(p: &mut Presentation, name: &str, x: f64) -> Shape {
-    Shape { id: ShapeId(p.alloc_id()), name: name.into(), xfrm: Some(Xfrm::new(x, 40.0, 80.0, 60.0)), ..Default::default() }
-}
-
-/// Slide 1 of a blank deck holds: a locked shape, an unlocked one, a hidden locked text box, a
-/// locked group (one child unlocked, one hidden), and a locked picture, connector and table.
-fn deck() -> Presentation {
-    let mut p = defaults::new_presentation(None);
-    let img = p.add_media("image1.png", "image/png", png());
-    let mut v = vec![];
-    let mut a = shape(&mut p, "Locked", 0.0);
-    a.locked = true;
-    v.push(a);
-    v.push(shape(&mut p, "Free", 100.0));
-    let mut t = shape(&mut p, "Hidden text", 200.0);
-    t.text_box = true;
-    t.hidden = true;
-    t.locked = true;
-    v.push(t);
-    let mut c1 = shape(&mut p, "Child locked", 300.0);
-    c1.locked = true;
-    let c2 = shape(&mut p, "Child free", 400.0);
-    let mut c3 = shape(&mut p, "Child hidden", 500.0);
-    c3.hidden = true;
-    let gx = Xfrm::new(300.0, 40.0, 280.0, 60.0);
-    let mut g = Shape {
-        id: ShapeId(p.alloc_id()),
-        name: "Group".into(),
-        xfrm: Some(gx),
-        kind: ShapeKind::Group { children: vec![c1, c2, c3], child: gx },
-        locked: true,
-        ..Default::default()
-    };
-    g.hidden = false;
-    v.push(g);
-    let mut pic = shape(&mut p, "Pic", 0.0);
-    pic.kind = ShapeKind::Picture { fill: PictureFill { media: img, ..Default::default() } };
-    pic.locked = true;
-    v.push(pic);
-    let mut cx = shape(&mut p, "Conn", 100.0);
-    cx.kind = ShapeKind::Connector { start: None, end: None };
-    cx.geom = deckcraft_model::Geom::preset("straightConnector1");
-    cx.locked = true;
-    v.push(cx);
-    let mut tb = shape(&mut p, "Tbl", 200.0);
-    tb.kind = ShapeKind::Table(Table::new(2, 2, 80.0, 30.0));
-    tb.locked = true;
-    v.push(tb);
-    if let Some(s) = p.slides.first_mut() {
-        std::sync::Arc::make_mut(s).shapes = v;
-    }
-    p
-}
-
-fn find<'a>(s: &'a Slide, name: &str) -> &'a Shape {
-    let mut found = None;
-    deckcraft_model::walk(&s.shapes, &mut |x, _| {
-        if found.is_none() && x.name == name {
-            found = Some(x);
-        }
-    });
-    found.unwrap_or_else(|| panic!("no shape {name}"))
-}
-
-fn entries(bytes: &[u8]) -> Vec<(String, Vec<u8>)> {
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    (0..z.len())
-        .map(|i| {
-            let mut f = z.by_index(i).expect("entry");
-            let mut d = vec![];
-            f.read_to_end(&mut d).expect("read");
-            (f.name().to_string(), d)
-        })
-        .collect()
-}
-
-fn rezip(es: &[(String, Vec<u8>)]) -> Vec<u8> {
-    let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for (n, d) in es {
-        z.start_file(n.as_str(), o).expect("start");
-        z.write_all(d).expect("write");
-    }
-    z.finish().expect("finish").into_inner()
-}
-
-fn slide1_xml(bytes: &[u8]) -> String {
-    let es = entries(bytes);
-    let (_, d) = es.iter().find(|(n, _)| n == "ppt/slides/slide1.xml").expect("slide1");
-    String::from_utf8(d.clone()).expect("utf8")
-}
-
-/// The element following `name="…"` up to the end of the object's non-visual properties.
-fn nv_of<'a>(xml: &'a str, name: &str) -> &'a str {
-    let i = xml.find(&format!("name=\"{name}\"")).unwrap_or_else(|| panic!("no {name}"));
-    let rest = &xml[i..];
-    let j = rest.find("<p:nvPr").unwrap_or(rest.len());
-    &rest[..j]
-}
-
-#[test]
-fn lock_and_hidden_round_trip() {
-    let p = deck();
-    let q = deckcraft_pptx::import(&deckcraft_pptx::export(&p).expect("export")).expect("import");
-    let s = &q.slides[0];
-    for (name, locked, hidden) in [
-        ("Locked", true, false),
-        ("Free", false, false),
-        ("Hidden text", true, true),
-        ("Group", true, false),
-        ("Child locked", true, false),
-        ("Child free", false, false),
-        ("Child hidden", false, true),
-        ("Pic", true, false),
-        ("Conn", true, false),
-        ("Tbl", true, false),
-    ] {
-        let sh = find(s, name);
-        assert_eq!((sh.locked, sh.hidden), (locked, hidden), "{name}");
-    }
-    // The stacking order of the slide and of the group survives too.
-    let names: Vec<&str> = s.shapes.iter().map(|x| x.name.as_str()).collect();
-    assert_eq!(names, ["Locked", "Free", "Hidden text", "Group", "Pic", "Conn", "Tbl"]);
-    let kids: Vec<&str> = find(s, "Group").children().iter().map(|x| x.name.as_str()).collect();
-    assert_eq!(kids, ["Child locked", "Child free", "Child hidden"]);
-}
-
-#[test]
-fn lock_writes_powerpoints_full_attribute_set() {
-    let xml = slide1_xml(&deckcraft_pptx::export(&deck()).expect("export"));
-    let sp = r#"noGrp="1" noRot="1" noMove="1" noResize="1" noEditPoints="1" noAdjustHandles="1" noChangeArrowheads="1" noChangeShapeType="1""#;
-    assert!(nv_of(&xml, "Locked").contains(&format!("<a:spLocks {sp}/>")), "{}", nv_of(&xml, "Locked"));
-    assert!(nv_of(&xml, "Hidden text").contains(&format!("<a:spLocks {sp}/>")));
-    assert!(nv_of(&xml, "Hidden text").contains(r#"hidden="1""#));
-    assert!(!nv_of(&xml, "Free").contains("Locks"), "an unlocked shape writes no locks: {}", nv_of(&xml, "Free"));
-    assert!(nv_of(&xml, "Group").contains(r#"<a:grpSpLocks noGrp="1" noUngrp="1" noRot="1" noMove="1" noResize="1"/>"#));
-    assert!(nv_of(&xml, "Conn").contains(&format!("<a:cxnSpLocks {sp}/>")), "{}", nv_of(&xml, "Conn"));
-    assert!(nv_of(&xml, "Pic").contains(&format!(r#"<a:picLocks noChangeAspect="1" {sp} noCrop="1"/>"#)), "{}", nv_of(&xml, "Pic"));
-    assert!(nv_of(&xml, "Tbl").contains(r#"<a:graphicFrameLocks noGrp="1" noDrilldown="1" noMove="1" noResize="1"/>"#));
-}
-
-/// PowerPoint reads Lock only from the whole set: a lone `noMove`/`noResize` (another tool's
-/// partial lock), or the set without `noGrp`, isn't locked.
-#[test]
-fn partial_locks_are_not_lock() {
-    let mut p = defaults::new_presentation(None);
-    let a = shape(&mut p, "A", 0.0);
-    let b = shape(&mut p, "B", 100.0);
-    let c = shape(&mut p, "C", 200.0);
-    let mut d = shape(&mut p, "D", 300.0);
-    d.locked = true;
-    if let Some(s) = p.slides.first_mut() {
-        std::sync::Arc::make_mut(s).shapes = vec![a, b, c, d];
-    }
-    let mut es = entries(&deckcraft_pptx::export(&p).expect("export"));
-    let slide = es.iter_mut().find(|(n, _)| n == "ppt/slides/slide1.xml").expect("slide1");
-    let xml = String::from_utf8(slide.1.clone()).expect("utf8");
-    let swap = |xml: String, name: &str, locks: &str| {
-        let i = xml.find(&format!("name=\"{name}\"")).expect("name");
-        let j = i + xml[i..].find("<p:cNvSpPr").expect("cNvSpPr");
-        let k = j + xml[j..].find("<p:nvPr").expect("nvPr");
-        format!("{}<p:cNvSpPr>{locks}</p:cNvSpPr>{}", &xml[..j], &xml[k..])
-    };
-    let xml = swap(xml, "A", r#"<a:spLocks noMove="1" noResize="1"/>"#);
-    let xml = swap(
-        xml,
-        "B",
-        r#"<a:spLocks noRot="1" noMove="1" noResize="1" noEditPoints="1" noAdjustHandles="1" noChangeArrowheads="1" noChangeShapeType="1"/>"#,
-    );
-    let xml =
-        swap(xml, "C", r#"<a:spLocks noGrp="1" noRot="1" noMove="1" noResize="1" noEditPoints="1" noAdjustHandles="1" noChangeShapeType="1"/>"#);
-    slide.1 = xml.into_bytes();
-    let q = deckcraft_pptx::import(&rezip(&es)).expect("import");
-    let s = &q.slides[0];
-    assert!(!find(s, "A").locked);
-    assert!(!find(s, "B").locked);
-    assert!(!find(s, "C").locked);
-    assert!(find(s, "D").locked);
-}
-
-/// Unlocked objects written by PowerPoint keep an empty locks element; that's not locked.
-#[test]
-fn empty_locks_element_is_unlocked() {
-    let mut p = defaults::new_presentation(None);
-    let a = shape(&mut p, "A", 0.0);
-    if let Some(s) = p.slides.first_mut() {
-        std::sync::Arc::make_mut(s).shapes = vec![a];
-    }
-    let mut es = entries(&deckcraft_pptx::export(&p).expect("export"));
-    let slide = es.iter_mut().find(|(n, _)| n == "ppt/slides/slide1.xml").expect("slide1");
-    let xml = String::from_utf8(slide.1.clone()).expect("utf8").replacen("<p:cNvSpPr/>", "<p:cNvSpPr><a:spLocks/></p:cNvSpPr>", 1);
-    slide.1 = xml.into_bytes();
-    let q = deckcraft_pptx::import(&rezip(&es)).expect("import");
-    assert!(!find(&q.slides[0], "A").locked);
-}

crates/pptx/tests/ole.rs

@@ -1,98 +0,0 @@
-//! Embedded (OLE) objects and their preview pictures, as other versions of PowerPoint write them.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_model::{ShapeKind, defaults};
-
-fn png() -> Vec<u8> {
-    let mut out = Cursor::new(vec![]);
-    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(4, 4, image::Rgb([10, 200, 30])))
-        .write_to(&mut out, image::ImageFormat::Png)
-        .expect("png");
-    out.into_inner()
-}
-
-/// An exported deck with `parts` added (or replaced) and `edit` applied to every part's text.
-fn with_parts(parts: &[(&str, Vec<u8>)], edit: impl Fn(&str, String) -> String) -> Vec<u8> {
-    let base = deckcraft_pptx::export(&defaults::new_presentation(None)).expect("export");
-    let mut z = zip::ZipArchive::new(Cursor::new(base)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let name = f.name().to_string();
-        if parts.iter().any(|(n, _)| *n == name) {
-            continue;
-        }
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        if name.ends_with(".xml") || name.ends_with(".rels") {
-            d = edit(&name, String::from_utf8(d).expect("utf8")).into_bytes();
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    for (name, data) in parts {
-        out.start_file(*name, o).expect("start");
-        out.write_all(data).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-/// PowerPoint 2007 style: `p:oleObj spid` with no `p:pic`; the preview is the `v:imagedata` of the
-/// VML shape with that id in the slide's legacy drawing part.
-fn ole_deck(spid_in_vml: &str) -> Vec<u8> {
-    let vml = format!(
-        r#"<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office">
- <v:shape id="_x0000_s9999" style='position:absolute;left:0;top:0;width:1in;height:1in'><v:imagedata o:relid="rId7" o:title=""/></v:shape>
- <v:shape id="{spid_in_vml}" style='position:absolute;left:0;top:0;width:2in;height:1in'><v:imagedata o:relid="rId1" o:title=""/></v:shape>
-</xml>"#
-    );
-    let vml_rels = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/preview.png"/><Relationship Id="rId7" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/other.png"/></Relationships>"#;
-    let frame = r#"<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="900" name="Object 3"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="0" y="0"/><a:ext cx="1828800" cy="914400"/></p:xfrm><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/presentationml/2006/ole"><p:oleObj spid="_x0000_s681987" name="Slide" r:id="rIdOle" imgW="4664160" imgH="3497400" progId="PowerPoint.Slide.8"><p:embed/></p:oleObj></a:graphicData></a:graphic></p:graphicFrame>"#;
-    with_parts(
-        &[
-            ("ppt/drawings/vmlDrawing1.vml", vml.into_bytes()),
-            ("ppt/drawings/_rels/vmlDrawing1.vml.rels", vml_rels.as_bytes().to_vec()),
-            ("ppt/media/preview.png", png()),
-            ("ppt/media/other.png", vec![1, 2, 3]),
-            ("ppt/embeddings/oleObject1.bin", vec![0; 16]),
-        ],
-        |name, s| {
-            if name == "ppt/slides/slide1.xml" {
-                s.replacen("</p:spTree>", &format!("{frame}</p:spTree>"), 1)
-            } else if name == "ppt/slides/_rels/slide1.xml.rels" {
-                s.replacen(
-                    "</Relationships>",
-                    r#"<Relationship Id="rIdVml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing" Target="../drawings/vmlDrawing1.vml"/><Relationship Id="rIdOle" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject" Target="../embeddings/oleObject1.bin"/></Relationships>"#,
-                    1,
-                )
-            } else {
-                s
-            }
-        },
-    )
-}
-
-fn object_preview(bytes: &[u8]) -> Option<Vec<u8>> {
-    let p = deckcraft_pptx::import(bytes).expect("import");
-    let s = p.slides[0].shapes.iter().find(|s| s.name == "Object 3").expect("object");
-    match &s.kind {
-        ShapeKind::Opaque { preview, label, .. } => {
-            assert_eq!(label, "PowerPoint.Slide.8");
-            preview.and_then(|m| p.media(m)).map(|m| m.data.to_vec())
-        }
-        k => panic!("{k:?}"),
-    }
-}
-
-#[test]
-fn an_old_ole_object_shows_its_vml_preview() {
-    assert_eq!(object_preview(&ole_deck("_x0000_s681987")), Some(png()), "the VML shape with the object's spid");
-}
-
-#[test]
-fn an_ole_object_without_a_matching_vml_shape_has_no_preview() {
-    assert_eq!(object_preview(&ole_deck("_x0000_s1")), None);
-}

crates/pptx/tests/ole_vml.rs

@@ -1,84 +0,0 @@
-//! Legacy OLE objects whose preview picture lives in the slide's VML drawing, and ActiveX controls
-//! shown by their pictures.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_model::ShapeKind;
-use deckcraft_model::defaults;
-
-const FRAME: &str = r#"<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="90" name="Object 3"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/></p:xfrm><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/presentationml/2006/ole"><p:oleObj spid="_x0000_s2050" name="Slide" r:id="rIdOle" progId="Thing.1"><p:embed/></p:oleObj></a:graphicData></a:graphic></p:graphicFrame>"#;
-
-const VML: &str = r#"<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office"><v:shape id="_x0000_s2049"><v:imagedata o:relid="rIdA"/></v:shape><v:shape id="_x0000_s2050" style='position:absolute;left:0;top:0;width:1in;height:1in'><v:imagedata o:relid="rIdB" o:title=""/></v:shape></xml>"#;
-
-const VML_RELS: &str = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rIdA" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/other.png"/><Relationship Id="rIdB" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/preview.png"/></Relationships>"#;
-
-const SLIDE_RELS: &str = r#"<Relationship Id="rIdVml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing" Target="../drawings/vmlDrawing1.vml"/><Relationship Id="rIdPic" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/preview.png"/>"#;
-
-/// An ActiveX control as PowerPoint writes it: a VML-only choice, and a fallback with its picture.
-const CONTROLS: &str = r#"<p:controls><mc:AlternateContent xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"><mc:Choice xmlns:v="urn:schemas-microsoft-com:vml" Requires="v"><p:control spid="1137" name="CheckBox1" r:id="rIdX" imgW="1933560" imgH="514440"/></mc:Choice><mc:Fallback><p:control name="CheckBox1" r:id="rIdX" imgW="1933560" imgH="514440"><p:pic><p:nvPicPr><p:cNvPr id="4" name="CheckBox1"/><p:cNvPicPr/><p:nvPr/></p:nvPicPr><p:blipFill><a:blip r:embed="rIdPic"/><a:stretch><a:fillRect/></a:stretch></p:blipFill><p:spPr><a:xfrm><a:off x="12700" y="25400"/><a:ext cx="127000" cy="63500"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr></p:pic></p:control></mc:Fallback></mc:AlternateContent><p:control name="NoPicture" r:id="rIdY"/></p:controls>"#;
-
-fn png(v: u8) -> Vec<u8> {
-    let mut out = Cursor::new(vec![]);
-    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(2, 2, image::Rgb([v, v, v])))
-        .write_to(&mut out, image::ImageFormat::Png)
-        .expect("png");
-    out.into_inner()
-}
-
-/// A new deck whose first slide holds [`FRAME`], with the VML drawing, its rels and two pictures.
-fn deck() -> Vec<u8> {
-    let bytes = deckcraft_pptx::export(&defaults::new_presentation(None)).expect("export");
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        let name = f.name().to_string();
-        if name == "ppt/slides/slide1.xml" {
-            let s = String::from_utf8(d).expect("utf8");
-            let at = s.rfind("</p:spTree>").expect("spTree");
-            let s = format!("{}{FRAME}{}", &s[..at], &s[at..]);
-            let at = s.rfind("</p:cSld>").expect("cSld");
-            d = format!("{}{CONTROLS}{}", &s[..at], &s[at..]).into_bytes();
-        } else if name == "ppt/slides/_rels/slide1.xml.rels" {
-            let s = String::from_utf8(d).expect("utf8");
-            d = s.replace("</Relationships>", &format!("{SLIDE_RELS}</Relationships>")).into_bytes();
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    for (name, data) in [
-        ("ppt/drawings/vmlDrawing1.vml", VML.as_bytes().to_vec()),
-        ("ppt/drawings/_rels/vmlDrawing1.vml.rels", VML_RELS.as_bytes().to_vec()),
-        ("ppt/media/other.png", png(10)),
-        ("ppt/media/preview.png", png(200)),
-    ] {
-        out.start_file(name, o).expect("start");
-        out.write_all(&data).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-#[test]
-fn an_ole_object_without_a_picture_shows_its_vml_preview() {
-    let p = deckcraft_pptx::import(&deck()).expect("import");
-    let s = p.slides[0].shapes.iter().find(|s| s.name == "Object 3").expect("frame");
-    let ShapeKind::Opaque { preview: Some(m), label, .. } = &s.kind else { panic!("{:?}", s.kind) };
-    assert_eq!(label, "Thing.1");
-    let media = p.media.iter().find(|x| x.id == *m).expect("media");
-    // The shape whose id is the object's spid, not the first one in the drawing.
-    assert_eq!(media.name, "preview.png");
-}
-
-#[test]
-fn activex_controls_show_their_pictures() {
-    let p = deckcraft_pptx::import(&deck()).expect("import");
-    let s = p.slides[0].shapes.iter().find(|s| s.name == "CheckBox1").expect("control picture");
-    let ShapeKind::Picture { fill } = &s.kind else { panic!("{:?}", s.kind) };
-    assert_eq!(p.media.iter().find(|m| m.id == fill.media).map(|m| m.name.as_str()), Some("preview.png"));
-    let x = s.xfrm.expect("xfrm");
-    assert_eq!((x.x, x.y, x.w, x.h), (1.0, 2.0, 10.0, 5.0));
-    assert!(!p.slides[0].shapes.iter().any(|s| s.name == "NoPicture"), "a control without a picture draws nothing");
-}

crates/pptx/tests/placeholders.rs

@@ -1,64 +0,0 @@
-//! Placeholder inheritance in decks written by PowerPoint.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_model::{Geom, defaults};
-
-/// `bytes` with `edit` applied to every slide part.
-fn edit_slides(bytes: &[u8], edit: impl Fn(String) -> String) -> Vec<u8> {
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        let name = f.name().to_string();
-        if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
-            d = edit(String::from_utf8(d).expect("utf8")).into_bytes();
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-#[test]
-fn a_placeholder_without_geometry_takes_its_layouts() {
-    // PowerPoint leaves a slide placeholder's spPr empty and draws it with the layout
-    // placeholder's geometry (a picture placeholder cut into a shape keeps the shape).
-    let mut p = defaults::new_presentation(None);
-    let layout = p.slides[0].layout;
-    let m = std::sync::Arc::make_mut(&mut p.masters[0]);
-    let l = m.layouts.iter_mut().find(|l| l.id == layout).expect("layout");
-    for s in &mut l.shapes {
-        if s.ph.is_some() {
-            s.geom = Geom::Preset { name: "ellipse".into(), adj: vec![] };
-        }
-    }
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    // Strip the slide's own geometry, as PowerPoint writes inheriting placeholders.
-    let bare = edit_slides(&bytes, |s| {
-        let mut s = s;
-        while let Some(i) = s.find("<a:prstGeom") {
-            let Some(j) = s[i..].find("</a:prstGeom>").map(|j| j + i + "</a:prstGeom>".len()) else { break };
-            s.replace_range(i..j, "");
-        }
-        s
-    });
-    let q = deckcraft_pptx::import(&bare).expect("import");
-    let phs: Vec<_> = q.slides[0].shapes.iter().filter(|s| s.ph.is_some()).collect();
-    assert!(!phs.is_empty());
-    for s in phs {
-        assert!(matches!(&s.geom, Geom::Preset { name, .. } if name == "ellipse"), "{:?}", s.geom);
-    }
-    // A placeholder with its own geometry keeps it.
-    let first = p.slides[0].id;
-    for s in &mut p.slide_mut(first).expect("slide").shapes {
-        if s.ph.is_some() {
-            s.geom = Geom::Preset { name: "triangle".into(), adj: vec![] };
-        }
-    }
-    let q = deckcraft_pptx::import(&deckcraft_pptx::export(&p).expect("export")).expect("import");
-    assert!(q.slides[0].shapes.iter().filter(|s| s.ph.is_some()).all(|s| matches!(&s.geom, Geom::Preset { name, .. } if name == "triangle")));
-}

crates/pptx/tests/roundtrip.rs

@@ -105,7 +105,6 @@ pub fn rich_deck() -> Presentation {
     let mut a = shape(&mut p, "Gradient Star", 100.0, 120.0, 150.0, 150.0);
     a.geom = Geom::Preset { name: "star5".into(), adj: vec![20000.0] };
     a.fill = Some(Fill::Gradient(Gradient {
-        tile: [0.0; 4],
         stops: vec![
             GradientStop { pos: 0.0, color: ColorRef::scheme(SchemeSlot::Accent1) },
             GradientStop { pos: 1.0, color: ColorRef::scheme(SchemeSlot::Accent2).with(ColorTransform::LumMod(75000)) },
@@ -231,7 +230,6 @@ pub fn rich_deck() -> Presentation {
             mode: PictureMode::Stretch { fill_rect: [0.0; 4] },
             alpha: Some(0.5),
             adjust: PictureAdjust { brightness: 0.2, contrast: -0.1, grayscale: true, ..Default::default() },
-            upright: false,
         },
     };
     let mut tiled = shape(&mut p, "Tiled", 350.0, 120.0, 200.0, 150.0);
@@ -732,262 +730,3 @@ fn date_fields_keep_their_type_and_saved_text() {
         assert_eq!(by_name(&q.slides[0], name).text, by_name(&p.slides[0], name).text, "{name}");
     }
 }
-
-#[test]
-fn colour_map_overrides_round_trip() {
-    let mut p = defaults::new_presentation(None);
-    let dark: Vec<(String, String)> =
-        [("bg1", "dk1"), ("tx1", "lt1"), ("bg2", "dk2"), ("tx2", "lt2")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect();
-    let layout = p.slides[0].layout;
-    std::sync::Arc::make_mut(&mut p.masters[0]).layouts.iter_mut().find(|l| l.id == layout).expect("layout").color_map = Some(dark.clone());
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").color_map = Some(dark.clone());
-    let q = round(&p);
-    let get = |m: &Option<Vec<(String, String)>>, k: &str| m.as_ref().and_then(|m| m.iter().find(|(a, _)| a == k).map(|(_, v)| v.clone()));
-    let ql = q.masters[0].layouts.iter().find(|l| l.color_map.is_some()).expect("the layout keeps its override");
-    assert_eq!(get(&ql.color_map, "bg1").as_deref(), Some("dk1"));
-    assert_eq!(get(&q.slides[0].color_map, "tx1").as_deref(), Some("lt1"));
-    // Layouts and slides without one keep following the master.
-    assert!(q.masters[0].layouts.iter().filter(|l| l.color_map.is_none()).count() >= 1);
-}
-
-#[test]
-fn a_picture_duotone_round_trips() {
-    let mut p = defaults::new_presentation(None);
-    let img = p.add_media("image1.png", "image/png", png(4, 4, [128, 128, 128]));
-    let mut pic = shape(&mut p, "Duotone", 10.0, 10.0, 100.0, 100.0);
-    let mut pf = PictureFill { media: img, ..Default::default() };
-    pf.adjust.duotone = Some((ColorRef::scheme(SchemeSlot::Accent1).with(ColorTransform::Shade(30000)), ColorRef::rgb(Rgba::rgb(250, 240, 200))));
-    pic.kind = deckcraft_model::ShapeKind::Picture { fill: pf };
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(pic);
-    let q = round(&p);
-    let sh = by_name(&q.slides[0], "Duotone");
-    let deckcraft_model::ShapeKind::Picture { fill } = &sh.kind else { panic!("picture") };
-    let (d, l) = fill.adjust.duotone.as_ref().expect("duotone kept");
-    assert!(matches!(d.base, deckcraft_model::ColorBase::Scheme { slot: SchemeSlot::Accent1 }));
-    assert!(matches!(l.base, deckcraft_model::ColorBase::Rgb { rgb } if rgb == Rgba::rgb(250, 240, 200)));
-}
-
-#[test]
-fn line_break_options_round_trip() {
-    let mut p = defaults::new_presentation(None);
-    let first = p.slides[0].id;
-    let s = p.slide_mut(first).expect("slide");
-    let t = s.shapes[0].text.insert(TextBody::from_text("x"));
-    t.paragraphs[0].props.latin_line_break = Some(true);
-    t.paragraphs[0].props.hanging_punct = Some(false);
-    let q = round(&p);
-    let props = &q.slides[0].shapes[0].text.as_ref().expect("text").paragraphs[0].props;
-    assert_eq!(props.latin_line_break, Some(true));
-    assert_eq!(props.hanging_punct, Some(false));
-}
-
-#[test]
-fn a_table_fill_round_trips() {
-    let mut p = defaults::new_presentation(None);
-    let mut t = Table::new(2, 2, 200.0, 40.0);
-    t.background = Some(Fill::solid(ColorRef::rgb(Rgba::rgb(0, 112, 192))));
-    let mut sh = shape(&mut p, "Filled table", 10.0, 10.0, 200.0, 80.0);
-    sh.kind = deckcraft_model::ShapeKind::Table(t);
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(sh);
-    let q = round(&p);
-    let deckcraft_model::ShapeKind::Table(t) = &by_name(&q.slides[0], "Filled table").kind else { panic!("table") };
-    assert!(
-        matches!(&t.background, Some(Fill::Solid { color }) if matches!(color.base, deckcraft_model::ColorBase::Rgb { rgb } if rgb == Rgba::rgb(0, 112, 192)))
-    );
-}
-
-#[test]
-fn wordart_warps_and_their_adjusts_round_trip() {
-    let mut p = Presentation::default();
-    let cases: [(&str, &str, Vec<f64>); 5] = [
-        ("Arch pour", "textArchUpPour", vec![13_500_000.0, 30_000.0]),
-        ("Wave", "textWave1", vec![18_000.0, -5_000.0]),
-        ("Inflate", "textInflate", vec![30_000.0]),
-        ("Arch", "textArchUp", vec![]),
-        ("Ring", "textRingInside", vec![75_000.0]),
-    ];
-    let mut shapes = vec![];
-    for (i, (name, warp, adj)) in cases.iter().enumerate() {
-        let mut s = shape(&mut p, name, 10.0, 10.0 + 50.0 * i as f64, 300.0, 40.0);
-        let mut body = TextBody::from_text("WordArt");
-        body.body.warp = Some((*warp).into());
-        body.body.warp_adj = adj.clone();
-        s.text = Some(body);
-        shapes.push(s);
-    }
-    Arc::make_mut(&mut p.slides[0]).shapes = shapes;
-    let q = round(&p);
-    for (name, warp, adj) in &cases {
-        let b = &by_name(&q.slides[0], name).text.as_ref().expect("text").body;
-        assert_eq!(b.warp.as_deref(), Some(*warp), "{name}");
-        assert_eq!(&b.warp_adj, adj, "{name}");
-    }
-    // The single-adjust preset is written with the guide name `adj`, two-adjust ones with
-    // `adj1`/`adj2`, and a preset with no adjusts given gets an empty list.
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
-    let mut xml = String::new();
-    std::io::Read::read_to_string(&mut zip.by_name("ppt/slides/slide1.xml").expect("slide"), &mut xml).expect("read");
-    assert!(xml.contains(r#"<a:prstTxWarp prst="textInflate"><a:avLst><a:gd name="adj" fmla="val 30000"/></a:avLst></a:prstTxWarp>"#), "{xml}");
-    assert!(xml.contains(r#"<a:gd name="adj1" fmla="val 13500000"/><a:gd name="adj2" fmla="val 30000"/>"#));
-    assert!(xml.contains(r#"<a:prstTxWarp prst="textArchUp"><a:avLst/></a:prstTxWarp>"#));
-    // A file that gives only `adj2` keeps the preset's default for `adj1`; hostile values are
-    // read as numbers or dropped.
-    let edited = xml
-        .replace(r#"<a:gd name="adj1" fmla="val 13500000"/>"#, "")
-        .replace(r#"<a:gd name="adj" fmla="val 30000"/>"#, r#"<a:gd name="adj" fmla="val NaN"/>"#);
-    let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
-    for i in 0..zip.len() {
-        let mut f = zip.by_index(i).expect("entry");
-        let name = f.name().to_string();
-        let mut data = vec![];
-        std::io::Read::read_to_end(&mut f, &mut data).expect("read");
-        if name == "ppt/slides/slide1.xml" {
-            data = edited.clone().into_bytes();
-        }
-        out.start_file(name, zip::write::SimpleFileOptions::default()).expect("start");
-        std::io::Write::write_all(&mut out, &data).expect("write");
-    }
-    let bytes = out.finish().expect("finish").into_inner();
-    let q = deckcraft_pptx::import(&bytes).expect("import");
-    let pour = &by_name(&q.slides[0], "Arch pour").text.as_ref().expect("text").body;
-    assert_eq!(pour.warp_adj, vec![10_800_000.0, 30_000.0]);
-    let inflate = &by_name(&q.slides[0], "Inflate").text.as_ref().expect("text").body;
-    assert_eq!(inflate.warp.as_deref(), Some("textInflate"));
-    assert!(inflate.warp_adj.is_empty());
-}
-
-/// Slide XML of a deck exported with one slide per transition (kind, option, ms, advance after).
-fn transition_deck(list: &[(&str, &str, u32, Option<u32>)]) -> (Presentation, Vec<String>) {
-    let mut p = defaults::new_presentation(None);
-    let base = p.slides[0].as_ref().clone();
-    p.slides.clear();
-    for (kind, option, ms, adv) in list {
-        let mut s = base.clone();
-        s.id = SlideId(p.alloc_id());
-        s.transition = Some(Transition {
-            kind: kind.to_string(),
-            option: option.to_string(),
-            duration_ms: *ms,
-            advance_on_click: adv.is_none(),
-            advance_after_ms: *adv,
-            ..Default::default()
-        });
-        p.slides.push(Arc::new(s));
-    }
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
-    let xml = (1..=list.len())
-        .map(|i| {
-            let mut x = String::new();
-            std::io::Read::read_to_string(&mut zip.by_name(&format!("ppt/slides/slide{i}.xml")).expect("slide"), &mut x).expect("read");
-            x
-        })
-        .collect();
-    (p, xml)
-}
-
-#[test]
-fn transition_xml_matches_powerpoints_elements() {
-    // The elements, attributes and namespaces PowerPoint itself writes for these effect options
-    // (observed on files it saved), inside `mc:AlternateContent` with a `p:fade` fallback for
-    // the 2010+ effects.
-    let cases: &[(&str, &str, &[&str], &str)] = &[
-        ("wipe", "ru", &[r#"<p:strips dir="ru"/>"#], "p14"),
-        ("wipe", "u", &[r#"<p:wipe dir="u"/>"#], "p14"),
-        ("zoom", "in", &[r#"<p14:warp dir="in"/>"#], "p14"),
-        ("zoom", "rotate", &["<p:newsflash/>"], "p14"),
-        ("shape", "out", &[r#"<p:zoom dir="out"/>"#], "p14"),
-        ("glitter", "hexD", &[r#"<p14:glitter dir="d" pattern="hexagon"/>"#], "p14"),
-        ("shred", "particlesOut", &[r#"<p14:shred pattern="rectangle" dir="out"/>"#], "p14"),
-        ("wind", "l", &[r#"<p15:prstTrans prst="wind" invX="1"/>"#], "p15"),
-        ("wind", "r", &[r#"<p15:prstTrans prst="wind"/>"#], "p15"),
-        ("fallOver", "r", &[r#"<p15:prstTrans prst="fallOver" invX="1"/>"#], "p15"),
-        ("pageCurlDouble", "singleR", &[r#"<p15:prstTrans prst="pageCurlSingle" invX="1"/>"#], "p15"),
-        ("orbit", "u", &[r#"<p14:prism dir="u" isContent="1" isInverted="1"/>"#], "p14"),
-        ("vortex", "r", &[r#"<p14:vortex dir="r"/>"#], "p14"),
-        ("morph", "words", &[r#"<p159:morph option="byWord"/>"#], "p159"),
-    ];
-    let list: Vec<(&str, &str, u32, Option<u32>)> = cases.iter().map(|c| (c.0, c.1, 2000, Some(1000))).collect();
-    let (p, xml) = transition_deck(&list);
-    for ((kind, option, wants, req), x) in cases.iter().zip(&xml) {
-        for w in *wants {
-            assert!(x.contains(w), "{kind}/{option}: {w} in {x}");
-        }
-        assert!(x.contains(&format!(r#"Requires="{req}""#)), "{kind}/{option}");
-        assert!(x.contains(r#"p14:dur="2000""#) && x.contains(r#"advTm="1000""#) && x.contains(r#"advClick="0""#), "{kind}/{option}");
-        assert!(x.contains("<mc:Fallback>"), "{kind}/{option}");
-    }
-    // Back in, everything is as it was.
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    let q = deckcraft_pptx::import(&bytes).expect("import");
-    for ((kind, option, ..), s) in cases.iter().zip(&q.slides) {
-        let t = s.transition.as_ref().expect("transition");
-        assert_eq!(
-            (t.kind.as_str(), t.option.as_str(), t.duration_ms, t.advance_after_ms, t.advance_on_click),
-            (*kind, *option, 2000, Some(1000), false)
-        );
-    }
-}
-
-#[test]
-fn transition_defaults_read_like_powerpoint() {
-    // PowerPoint leaves out an option when it is the element's default; these are its defaults.
-    let cases: &[(&str, &str, &str)] = &[
-        ("<p:push/>", "push", "l"),
-        ("<p:wipe/>", "wipe", "l"),
-        ("<p:strips/>", "wipe", "lu"),
-        ("<p:randomBar/>", "randomBar", "horz"),
-        ("<p:checker/>", "checker", "horz"),
-        ("<p:blinds/>", "blinds", "horz"),
-        ("<p:comb/>", "comb", "horz"),
-        ("<p:zoom/>", "shape", "out"),
-        (r#"<p:zoom dir="in"/>"#, "shape", "in"),
-        ("<p:split/>", "split", "horzOut"),
-        ("<p14:doors/>", "doors", "horz"),
-        ("<p14:window/>", "window", "horz"),
-        ("<p14:pan/>", "pan", "l"),
-        ("<p14:warp/>", "zoom", "out"),
-        ("<p14:glitter/>", "glitter", "l"),
-        ("<p14:shred/>", "shred", "stripsIn"),
-        ("<p14:reveal/>", "reveal", "smoothlyLeft"),
-        ("<p14:prism/>", "cube", "l"),
-        (r#"<p15:prstTrans prst="airplane"/>"#, "airplane", "r"),
-        (r#"<p15:prstTrans prst="peelOff"/>"#, "peelOff", "l"),
-        (r#"<p15:prstTrans prst="pageCurlSingle"/>"#, "pageCurlDouble", "singleL"),
-    ];
-    let (_, xml) = transition_deck(&[("fade", "smoothly", 2000, None)]);
-    let Some(x) = xml.first() else { panic!("no slide") };
-    let start = x.find("<mc:AlternateContent").expect("transition");
-    let end = x.find("</mc:AlternateContent>").expect("transition end") + "</mc:AlternateContent>".len();
-    let p14 = r#"xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main""#;
-    let p15 = r#"xmlns:p15="http://schemas.microsoft.com/office/powerpoint/2012/main""#;
-    for (el, kind, option) in cases {
-        let tr = format!(r#"<p:transition {p14} {p15} spd="slow" p14:dur="2000">{el}</p:transition>"#);
-        let edited = format!("{}{}{}", &x[..start], tr, &x[end..]);
-        let mut p = defaults::new_presentation(None);
-        let base = p.slides[0].as_ref().clone();
-        p.slides = vec![Arc::new(base)];
-        let bytes = deckcraft_pptx::export(&p).expect("export");
-        let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
-        let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
-        for i in 0..zip.len() {
-            let mut f = zip.by_index(i).expect("entry");
-            let name = f.name().to_string();
-            let mut data = vec![];
-            std::io::Read::read_to_end(&mut f, &mut data).expect("read");
-            if name == "ppt/slides/slide1.xml" {
-                data = edited.clone().into_bytes();
-            }
-            out.start_file(name, zip::write::SimpleFileOptions::default()).expect("start");
-            std::io::Write::write_all(&mut out, &data).expect("write");
-        }
-        let bytes = out.finish().expect("finish").into_inner();
-        let q = deckcraft_pptx::import(&bytes).expect("import");
-        let t = q.slides[0].transition.as_ref().expect("transition");
-        assert_eq!((t.kind.as_str(), t.option.as_str(), t.duration_ms), (*kind, *option, 2000), "{el}");
-    }
-}

crates/pptx/tests/table_styles.rs

@@ -1,84 +0,0 @@
-//! Fills and styles read from decks written by other tools.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_geom::Xfrm;
-use deckcraft_model::style::Fill;
-use deckcraft_model::{Shape, ShapeId, defaults};
-
-const STYLE_GUID: &str = "{ABCDEF01-2345-4678-9ABC-DEF012345678}";
-
-/// A table style definition as PowerPoint writes one: red table background, see-through white
-/// bands, 2 pt blue outer borders and no inside lines.
-fn style_xml() -> String {
-    format!(
-        r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<a:tblStyleLst xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" def="{STYLE_GUID}"><a:tblStyle styleId="{STYLE_GUID}" styleName="Probe Style"><a:tblBg><a:fillRef idx="1"><a:srgbClr val="FF0000"/></a:fillRef></a:tblBg><a:wholeTbl><a:tcTxStyle b="on"><a:srgbClr val="00FF00"/></a:tcTxStyle><a:tcStyle><a:tcBdr><a:left><a:ln w="25400"><a:solidFill><a:srgbClr val="0000FF"/></a:solidFill></a:ln></a:left><a:insideH><a:ln><a:noFill/></a:ln></a:insideH></a:tcBdr><a:fill><a:noFill/></a:fill></a:tcStyle></a:wholeTbl><a:band1H><a:tcStyle><a:tcBdr/><a:fill><a:solidFill><a:srgbClr val="FFFFFF"><a:alpha val="20000"/></a:srgbClr></a:solidFill></a:fill></a:tcStyle></a:band1H></a:tblStyle></a:tblStyleLst>"#
-    )
-}
-
-/// An exported deck with a 3x2 table using the probe style.
-fn table_deck() -> Vec<u8> {
-    let mut p = defaults::new_presentation(None);
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    let mut t = deckcraft_model::Table::new(3, 2, 300.0, 30.0);
-    t.style = "medium2-accent1".into();
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Styled".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 300.0, 90.0)),
-        kind: deckcraft_model::ShapeKind::Table(t),
-        ..Default::default()
-    });
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    // Point the table at the probe style and replace the style part.
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        let name = f.name().to_string();
-        if name == "ppt/tableStyles.xml" {
-            d = style_xml().into_bytes();
-        } else if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
-            let s = String::from_utf8(d).expect("utf8");
-            let start = s.find("<a:tableStyleId>").map(|i| i + "<a:tableStyleId>".len());
-            let end = s.find("</a:tableStyleId>");
-            d = match (start, end) {
-                (Some(a), Some(b)) => format!("{}{}{}", &s[..a], STYLE_GUID, &s[b..]).into_bytes(),
-                _ => s.into_bytes(),
-            };
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-#[test]
-fn table_styles_the_file_defines_are_read_used_and_kept() {
-    use deckcraft_model::table::{TableBorder, TablePart};
-    let p = deckcraft_pptx::import(&table_deck()).expect("import");
-    let def = p.table_styles.iter().find(|d| d.id == STYLE_GUID).expect("the probe style is read");
-    assert_eq!(def.name, "Probe Style");
-    let bg = def.background.as_ref().expect("table background");
-    assert!(matches!(bg.fill_ref, Some((1, _))));
-    let whole = def.part(TablePart::WholeTbl).expect("whole table");
-    assert_eq!(whole.bold, Some(true));
-    assert!(whole.text_color.is_some());
-    assert!(matches!(&whole.borders[0], Some(TableBorder::Line { line }) if line.width == Some(2.0)));
-    assert!(matches!(&whole.borders[4], Some(TableBorder::Line { line }) if matches!(line.fill, Some(Fill::None))));
-    assert!(matches!(def.part(TablePart::Band1H).and_then(|b| b.fill.clone()), Some(Fill::Solid { .. })));
-    // The table keeps the style's GUID, so it's drawn from the definition.
-    let s = p.slides[0].shapes.iter().find(|s| s.name == "Styled").expect("table");
-    let deckcraft_model::ShapeKind::Table(t) = &s.kind else { panic!("table") };
-    assert_eq!(t.style, STYLE_GUID);
-    // Saving writes the definition back, unchanged.
-    let again = deckcraft_pptx::export(&p).expect("export");
-    let q = deckcraft_pptx::import(&again).expect("reimport");
-    let def2 = q.table_styles.iter().find(|d| d.id == STYLE_GUID).expect("kept on save");
-    assert_eq!(def2.parts, def.parts);
-}

crates/render/Cargo.toml

@@ -11,9 +11,7 @@ workspace = true
 [dependencies]
 deckcraft-geom = { workspace = true }
 deckcraft-color = { workspace = true }
-deckcraft-metafile = { workspace = true }
 deckcraft-model = { workspace = true }
-deckcraft-anim = { workspace = true }
 deckcraft-fonts = { workspace = true }
 deckcraft-text = { workspace = true }
 vello_cpu = { workspace = true }
@@ -21,7 +19,6 @@ vello_common = { workspace = true }
 image = { workspace = true }
 log = { workspace = true }
 kurbo = { workspace = true }
-skrifa = { workspace = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 vello_cpu = { workspace = true, features = ["multithreading"] }

crates/render/src/bevel.rs

@@ -1,234 +0,0 @@
-//! 3-D bevels (`a:sp3d/a:bevelT` seen through a `a:scene3d`), approximated in 2-D: the shape's
-//! face and a band inside its outline as wide as the bevel are lit as surfaces, the band's normal
-//! tilting out towards the outline by the bevel profile's slope.
-//!
-//! Fitted to PowerPoint's export of bevel presets on a solid-filled shape with the default
-//! three-point light rig and matte material: each channel comes out as
-//! `c · (0.453 + 0.731 · max(0, n · L)) + 14.7` for a light from the upper left (azimuth 240°,
-//! 45° up), within about 15 grey levels RMS across the band (exact profiles, specular highlights
-//! and the other rigs, materials and cameras are not modelled).
-
-use std::sync::Arc;
-
-use deckcraft_color::Rgba;
-use kurbo::{Affine, BezPath, Point, Rect};
-use vello_cpu::{Pixmap, RenderContext, peniko};
-
-/// Longest side of the rasterised lighting, in pixels.
-const MAX_SIDE: f64 = 512.0;
-const AMBIENT: f64 = 0.453;
-const DIFFUSE: f64 = 0.731;
-const SPECULAR: f64 = 14.7;
-
-/// A top bevel: its width and height in points and its preset.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Bevel {
-    pub w: f64,
-    pub h: f64,
-    pub preset: String,
-    /// Lit as measured (the three-point rig and matte material); other rigs and materials are not
-    /// drawn.
-    pub modelled: bool,
-}
-
-/// The top bevel of 3-D XML kept from the file (`scene3d` + `sp3d`), when it has both a scene
-/// (without one PowerPoint draws the shape flat) and a `bevelT`.
-pub fn from_raw(raw: &str) -> Option<Bevel> {
-    if !raw.contains("scene3d") || !raw.contains("sp3d") {
-        return None;
-    }
-    // A 3-D shape without a bevel still has its face lit: a bevel of no width.
-    let Some(i) = raw.find("bevelT") else {
-        let b = Bevel { w: 0.0, h: 0.0, preset: "circle".into(), modelled: false };
-        return Some(Bevel { modelled: modelled(raw), ..b });
-    };
-    let tag = raw.get(i..)?;
-    let tag = tag.get(..tag.find('>')?)?;
-    let attr = |name: &str| -> Option<&str> {
-        let key = format!(" {name}=\"");
-        let s = tag.find(&key)? + key.len();
-        let rest = tag.get(s..)?;
-        rest.get(..rest.find('"')?)
-    };
-    let emu = |name: &str| attr(name).and_then(|v| v.parse::<f64>().ok()).map(|v| v / 12700.0);
-    let w = emu("w").unwrap_or(6.0).clamp(0.0, 2000.0);
-    let h = emu("h").unwrap_or(6.0).clamp(0.0, 2000.0);
-    (w > 0.0).then(|| Bevel { w, h, preset: attr("prst").unwrap_or("circle").to_string(), modelled: modelled(raw) })
-}
-
-/// Whether the light rig and material (from anywhere in the XML: `a:lightRig rig=`,
-/// `prstMaterial=`) are the ones measured: the three-point rig, matte.
-fn modelled(raw: &str) -> bool {
-    let value_after = |key: &str| -> Option<&str> {
-        let s = raw.find(key)? + key.len();
-        let rest = raw.get(s..)?;
-        rest.get(..rest.find('"')?)
-    };
-    let rig = value_after("rig=\"").unwrap_or("threePt");
-    let material = value_after("prstMaterial=\"").unwrap_or("warmMatte");
-    rig == "threePt" && matches!(material, "warmMatte" | "matte")
-}
-
-/// The light, pointing from the surface towards it (x right, y down, z towards the viewer).
-fn light() -> [f64; 3] {
-    let (az, el) = (240f64.to_radians(), 45f64.to_radians());
-    [el.cos() * az.cos(), el.cos() * az.sin(), el.sin()]
-}
-
-/// The bevel surface's rise per unit inwards (in units of h / w) at `u` (0 at the outline, 1 at
-/// the inner edge of the band), by preset.
-fn slope(preset: &str, u: f64) -> f64 {
-    let u = u.clamp(1e-3, 1.0);
-    match preset {
-        "angle" => 1.0,
-        // A quarter circle, steep at the outline and flat where it meets the face; the default,
-        // and used for the presets not modelled.
-        _ => {
-            let v = 1.0 - u;
-            v / (1.0 - v * v).max(1e-6).sqrt()
-        }
-    }
-}
-
-/// Lighting factor and outward edge normal at each position, for a polygon set: distance to the
-/// nearest edge and that edge's outward normal (edges oriented by each polygon's signed area).
-fn nearest_edge(polys: &[Vec<Point>], areas: &[f64], p: Point) -> Option<(f64, kurbo::Vec2)> {
-    let mut best: Option<(f64, kurbo::Vec2)> = None;
-    for (poly, area) in polys.iter().zip(areas) {
-        for w in poly.windows(2) {
-            let (a, b) = (w[0], w[1]);
-            let e = b - a;
-            let l2 = e.hypot2();
-            if l2 < 1e-12 {
-                continue;
-            }
-            let t = ((p - a).dot(e) / l2).clamp(0.0, 1.0);
-            let d = (p - (a + e * t)).hypot();
-            if best.is_none_or(|(bd, _)| d < bd) {
-                // Outward normal: for a polygon of positive (clockwise on screen, y down) area the
-                // outside is to the left of each edge's direction.
-                let n = kurbo::Vec2::new(e.y, -e.x) / l2.sqrt();
-                let n = if *area > 0.0 { n } else { -n };
-                best = Some((d, n));
-            }
-        }
-    }
-    best
-}
-
-/// Draw the lit face and bevel band over a shape filled with `fill` (a solid colour, or `None`
-/// for any other fill, which gets the band's highlights and shading as light and dark veils)
-/// inside `path` (shape space, laid out in `bounds`), `m` mapping it to the output.
-#[allow(clippy::too_many_arguments)]
-pub fn draw(ctx: &mut RenderContext, bevel: &Bevel, fill: Option<Rgba>, path: &BezPath, bounds: Rect, m: Affine, alpha: f64) {
-    // Other light rigs and materials light the face and band differently (brighter, darker,
-    // shinier); rather than guess, they stay flat as before.
-    if !bevel.modelled || bounds.width() <= 0.0 || bounds.height() <= 0.0 || !bounds.is_finite() {
-        return;
-    }
-    // No bevel: only the face, one lit colour (as PowerPoint lights a 3-D shape's front face,
-    // whichever way the camera turns it, within about 10 levels).
-    if bevel.w <= 0.0 {
-        if let Some(c) = fill {
-            let f = AMBIENT + DIFFUSE * light()[2];
-            let ch = |v: u8| (v as f64 * f + SPECULAR).round().clamp(0.0, 255.0) as u8;
-            ctx.set_transform(m);
-            ctx.set_paint(crate::color(Rgba::rgba(ch(c.r), ch(c.g), ch(c.b), c.a), alpha));
-            ctx.fill_path(path);
-        }
-        return;
-    }
-    let k = crate::scale_of(m);
-    let k = if k.is_finite() && k > 0.0 { k } else { 1.0 };
-    let longest = bounds.width().max(bounds.height()) * k;
-    let s = (MAX_SIDE / longest).min(1.0) * k;
-    let (pw, ph) = (((bounds.width() * s).ceil() as u32).clamp(1, 2048), ((bounds.height() * s).ceil() as u32).clamp(1, 2048));
-    let polys = crate::pathgrad::polygons(path);
-    if polys.is_empty() {
-        return;
-    }
-    let areas: Vec<f64> = polys.iter().map(|p| p.windows(2).map(|w| w[0].x * w[1].y - w[1].x * w[0].y).sum::<f64>() / 2.0).collect();
-    let l = light();
-    let face = AMBIENT + DIFFUSE * l[2];
-    let ratio = if bevel.w > 0.0 { bevel.h / bevel.w } else { 0.0 };
-    let a = alpha.clamp(0.0, 1.0);
-    let mut data = Vec::with_capacity((pw * ph) as usize);
-    for j in 0..ph {
-        for i in 0..pw {
-            let p = Point::new(bounds.x0 + (i as f64 + 0.5) / pw as f64 * bounds.width(), bounds.y0 + (j as f64 + 0.5) / ph as f64 * bounds.height());
-            let f = match nearest_edge(&polys, &areas, p) {
-                Some((d, e)) if d < bevel.w => {
-                    let z = slope(&bevel.preset, d / bevel.w) * ratio;
-                    let n = [e.x * z, e.y * z, 1.0];
-                    let len = (n[0] * n[0] + n[1] * n[1] + n[2] * n[2]).sqrt();
-                    let dot = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]) / len;
-                    AMBIENT + DIFFUSE * dot.max(0.0)
-                }
-                _ => face,
-            };
-            let px = match fill {
-                Some(c) => {
-                    let ch = |v: u8| (v as f64 * f + SPECULAR).round().clamp(0.0, 255.0);
-                    let ca = c.a as f64 * a / 255.0;
-                    let pm = |v: f64| (v * ca).round().clamp(0.0, 255.0) as u8;
-                    vello_cpu::color::PremulRgba8 { r: pm(ch(c.r)), g: pm(ch(c.g)), b: pm(ch(c.b)), a: (ca * 255.0).round() as u8 }
-                }
-                None => {
-                    // A veil: white where the band is lighter than the face, black where darker.
-                    let d = ((f - face) * 1.5).clamp(-1.0, 1.0);
-                    let va = (d.abs() * a * 255.0).round().clamp(0.0, 255.0) as u8;
-                    let v = if d > 0.0 { va } else { 0 };
-                    vello_cpu::color::PremulRgba8 { r: v, g: v, b: v, a: va }
-                }
-            };
-            data.push(px);
-        }
-    }
-    let pm = Arc::new(Pixmap::from_parts(data, pw as u16, ph as u16));
-    ctx.set_transform(m);
-    ctx.set_paint(vello_cpu::Image {
-        image: vello_cpu::ImageSource::Pixmap(pm),
-        sampler: peniko::ImageSampler { quality: peniko::ImageQuality::Medium, ..Default::default() },
-    });
-    ctx.set_paint_transform(
-        Affine::translate(bounds.origin().to_vec2()) * Affine::scale_non_uniform(bounds.width() / pw as f64, bounds.height() / ph as f64),
-    );
-    ctx.fill_path(path);
-    ctx.reset_paint_transform();
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn bevels_are_read_from_kept_3d_xml() {
-        let raw = r#"<a:scene3d><a:camera prst="orthographicFront"/></a:scene3d><a:sp3d><a:bevelT w="50800" h="16510" prst="angle"/></a:sp3d>"#;
-        assert_eq!(from_raw(raw), Some(Bevel { w: 4.0, h: 1.3, preset: "angle".into(), modelled: true }));
-        // Defaults: 6 pt square, circle.
-        let raw = r#"<a:scene3d/><a:sp3d><a:bevelT/></a:sp3d>"#;
-        assert_eq!(from_raw(raw), Some(Bevel { w: 6.0, h: 6.0, preset: "circle".into(), modelled: true }));
-        // Another rig or material: not modelled.
-        let raw = r#"<a:scene3d><a:lightRig rig="flood" dir="t"/></a:scene3d><a:sp3d prstMaterial="metal"><a:bevelT/></a:sp3d>"#;
-        assert!(from_raw(raw).is_some_and(|b| !b.modelled));
-        // No scene: flat in PowerPoint.
-        assert_eq!(from_raw(r#"<a:sp3d><a:bevelT w="50800"/></a:sp3d>"#), None);
-        // A 3-D shape with no bevel: a bevel of no width (its face is lit).
-        assert!(from_raw(r#"<a:scene3d/><a:sp3d extrusionH="10"/>"#).is_some_and(|b| b.w == 0.0 && b.modelled));
-        assert_eq!(from_raw(r#"<a:scene3d/>"#), None);
-    }
-
-    #[test]
-    fn the_light_comes_from_the_upper_left() {
-        let l = light();
-        assert!(l[0] < 0.0 && l[1] < 0.0 && l[2] > 0.0);
-        // An upward-facing edge (outward normal up) is lit more than a downward one.
-        let lit = |e: [f64; 2]| {
-            let z = slope("circle", 0.3) * 0.5;
-            let n = [e[0] * z, e[1] * z, 1.0];
-            let len = (n[0] * n[0] + n[1] * n[1] + 1.0).sqrt();
-            (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]) / len
-        };
-        assert!(lit([0.0, -1.0]) > lit([-1.0, 0.0]) && lit([-1.0, 0.0]) > lit([1.0, 0.0]) && lit([1.0, 0.0]) > lit([0.0, 1.0]));
-    }
-}

crates/render/src/camera.rs

@@ -1,202 +0,0 @@
-//! 3-D cameras (`a:scene3d/a:camera`) turning a flat shape, approximated in 2-D.
-//!
-//! A shape seen through a 3-D camera preset (isometric, perspective…) or rotated with
-//! `a:camera/a:rot` is drawn by PowerPoint as its plane turned in space and projected. DeckCraft
-//! turns the shape's corners the same way and draws the shape under the affine transform that best
-//! fits them: exact for orthographic cameras, within about 2% of the shape's size for the
-//! perspective ones (whose foreshortening an affine transform can't show). Depth, bevels' sides and
-//! lighting are not drawn.
-//!
-//! The presets' turns were fitted to PowerPoint's exports (black-box: a picture with coloured
-//! corner markers under each preset, all fits within half a point on a 100 × 75 pt shape):
-//! points relative to the shape's centre are turned `p = Rz(-rev) · Rx(lat) · Ry(lon) · (x, y, 0)`
-//! and, for perspective cameras, scaled by `D / (D - p.z)` with `D = dist · max(w, h)`.
-
-use kurbo::{Affine, Point};
-
-/// (preset, lat, lon, rev in degrees, perspective distance in shape sizes or 0 for orthographic).
-const PRESETS: &[(&str, f64, f64, f64, f64)] = &[
-    ("orthographicFront", 0.0, 0.0, 0.0, 0.0),
-    ("isometricTopUp", 215.52, 134.75, 240.17, 0.0),
-    ("isometricTopDown", 324.69, 45.30, 299.88, 0.0),
-    ("isometricBottomUp", 215.52, 134.75, 240.17, 0.0),
-    ("isometricBottomDown", 215.36, 225.28, 119.86, 0.0),
-    ("isometricLeftUp", 324.94, 44.77, 0.03, 0.0),
-    ("isometricLeftDown", 144.84, 224.73, 179.95, 0.0),
-    ("isometricRightUp", 324.81, 44.75, 359.98, 0.0),
-    ("isometricRightDown", 144.84, 224.73, 179.95, 0.0),
-    ("isometricOffAxis1Left", 17.94, 64.06, 359.94, 0.0),
-    ("isometricOffAxis1Right", 341.80, 25.84, 0.0, 0.0),
-    ("isometricOffAxis1Top", 238.56, 127.22, 237.03, 0.0),
-    ("isometricOffAxis2Left", 161.88, 205.84, 179.98, 0.0),
-    ("isometricOffAxis2Right", 197.91, 244.06, 180.06, 0.0),
-    ("isometricOffAxis2Top", 301.42, 52.80, 302.97, 0.0),
-    ("isometricOffAxis3Left", 197.95, 244.05, 180.06, 0.0),
-    ("isometricOffAxis3Right", 161.88, 205.84, 179.98, 0.0),
-    ("isometricOffAxis3Bottom", 301.42, 52.78, 302.98, 0.0),
-    ("isometricOffAxis4Left", 198.00, 205.84, 180.05, 0.0),
-    ("isometricOffAxis4Right", 17.94, 64.06, 359.94, 0.0),
-    ("isometricOffAxis4Bottom", 121.42, 232.75, 237.00, 0.0),
-    ("perspectiveLeft", 359.91, 341.75, 0.02, 12.14),
-    ("perspectiveRight", 180.27, 198.23, 179.94, 8.02),
-    ("perspectiveAbove", 18.92, 0.38, 0.09, 16.61),
-    ("perspectiveBelow", 198.83, 180.39, 179.89, 9.31),
-    ("perspectiveAboveLeftFacing", 320.78, 346.02, 340.95, 11.54),
-    ("perspectiveAboveRightFacing", 219.25, 194.14, 198.98, 9.28),
-    ("perspectiveContrastingLeftFacing", 190.42, 136.41, 176.42, 12.21),
-    ("perspectiveContrastingRightFacing", 190.52, 223.59, 183.56, 9.53),
-    ("perspectiveHeroicLeftFacing", 10.89, 346.28, 2.75, 13.22),
-    ("perspectiveHeroicRightFacing", 169.53, 194.00, 177.22, 8.45),
-    ("perspectiveHeroicExtremeLeftFacing", 351.98, 325.89, 357.00, 5.98),
-    ("perspectiveHeroicExtremeRightFacing", 188.39, 214.22, 182.81, 5.26),
-    ("perspectiveRelaxed", 50.02, 0.03, 0.0, 11.32),
-    ("perspectiveRelaxedModerately", 34.42, 0.33, 0.16, 11.14),
-];
-
-/// Perspective distance for a perspective camera given its own rotation (fitted on
-/// `perspectiveFront` with `a:rot`, about 11 shape sizes).
-const PERSPECTIVE_DIST: f64 = 11.0;
-
-/// A camera's turn of the shape's plane.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Camera {
-    pub lat: f64,
-    pub lon: f64,
-    pub rev: f64,
-    /// Perspective distance in shape sizes; 0 for an orthographic camera.
-    pub dist: f64,
-}
-
-/// The value of attribute `name` in the first `tag` element of `raw` (XML as kept from the file).
-fn attr<'a>(tag: &'a str, name: &str) -> Option<&'a str> {
-    let key = format!(" {name}=\"");
-    let s = tag.find(&key)? + key.len();
-    let rest = tag.get(s..)?;
-    rest.get(..rest.find('"')?)
-}
-
-/// The camera of 3-D XML kept from the file, when it turns the shape.
-pub fn from_raw(raw: &str) -> Option<Camera> {
-    let i = raw.find("camera ")?;
-    let rest = raw.get(i..)?;
-    let open_end = rest.find('>')?;
-    let open = rest.get(..open_end)?;
-    let prst = attr(open, "prst").unwrap_or("orthographicFront");
-    let preset = PRESETS.iter().find(|p| p.0 == prst);
-    let perspective = prst.starts_with("perspective");
-    // Its own `a:rot` (inside the camera element, not the light rig's).
-    let self_closing = open.ends_with('/');
-    let own_rot = if self_closing {
-        None
-    } else {
-        let body = rest.get(open_end..rest.find("camera>").unwrap_or(rest.len()))?;
-        body.find("rot ").and_then(|j| {
-            let t = body.get(j..)?;
-            let t = t.get(..t.find('>')?)?;
-            let deg = |n: &str| attr(t, n).and_then(|v| v.parse::<f64>().ok()).map(|v| v / 60000.0).unwrap_or(0.0);
-            Some((deg("lat"), deg("lon"), deg("rev")))
-        })
-    };
-    let cam = match (own_rot, preset) {
-        // PowerPoint turns the other way about the horizontal and vertical axes for `a:rot`.
-        (Some((lat, lon, rev)), p) => {
-            let dist = match p {
-                Some(p) if p.4 > 0.0 => p.4,
-                _ if perspective => PERSPECTIVE_DIST,
-                _ => 0.0,
-            };
-            Camera { lat: -lat, lon: -lon, rev, dist }
-        }
-        (None, Some(p)) => Camera { lat: p.1, lon: p.2, rev: p.3, dist: p.4 },
-        (None, None) => return None,
-    };
-    let flat = [cam.lat, cam.lon, cam.rev].iter().all(|a| (a.rem_euclid(360.0)).min(360.0 - a.rem_euclid(360.0)) < 1e-6);
-    (!flat).then_some(cam)
-}
-
-/// Where a point of the shape (relative to its centre) lands.
-fn project(c: &Camera, p: Point, size: f64) -> Point {
-    let (a, b, r) = (c.lat.to_radians(), c.lon.to_radians(), -c.rev.to_radians());
-    let (x1, y1, z1) = (p.x * b.cos(), p.y, -p.x * b.sin());
-    let (x2, y2, z2) = (x1, y1 * a.cos() - z1 * a.sin(), y1 * a.sin() + z1 * a.cos());
-    let (x3, y3) = (x2 * r.cos() - y2 * r.sin(), x2 * r.sin() + y2 * r.cos());
-    if c.dist > 0.0 {
-        let d = c.dist * size;
-        let s = d / (d - z2);
-        if s.is_finite() && s > 0.0 {
-            return Point::new(x3 * s, y3 * s);
-        }
-    }
-    Point::new(x3, y3)
-}
-
-/// The transform (shape space to shape space) that turns a `w` × `h` shape as camera `c` does:
-/// the affine map best fitting its turned corners.
-pub fn affine(c: &Camera, w: f64, h: f64) -> Option<Affine> {
-    if !(w.is_finite() && h.is_finite()) || w <= 0.0 || h <= 0.0 {
-        return None;
-    }
-    let size = w.max(h);
-    let src = [(-w / 2.0, -h / 2.0), (w / 2.0, -h / 2.0), (w / 2.0, h / 2.0), (-w / 2.0, h / 2.0)];
-    let dst: Vec<Point> = src.iter().map(|(x, y)| project(c, Point::new(*x, *y), size)).collect();
-    // Least squares over the four corners. The corners are symmetric about the centre, so the
-    // normal equations are diagonal: x' = a x + b y + e with a = Σ x x' / Σ x², and so on.
-    let (sxx, syy) = (src.iter().map(|p| p.0 * p.0).sum::<f64>(), src.iter().map(|p| p.1 * p.1).sum::<f64>());
-    let dot = |f: &dyn Fn(&(f64, f64), &Point) -> f64| src.iter().zip(&dst).map(|(s, d)| f(s, d)).sum::<f64>();
-    let a = dot(&|s, d| s.0 * d.x) / sxx;
-    let b = dot(&|s, d| s.1 * d.x) / syy;
-    let cc = dot(&|s, d| s.0 * d.y) / sxx;
-    let dd = dot(&|s, d| s.1 * d.y) / syy;
-    let e = dot(&|_, d| d.x) / 4.0;
-    let f = dot(&|_, d| d.y) / 4.0;
-    let local = Affine::new([a, cc, b, dd, e, f]);
-    let m = Affine::translate((w / 2.0, h / 2.0)) * local * Affine::translate((-w / 2.0, -h / 2.0));
-    (m.is_finite() && m.determinant().abs() > 1e-9).then_some(m)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn corners(m: Affine, w: f64, h: f64) -> Vec<Point> {
-        [(0.0, 0.0), (w, 0.0), (w, h), (0.0, h)].iter().map(|(x, y)| m * Point::new(*x, *y)).collect()
-    }
-
-    #[test]
-    fn turning_about_the_vertical_axis_narrows_the_shape() {
-        // orthographicFront with lon 60: half as wide, as tall (PowerPoint: 0.506 of the width).
-        let c = from_raw(r#"<a:scene3d><a:camera prst="orthographicFront"><a:rot lat="0" lon="3600000" rev="0"/></a:camera><a:lightRig rig="threePt" dir="t"><a:rot lat="0" lon="0" rev="1200000"/></a:lightRig></a:scene3d>"#).unwrap();
-        let m = affine(&c, 100.0, 75.0).unwrap();
-        let k = corners(m, 100.0, 75.0);
-        assert!((k[1].x - k[0].x - 50.0).abs() < 0.01 && (k[3].y - k[0].y - 75.0).abs() < 0.01, "{k:?}");
-        assert!(((k[0].x + k[1].x) / 2.0 - 50.0).abs() < 1e-9, "about the centre");
-    }
-
-    #[test]
-    fn presets_turn_the_shape_as_powerpoint_does() {
-        // isometricTopUp, 100 × 75: PowerPoint's corners at (-1.247, 0.127), (0.170, -0.955),
-        // (1.237, -0.141), (-0.181, 0.941) of the half sizes from the centre.
-        let c = from_raw(r#"<a:scene3d><a:camera prst="isometricTopUp"/><a:lightRig rig="threePt" dir="t"/></a:scene3d>"#).unwrap();
-        let k = corners(affine(&c, 100.0, 75.0).unwrap(), 100.0, 75.0);
-        for (p, (u, v)) in k.iter().zip([(-1.247, 0.127), (0.170, -0.955), (1.237, -0.141), (-0.181, 0.941)]) {
-            let (x, y) = ((p.x - 50.0) / 50.0, (p.y - 37.5) / 37.5);
-            assert!((x - u).abs() < 0.03 && (y - v).abs() < 0.03, "({x:.3}, {y:.3}) vs ({u}, {v})");
-        }
-        // Front-facing cameras and the oblique ones leave a flat shape as it is.
-        for raw in [r#"<a:scene3d><a:camera prst="orthographicFront"/></a:scene3d>"#, r#"<a:scene3d><a:camera prst="obliqueTopLeft"/></a:scene3d>"#] {
-            assert_eq!(from_raw(raw), None);
-        }
-        assert_eq!(from_raw("<a:sp3d/>"), None);
-    }
-
-    #[test]
-    fn a_perspective_camera_is_approximated_closely() {
-        // perspectiveContrastingLeftFacing on 100 × 75: PowerPoint's corners within 3% of the size.
-        let c = from_raw(r#"<a:scene3d><a:camera prst="perspectiveContrastingLeftFacing"/></a:scene3d>"#).unwrap();
-        let k = corners(affine(&c, 100.0, 75.0).unwrap(), 100.0, 75.0);
-        for (p, (u, v)) in k.iter().zip([(-0.657, -1.189), (0.791, -0.795), (0.685, 1.244), (-0.742, 0.729)]) {
-            let (dx, dy) = (p.x - 50.0 - u * 50.0, p.y - 37.5 - v * 37.5);
-            assert!(dx.hypot(dy) < 3.0, "{p:?} vs ({u}, {v})");
-        }
-    }
-}

crates/render/src/chart.rs

@@ -2,7 +2,7 @@
 
 use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
 use deckcraft_model::Shape;
-use deckcraft_model::chart::{Chart, ChartType, axis_scale};
+use deckcraft_model::chart::{Chart, ChartType, nice_scale};
 use deckcraft_model::resolve::Ctx;
 use deckcraft_model::style::{ColorRef, Fill};
 use deckcraft_model::text::{Align, Anchor, Bullet, TextBody};
@@ -36,29 +36,6 @@ fn series_fill(ctx: &Ctx, c: &Chart, i: usize, s: Option<&deckcraft_model::chart
     }
 }
 
-/// A line series' colour: its line's own (where PowerPoint keeps it), else its fill's, else the
-/// palette's.
-fn series_line(ctx: &Ctx, c: &Chart, i: usize, s: &deckcraft_model::chart::Series) -> Rgba {
-    match s.line.as_ref().and_then(|l| l.fill.as_ref()) {
-        Some(Fill::Solid { color: cc }) => ctx.color(cc, None),
-        _ => series_fill(ctx, c, i, Some(s)),
-    }
-}
-
-/// A category label on two lines, split at its middle space or dash ("03.11.2025 - 09.11.2025").
-fn split_label(name: &str) -> String {
-    let chars: Vec<char> = name.chars().collect();
-    let mid = chars.len() / 2;
-    let best = chars.iter().enumerate().filter(|(_, c)| c.is_whitespace()).map(|(i, _)| i).min_by_key(|i| i.abs_diff(mid));
-    match best {
-        Some(i) if i > 0 && i + 1 < chars.len() => {
-            let (a, b) = chars.split_at(i);
-            format!("{}\n{}", a.iter().collect::<String>().trim_end(), b.iter().collect::<String>().trim_start())
-        }
-        _ => name.to_string(),
-    }
-}
-
 fn label(ctx: &mut RenderContext, rctx: &Ctx, m: Affine, text: &str, r: Rect, size: f64, align: Align, anchor: Anchor, col: Rgba, bold: bool) {
     let mut body = TextBody::from_text(text);
     body.body.inset_l = Some(0.0);
@@ -86,42 +63,6 @@ fn fmt_num(v: f64) -> String {
     if (v - v.round()).abs() < 1e-9 { format!("{}", v.round() as i64) } else { format!("{v:.1}") }
 }
 
-/// Where the legend goes for `c:legendPos`, and the plot area left over.
-/// `size` is the legend block (width, height); the result is its top-left corner and the plot area.
-/// `r` (also the OOXML default and the fallback for unknown values) and `l` are vertical stacks centred
-/// on the area, `tr` is a vertical stack in the top-right corner, `t` and `b` are centred rows.
-/// An overlaid legend leaves the plot area as it was.
-fn legend_layout(pos: &str, size: (f64, f64), area: Rect, base: f64, overlay: bool) -> (Point, Rect) {
-    let (lw, lh) = size;
-    let gap = base * 0.5;
-    let cx = (area.x0 + area.x1) / 2.0;
-    let cy = ((area.y0 + area.y1) / 2.0 - lh / 2.0).max(area.y0);
-    let mut plot = area;
-    let origin = match pos {
-        "b" => {
-            plot.y1 = area.y1 - lh - gap;
-            Point::new(cx - lw / 2.0, area.y1 - lh)
-        }
-        "t" => {
-            plot.y0 = area.y0 + lh + gap;
-            Point::new(cx - lw / 2.0, area.y0)
-        }
-        "l" => {
-            plot.x0 = area.x0 + lw + gap;
-            Point::new(area.x0, cy)
-        }
-        "tr" => {
-            plot.x1 = area.x1 - lw - gap;
-            Point::new(area.x1 - lw, area.y0)
-        }
-        _ => {
-            plot.x1 = area.x1 - lw - gap;
-            Point::new(area.x1 - lw, cy)
-        }
-    };
-    (origin, if overlay { area } else { plot })
-}
-
 pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h: f64) {
     let text_col = c.text_color.as_ref().map(|t| rctx.color(t, None)).unwrap_or(Rgba::rgb(0x59, 0x59, 0x59));
     let grid_col = Rgba::rgb(0xD9, 0xD9, 0xD9);
@@ -139,53 +80,32 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
             rctx.pres,
         );
     }
-    // The file's text sizes when it has them (PowerPoint draws chart text at them); otherwise a size
-    // that suits the chart.
-    let base = c.text_size.unwrap_or_else(|| (h.min(w) / 22.0).clamp(7.0, 18.0));
-    let title_size = c.title_size.unwrap_or(base * 1.4);
+    let base = (h.min(w) / 22.0).clamp(7.0, 18.0);
     let mut area = Rect::new(w * 0.04, h * 0.04, w * 0.96, h * 0.96);
     if let Some(t) = &c.title {
-        label(ctx, rctx, m, t, Rect::new(0.0, area.y0, w, area.y0 + title_size * 1.3), title_size, Align::Center, Anchor::Top, text_col, false);
-        area.y0 += title_size * 1.7;
+        label(ctx, rctx, m, t, Rect::new(0.0, area.y0, w, area.y0 + base * 1.8), base * 1.4, Align::Center, Anchor::Top, text_col, false);
+        area.y0 += base * 2.4;
     }
     let pie = matches!(c.kind, ChartType::Pie | ChartType::Doughnut);
-    // Legend placed by `c:legendPos`.
+    // Legend at the bottom.
     let legend_items: Vec<(String, Rgba)> = if pie {
         c.categories.iter().enumerate().map(|(i, n)| (n.clone(), series_color(rctx, c, i))).collect()
     } else {
-        c.series
-            .iter()
-            .enumerate()
-            .map(|(i, s)| {
-                let k = c.series_kind(s);
-                let line = !k.is_bar_like() && !matches!(k, ChartType::Area | ChartType::StackedArea | ChartType::FilledRadar);
-                (s.name.clone(), if line { series_line(rctx, c, i, s) } else { series_fill(rctx, c, i, Some(s)) })
-            })
-            .collect()
+        c.series.iter().enumerate().map(|(i, s)| (s.name.clone(), series_fill(rctx, c, i, Some(s)))).collect()
     };
-    if let (Some(pos), false) = (&c.legend, legend_items.is_empty()) {
-        let vertical = matches!(pos.as_str(), "l" | "r" | "tr");
-        let item_ws: Vec<f64> = legend_items.iter().map(|(n, _)| n.chars().count() as f64 * base * 0.55 + base * 1.6).collect();
-        let size = if vertical {
-            (item_ws.iter().copied().fold(0.0, f64::max).min(w * 0.4), legend_items.len() as f64 * base * 1.5)
-        } else {
-            (item_ws.iter().sum::<f64>().min(w * 0.9), base * 1.4)
-        };
-        let (origin, plot_area) = legend_layout(pos, size, area, base, c.legend_overlay);
-        area = plot_area;
-        let (mut x, mut y) = (origin.x, origin.y);
+    if c.legend.is_some() && !legend_items.is_empty() {
+        let ly = area.y1 - base * 1.4;
+        let item_w = (legend_items.iter().map(|(n, _)| n.chars().count() as f64 * base * 0.55 + base * 1.6).sum::<f64>()).min(w * 0.9);
+        let mut x = (w - item_w) / 2.0;
         for (name, col) in &legend_items {
             ctx.set_transform(m);
             ctx.set_paint(color(*col, 1.0));
-            ctx.fill_rect(&Rect::new(x, y + base * 0.3, x + base * 0.7, y + base));
+            ctx.fill_rect(&Rect::new(x, ly + base * 0.3, x + base * 0.7, ly + base));
             let tw = name.chars().count() as f64 * base * 0.55 + base;
-            label(ctx, rctx, m, name, Rect::new(x + base, y, x + base + tw, y + base * 1.3), base, Align::Left, Anchor::Middle, text_col, false);
-            if vertical {
-                y += base * 1.5;
-            } else {
-                x += tw + base * 0.6;
-            }
+            label(ctx, rctx, m, name, Rect::new(x + base, ly, x + base + tw, ly + base * 1.3), base, Align::Left, Anchor::Middle, text_col, false);
+            x += tw + base * 0.6;
         }
+        area.y1 = ly - base * 0.5;
     }
     if pie {
         let Some(s) = c.series.first() else { return };
@@ -242,50 +162,26 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
         }
         return;
     }
-    let combo = c.kind == ChartType::Combo;
-    // Bars are drawn first and lines over them; a combo chart has both.
-    let bar_kind = c.series.iter().map(|s| c.series_kind(s)).find(|k| k.is_bar_like());
-    let horiz = if combo { bar_kind.is_some_and(ChartType::horizontal) } else { c.kind.horizontal() };
-    // As many major units as the value axis has room for labels (PowerPoint's automatic unit).
-    let axis_len = if horiz { area.width() - base * 4.5 } else { area.height() - base * 1.8 };
-    let max_intervals = (axis_len / if horiz { base * 6.0 } else { base * 1.9 }).floor().clamp(2.0, 12.0) as usize;
-    let (min, max, step) = c.axis_scale(false, max_intervals).unwrap_or_else(|| axis_scale(0.0, 1.0, None, None, None, max_intervals, true));
-    // A combo chart's secondary value axis, on the right (vertical value axes only).
-    let second = if horiz { None } else { c.axis_scale(true, max_intervals) };
-    let ticks = |(lo, hi, st): (f64, f64, f64)| {
-        let n = (((hi - lo) / st.max(1e-12)).round() as i64).clamp(1, 50);
-        (0..=n).map(move |k| lo + k as f64 * st)
-    };
-    // Label gutters as wide as the longest value label.
-    let label_w =
-        |sec: bool, sc: (f64, f64, f64)| ticks(sc).map(|v| c.axis_label(sec, v).chars().count()).max().unwrap_or(1) as f64 * base * 0.55 + base * 0.6;
-    let gutter = if horiz {
-        base * 4.5
-    } else if c.y_hidden {
-        base * 0.5
-    } else {
-        label_w(false, (min, max, step)).clamp(base * 1.5, area.width() * 0.3)
-    };
-    let gutter_r = second.filter(|_| !c.y2_hidden).map(|sc| label_w(true, sc).clamp(base * 1.5, area.width() * 0.3)).unwrap_or(0.0);
+    let (lo, hi) = c.value_range();
+    let (min, max, step) = nice_scale(lo.min(0.0), hi);
+    let horiz = c.kind.horizontal();
+    // Axis label gutter.
+    let gutter = base * 3.0;
     let plot = if horiz {
-        Rect::new(area.x0 + gutter, area.y0, area.x1, area.y1 - base * 1.6)
+        Rect::new(area.x0 + gutter * 1.5, area.y0, area.x1, area.y1 - base * 1.6)
     } else {
-        Rect::new(area.x0 + gutter, area.y0, area.x1 - gutter_r, area.y1 - base * 1.8)
+        Rect::new(area.x0 + gutter, area.y0, area.x1, area.y1 - base * 1.8)
     };
     if let Some(f) = &c.plot_fill {
         crate::paint::fill_path(ctx, rctx, f, None, &plot.to_path(0.1), plot, m, deckcraft_geom::preset::FillMode::Norm, 1.0, rctx.pres);
     }
     let span = (max - min).max(1e-9);
     let to_v = |v: f64| if horiz { plot.x0 + (v - min) / span * plot.width() } else { plot.y1 - (v - min) / span * plot.height() };
-    // A series' value as a position on its own axis.
-    let to_axis = |sec: bool, v: f64| match (sec, second) {
-        (true, Some((min2, max2, _))) => plot.y1 - (v - min2) / (max2 - min2).max(1e-9) * plot.height(),
-        _ => to_v(v),
-    };
     // Gridlines and value labels.
-    for v in ticks((min, max, step)) {
+    let n_steps = ((span / step).round() as i64).clamp(1, 50);
+    for k in 0..=n_steps {
+        let v = min + k as f64 * step;
         let pos = to_v(v);
-        let text = if c.y_hidden { String::new() } else { c.axis_label(false, v) };
         let mut g = BezPath::new();
         if horiz {
             g.move_to((pos, plot.y0));
@@ -294,7 +190,7 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
                 ctx,
                 rctx,
                 m,
-                &text,
+                &fmt_num(v),
                 Rect::new(pos - 30.0, plot.y1 + 2.0, pos + 30.0, plot.y1 + base * 1.5),
                 base,
                 Align::Center,
@@ -309,7 +205,7 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
                 ctx,
                 rctx,
                 m,
-                &text,
+                &fmt_num(v),
                 Rect::new(area.x0, pos - base, plot.x0 - base * 0.4, pos + base),
                 base,
                 Align::Right,
@@ -325,28 +221,9 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
             ctx.stroke_path(&g);
         }
     }
-    // The secondary axis' labels, on the right, without gridlines of their own.
-    if let Some(sc) = second.filter(|_| !c.y2_hidden) {
-        for v in ticks(sc) {
-            let pos = to_axis(true, v);
-            label(
-                ctx,
-                rctx,
-                m,
-                &c.axis_label(true, v),
-                Rect::new(plot.x1 + base * 0.4, pos - base, area.x1, pos + base),
-                base,
-                Align::Left,
-                Anchor::Middle,
-                text_col,
-                false,
-            );
-        }
-    }
     let ncat = c.categories.len().max(c.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).max(1);
     let band = if horiz { plot.height() / ncat as f64 } else { plot.width() / ncat as f64 };
-    // Category labels: wrapped onto two lines when they don't fit their band (long date ranges).
-    let wraps = !horiz && c.categories.iter().any(|n| n.chars().count() as f64 * base * 0.5 > band);
+    // Category labels.
     for (i, name) in c.categories.iter().enumerate() {
         let mid = if horiz { plot.y0 + band * (i as f64 + 0.5) } else { plot.x0 + band * (i as f64 + 0.5) };
         if horiz {
@@ -363,13 +240,12 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
                 false,
             );
         } else {
-            let text = if wraps { split_label(name) } else { name.clone() };
             label(
                 ctx,
                 rctx,
                 m,
-                &text,
-                Rect::new(mid - band / 2.0, plot.y1 + 3.0, mid + band / 2.0, plot.y1 + base * if wraps { 2.8 } else { 1.6 }),
+                name,
+                Rect::new(mid - band / 2.0, plot.y1 + 3.0, mid + band / 2.0, plot.y1 + base * 1.6),
                 base,
                 Align::Center,
                 Anchor::Top,
@@ -378,27 +254,24 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
             );
         }
     }
+    let ns = c.series.len().max(1);
     let zero = to_v(0.0f64.clamp(min, max));
-    if let Some(bk) = bar_kind {
-        let bars: Vec<(usize, &deckcraft_model::chart::Series)> =
-            c.series.iter().enumerate().filter(|(_, s)| c.series_kind(s).is_bar_like()).collect();
-        let ns = bars.len().max(1);
+    if c.kind.is_bar_like() {
         let gap = c.gap_width.clamp(0.0, 5.0);
         let group = band / (1.0 + gap);
-        let stacked = bk.stacked();
+        let stacked = c.kind.stacked();
         let bar = if stacked { group } else { group / ns as f64 };
         for i in 0..ncat {
             let mut pos_acc = 0.0;
             let mut neg_acc = 0.0;
-            let total: f64 = if bk.percent() {
-                bars.iter().map(|(_, s)| s.values.get(i).copied().flatten().unwrap_or(0.0).abs()).sum::<f64>().max(1e-9)
+            let total: f64 = if c.kind.percent() {
+                c.series.iter().map(|s| s.values.get(i).copied().flatten().unwrap_or(0.0).abs()).sum::<f64>().max(1e-9)
             } else {
                 1.0
             };
-            for (bi, (si, s)) in bars.iter().enumerate() {
-                let sec = c.on_secondary(s);
+            for (si, s) in c.series.iter().enumerate() {
                 let v = s.values.get(i).copied().flatten().unwrap_or(0.0) / total;
-                let start = band * i as f64 + (band - group) / 2.0 + if stacked { 0.0 } else { bar * bi as f64 };
+                let start = band * i as f64 + (band - group) / 2.0 + if stacked { 0.0 } else { bar * si as f64 };
                 let (a, b) = if stacked {
                     if v >= 0.0 {
                         let r = (pos_acc, pos_acc + v);
@@ -415,13 +288,13 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
                 let r = if horiz {
                     Rect::new(to_v(a), plot.y0 + start, to_v(b), plot.y0 + start + bar)
                 } else {
-                    Rect::new(plot.x0 + start, to_axis(sec, b), plot.x0 + start + bar, to_axis(sec, a))
+                    Rect::new(plot.x0 + start, to_v(b), plot.x0 + start + bar, to_v(a))
                 };
                 ctx.set_transform(m);
-                ctx.set_paint(color(series_fill(rctx, c, *si, Some(s)), 1.0));
+                ctx.set_paint(color(series_fill(rctx, c, si, Some(s)), 1.0));
                 ctx.fill_rect(&r.abs());
                 if c.data_labels {
-                    let t = c.data_label(s, s.values.get(i).copied().flatten().unwrap_or(0.0));
+                    let t = fmt_num(s.values.get(i).copied().flatten().unwrap_or(0.0));
                     let lr = if horiz {
                         Rect::new(r.x1 + 2.0, r.y0, r.x1 + 40.0, r.y1)
                     } else {
@@ -442,72 +315,66 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
                 }
             }
         }
-    }
-    // Lines, areas, scatter, radar (drawn as lines): the series that aren't bars.
-    let mut acc = vec![0.0; ncat];
-    for (si, s) in c.series.iter().enumerate() {
-        let kind = c.series_kind(s);
-        if kind.is_bar_like() {
-            continue;
-        }
-        let sec = c.on_secondary(s);
-        let stacked = kind.stacked();
-        let area_kind = matches!(kind, ChartType::Area | ChartType::StackedArea | ChartType::FilledRadar);
-        let col = if area_kind { series_fill(rctx, c, si, Some(s)) } else { series_line(rctx, c, si, s) };
-        let mut pts = vec![];
-        for i in 0..ncat {
-            let Some(v) = s.values.get(i).copied().flatten() else { continue };
-            let v = if stacked {
-                let base_v = acc.get(i).copied().unwrap_or(0.0);
-                if let Some(a) = acc.get_mut(i) {
-                    *a += v;
-                }
-                base_v + v
-            } else {
-                v
-            };
-            let x = match kind {
-                ChartType::Scatter | ChartType::Bubble => {
-                    let xs: Vec<f64> = s.x_values.iter().flatten().copied().collect();
-                    let (xl, xh) = (xs.iter().copied().fold(f64::MAX, f64::min), xs.iter().copied().fold(f64::MIN, f64::max));
-                    let xv = s.x_values.get(i).copied().flatten().unwrap_or(i as f64);
-                    if xh > xl { plot.x0 + (xv - xl) / (xh - xl) * plot.width() } else { plot.x0 + band * (i as f64 + 0.5) }
-                }
-                _ => plot.x0 + band * (i as f64 + 0.5),
-            };
-            pts.push(Point::new(x, to_axis(sec, v)));
-        }
-        if pts.is_empty() {
-            continue;
-        }
-        let mut p = BezPath::new();
-        for (k, q) in pts.iter().enumerate() {
-            if k == 0 {
-                p.move_to(*q);
-            } else {
-                p.line_to(*q);
+    } else {
+        // Lines, areas, scatter, radar (drawn as lines).
+        let stacked = c.kind.stacked();
+        let mut acc = vec![0.0; ncat];
+        for (si, s) in c.series.iter().enumerate() {
+            let col = series_fill(rctx, c, si, Some(s));
+            let mut pts = vec![];
+            for i in 0..ncat {
+                let Some(v) = s.values.get(i).copied().flatten() else { continue };
+                let v = if stacked {
+                    let base_v = acc.get(i).copied().unwrap_or(0.0);
+                    if let Some(a) = acc.get_mut(i) {
+                        *a += v;
+                    }
+                    base_v + v
+                } else {
+                    v
+                };
+                let x = match c.kind {
+                    ChartType::Scatter | ChartType::Bubble => {
+                        let xs: Vec<f64> = s.x_values.iter().flatten().copied().collect();
+                        let (xl, xh) = (xs.iter().copied().fold(f64::MAX, f64::min), xs.iter().copied().fold(f64::MIN, f64::max));
+                        let xv = s.x_values.get(i).copied().flatten().unwrap_or(i as f64);
+                        if xh > xl { plot.x0 + (xv - xl) / (xh - xl) * plot.width() } else { plot.x0 + band * (i as f64 + 0.5) }
+                    }
+                    _ => plot.x0 + band * (i as f64 + 0.5),
+                };
+                pts.push(Point::new(x, to_v(v)));
             }
-        }
-        ctx.set_transform(m);
-        if area_kind {
-            let mut a = p.clone();
-            if let (Some(l), Some(f)) = (pts.last(), pts.first()) {
-                a.line_to((l.x, zero));
-                a.line_to((f.x, zero));
-                a.close_path();
+            if pts.is_empty() {
+                continue;
             }
-            ctx.set_paint(color(col, 0.85));
-            ctx.fill_path(&a);
-        } else if kind != ChartType::Scatter {
-            let lw = s.line.as_ref().and_then(|l| l.width).filter(|w| w.is_finite() && *w > 0.0).unwrap_or(2.25).clamp(0.25, 20.0);
-            ctx.set_paint(color(col, 1.0));
-            ctx.set_stroke(kurbo::Stroke::new(lw).with_join(kurbo::Join::Round).with_caps(kurbo::Cap::Round));
-            ctx.stroke_path(&p);
-        }
-        if matches!(kind, ChartType::LineMarkers | ChartType::Scatter | ChartType::Bubble) {
-            ctx.set_paint(color(col, 1.0));
-            for q in &pts {
-                ctx.fill_path(&kurbo::Circle::new(*q, 3.5).to_path(0.1));
+            let mut p = BezPath::new();
+            for (k, q) in pts.iter().enumerate() {
+                if k == 0 {
+                    p.move_to(*q);
+                } else {
+                    p.line_to(*q);
+                }
+            }
+            ctx.set_transform(m);
+            if matches!(c.kind, ChartType::Area | ChartType::StackedArea | ChartType::FilledRadar) {
+                let mut a = p.clone();
+                if let (Some(l), Some(f)) = (pts.last(), pts.first()) {
+                    a.line_to((l.x, zero));
+                    a.line_to((f.x, zero));
+                    a.close_path();
+                }
+                ctx.set_paint(color(col, 0.85));
+                ctx.fill_path(&a);
+            } else if c.kind != ChartType::Scatter {
+                ctx.set_paint(color(col, 1.0));
+                ctx.set_stroke(kurbo::Stroke::new(2.25).with_join(kurbo::Join::Round).with_caps(kurbo::Cap::Round));
+                ctx.stroke_path(&p);
+            }
+            if matches!(c.kind, ChartType::LineMarkers | ChartType::Scatter | ChartType::Bubble) {
+                ctx.set_paint(color(col, 1.0));
+                for q in &pts {
+                    ctx.fill_path(&kurbo::Circle::new(*q, 3.5).to_path(0.1));
+                }
             }
         }
     }
@@ -525,40 +392,3 @@ pub fn draw(ctx: &mut RenderContext, rctx: &Ctx, c: &Chart, m: Affine, w: f64, h
     ctx.set_stroke(kurbo::Stroke::new(0.75));
     ctx.stroke_path(&ax);
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const AREA: Rect = Rect::new(0.0, 0.0, 400.0, 300.0);
-
-    #[test]
-    fn right_legend_is_a_centred_column_and_narrows_the_plot() {
-        let (o, plot) = legend_layout("r", (60.0, 100.0), AREA, 10.0, false);
-        assert_eq!((o.x, o.y), (340.0, 100.0));
-        assert_eq!((plot.x0, plot.x1, plot.y0, plot.y1), (0.0, 335.0, 0.0, 300.0));
-    }
-
-    #[test]
-    fn left_top_and_corner_positions() {
-        let (o, plot) = legend_layout("l", (60.0, 100.0), AREA, 10.0, false);
-        assert_eq!((o.x, o.y, plot.x0, plot.x1), (0.0, 100.0, 65.0, 400.0));
-        let (o, plot) = legend_layout("t", (100.0, 14.0), AREA, 10.0, false);
-        assert_eq!((o.x, o.y, plot.y0, plot.y1), (150.0, 0.0, 19.0, 300.0));
-        let (o, plot) = legend_layout("tr", (60.0, 100.0), AREA, 10.0, false);
-        assert_eq!((o.x, o.y, plot.x1), (340.0, 0.0, 335.0));
-    }
-
-    #[test]
-    fn bottom_legend_keeps_the_old_row_layout() {
-        let (o, plot) = legend_layout("b", (100.0, 14.0), AREA, 10.0, false);
-        assert_eq!((o.x, o.y, plot.y1, plot.x1), (150.0, 286.0, 281.0, 400.0));
-    }
-
-    #[test]
-    fn overlay_does_not_shrink_the_plot() {
-        let (o, plot) = legend_layout("r", (60.0, 100.0), AREA, 10.0, true);
-        assert_eq!(plot, AREA);
-        assert_eq!(o.x, 340.0);
-    }
-}

crates/render/src/colr.rs

@@ -1,212 +0,0 @@
-//! Colour glyphs (OpenType `COLR` v0 and v1, colours from `CPAL`), as colour emoji fonts draw
-//! them: layers of glyph outlines filled with solid colours or gradients.
-
-use deckcraft_color::Rgba;
-use deckcraft_fonts::FontFace;
-use kurbo::{Affine, BezPath, Point, Rect};
-use skrifa::color::{Brush, ColorPainter, ColorStop, CompositeMode, Extend, Transform};
-use skrifa::raw::types::BoundingBox;
-use skrifa::{GlyphId, MetadataProvider};
-use vello_cpu::{RenderContext, peniko};
-
-/// Nesting depth of clips and layers past which a glyph opens no more (hostile fonts).
-const MAX_DEPTH: usize = 64;
-
-/// Paint `gid` of `face` as a colour glyph, its origin mapped by `at` (y down, points) at `scale`
-/// points per font unit. `fg` is the text colour (palette index 0xFFFF) and `alpha` fades it all.
-/// False when the glyph has no colour version, so the caller draws the plain outline.
-pub fn paint(ctx: &mut RenderContext, face: &FontFace, gid: u32, at: Affine, scale: f64, fg: Rgba, alpha: f64) -> bool {
-    let Some(font) = face.skrifa() else { return false };
-    let glyphs = font.color_glyphs();
-    let Some(glyph) = glyphs.get(GlyphId::new(gid)) else { return false };
-    let palette: Vec<Rgba> = font
-        .color_palettes()
-        .get(0)
-        .map(|p| p.colors().iter().map(|c| Rgba { r: c.red, g: c.green, b: c.blue, a: c.alpha }).collect())
-        .unwrap_or_default();
-    // Font units are y up; the slide is y down.
-    let base = at * Affine::scale(scale) * Affine::scale_non_uniform(1.0, -1.0);
-    let mut p = Painter { ctx, face, base, stack: vec![Affine::IDENTITY], palette, fg, opened: Vec::new() };
-    p.ctx.push_layer(None, None, Some(alpha.clamp(0.0, 1.0) as f32), None, None);
-    let ok = glyph.paint(face.location(), &mut p).is_ok();
-    // A malformed glyph may leave layers open: close them all.
-    while let Some(open) = p.opened.pop() {
-        if open {
-            p.ctx.pop_layer();
-        }
-    }
-    p.ctx.pop_layer();
-    ok
-}
-
-struct Painter<'a> {
-    ctx: &'a mut RenderContext,
-    face: &'a FontFace,
-    base: Affine,
-    /// Transforms pushed by the glyph (font units), innermost last.
-    stack: Vec<Affine>,
-    palette: Vec<Rgba>,
-    fg: Rgba,
-    /// Clips and composite groups pushed by the glyph, innermost last: true when a layer was
-    /// opened on the context for it (false past `MAX_DEPTH`, so its pop is skipped too).
-    opened: Vec<bool>,
-}
-
-fn affine(t: &Transform) -> Affine {
-    Affine::new([t.xx as f64, t.yx as f64, t.xy as f64, t.yy as f64, t.dx as f64, t.dy as f64])
-}
-
-fn pt(p: skrifa::raw::types::Point<f32>) -> Point {
-    Point::new(p.x as f64, p.y as f64)
-}
-
-fn extend(e: Extend) -> peniko::Extend {
-    match e {
-        Extend::Repeat => peniko::Extend::Repeat,
-        Extend::Reflect => peniko::Extend::Reflect,
-        _ => peniko::Extend::Pad,
-    }
-}
-
-fn blend(m: CompositeMode) -> peniko::BlendMode {
-    use peniko::{Compose, Mix};
-    let (mix, compose) = match m {
-        CompositeMode::Clear => (Mix::Normal, Compose::Clear),
-        CompositeMode::Src => (Mix::Normal, Compose::Copy),
-        CompositeMode::Dest => (Mix::Normal, Compose::Dest),
-        CompositeMode::DestOver => (Mix::Normal, Compose::DestOver),
-        CompositeMode::SrcIn => (Mix::Normal, Compose::SrcIn),
-        CompositeMode::DestIn => (Mix::Normal, Compose::DestIn),
-        CompositeMode::SrcOut => (Mix::Normal, Compose::SrcOut),
-        CompositeMode::DestOut => (Mix::Normal, Compose::DestOut),
-        CompositeMode::SrcAtop => (Mix::Normal, Compose::SrcAtop),
-        CompositeMode::DestAtop => (Mix::Normal, Compose::DestAtop),
-        CompositeMode::Xor => (Mix::Normal, Compose::Xor),
-        CompositeMode::Plus => (Mix::Normal, Compose::Plus),
-        CompositeMode::Screen => (Mix::Screen, Compose::SrcOver),
-        CompositeMode::Overlay => (Mix::Overlay, Compose::SrcOver),
-        CompositeMode::Darken => (Mix::Darken, Compose::SrcOver),
-        CompositeMode::Lighten => (Mix::Lighten, Compose::SrcOver),
-        CompositeMode::ColorDodge => (Mix::ColorDodge, Compose::SrcOver),
-        CompositeMode::ColorBurn => (Mix::ColorBurn, Compose::SrcOver),
-        CompositeMode::HardLight => (Mix::HardLight, Compose::SrcOver),
-        CompositeMode::SoftLight => (Mix::SoftLight, Compose::SrcOver),
-        CompositeMode::Difference => (Mix::Difference, Compose::SrcOver),
-        CompositeMode::Exclusion => (Mix::Exclusion, Compose::SrcOver),
-        CompositeMode::Multiply => (Mix::Multiply, Compose::SrcOver),
-        CompositeMode::HslHue => (Mix::Hue, Compose::SrcOver),
-        CompositeMode::HslSaturation => (Mix::Saturation, Compose::SrcOver),
-        CompositeMode::HslColor => (Mix::Color, Compose::SrcOver),
-        CompositeMode::HslLuminosity => (Mix::Luminosity, Compose::SrcOver),
-        _ => (Mix::Normal, Compose::SrcOver),
-    };
-    peniko::BlendMode::new(mix, compose)
-}
-
-impl Painter<'_> {
-    fn current(&self) -> Affine {
-        self.base * self.stack.last().copied().unwrap_or(Affine::IDENTITY)
-    }
-
-    fn color(&self, index: u16, alpha: f32) -> peniko::Color {
-        let c = if index == 0xFFFF { self.fg } else { self.palette.get(index as usize).copied().unwrap_or(self.fg) };
-        let a = (c.a as f64 * (alpha as f64).clamp(0.0, 1.0)).round().clamp(0.0, 255.0) as u8;
-        peniko::Color::from_rgba8(c.r, c.g, c.b, a)
-    }
-
-    fn stops(&self, stops: &[ColorStop]) -> Vec<peniko::ColorStop> {
-        stops.iter().map(|s| peniko::ColorStop { offset: s.offset.clamp(0.0, 1.0), color: self.color(s.palette_index, s.alpha).into() }).collect()
-    }
-
-    /// The glyph outline in font units, y up.
-    fn outline(&self, gid: GlyphId) -> BezPath {
-        let p = deckcraft_fonts::FontDb::global().outline(self.face, gid.to_u32());
-        Affine::scale_non_uniform(1.0, -1.0) * (*p).clone()
-    }
-
-    fn push_clip(&mut self, path: &BezPath) {
-        let open = self.opened.len() < MAX_DEPTH;
-        if open {
-            self.ctx.set_transform(self.current());
-            self.ctx.push_clip_layer(path);
-        }
-        self.opened.push(open);
-    }
-
-    fn pop(&mut self) {
-        if self.opened.pop() == Some(true) {
-            self.ctx.pop_layer();
-        }
-    }
-
-    /// Fill the open clip area (a large box in the current transform) with `paint`.
-    fn cover(&mut self, paint: impl Into<vello_cpu::PaintType>) {
-        self.ctx.set_transform(self.current());
-        self.ctx.set_paint(paint);
-        self.ctx.fill_rect(&Rect::new(-1.0e5, -1.0e5, 1.0e5, 1.0e5));
-    }
-}
-
-impl ColorPainter for Painter<'_> {
-    fn push_transform(&mut self, t: Transform) {
-        let next = self.stack.last().copied().unwrap_or(Affine::IDENTITY) * affine(&t);
-        self.stack.push(next);
-    }
-
-    fn pop_transform(&mut self) {
-        if self.stack.len() > 1 {
-            self.stack.pop();
-        }
-    }
-
-    fn push_clip_glyph(&mut self, gid: GlyphId) {
-        let path = self.outline(gid);
-        self.push_clip(&path);
-    }
-
-    fn push_clip_box(&mut self, b: BoundingBox<f32>) {
-        let r = Rect::new(b.x_min as f64, b.y_min as f64, b.x_max as f64, b.y_max as f64);
-        self.push_clip(&kurbo::Shape::to_path(&r, 0.1));
-    }
-
-    fn pop_clip(&mut self) {
-        self.pop();
-    }
-
-    fn fill(&mut self, brush: Brush<'_>) {
-        match brush {
-            Brush::Solid { palette_index, alpha } => {
-                let c = self.color(palette_index, alpha);
-                self.cover(c);
-            }
-            Brush::LinearGradient { p0, p1, color_stops, extend: e } => {
-                let g = peniko::Gradient::new_linear(pt(p0), pt(p1)).with_stops(self.stops(color_stops).as_slice()).with_extend(extend(e));
-                self.cover(g);
-            }
-            Brush::RadialGradient { c0, r0, c1, r1, color_stops, extend: e } => {
-                let g = peniko::Gradient::new_two_point_radial(pt(c0), r0.max(0.0), pt(c1), r1.max(0.0))
-                    .with_stops(self.stops(color_stops).as_slice())
-                    .with_extend(extend(e));
-                self.cover(g);
-            }
-            Brush::SweepGradient { c0, start_angle, end_angle, color_stops, extend: e } => {
-                let g = peniko::Gradient::new_sweep(pt(c0), start_angle.to_radians(), end_angle.to_radians())
-                    .with_stops(self.stops(color_stops).as_slice())
-                    .with_extend(extend(e));
-                self.cover(g);
-            }
-        }
-    }
-
-    fn push_layer(&mut self, mode: CompositeMode) {
-        let open = self.opened.len() < MAX_DEPTH;
-        if open {
-            self.ctx.push_blend_layer(blend(mode));
-        }
-        self.opened.push(open);
-    }
-
-    fn pop_layer(&mut self) {
-        self.pop();
-    }
-}

crates/render/src/compound.rs

@@ -1,242 +0,0 @@
-//! Compound outlines (`a:ln/@cmpd`): double, thick-thin, thin-thick and triple lines.
-//!
-//! PowerPoint splits the line's width into bands across the path, measured from its left side
-//! (looking along the path) to its right, as these shares of the width (read from PowerPoint's
-//! export of 24 pt lines of each kind):
-//! - double: 1/3 line, 1/3 gap, 1/3 line;
-//! - thin-thick: 1/5 line, 1/5 gap, 3/5 line; thick-thin the mirror;
-//! - triple: 1/6 line, 1/6 gap, 1/3 line, 1/6 gap, 1/6 line.
-//!
-//! On a shape drawn clockwise (all presets) the left side is the outside.
-
-use deckcraft_model::style::Compound;
-use kurbo::{BezPath, CubicBez, ParamCurve, PathEl, PathSeg, Point, Vec2};
-
-/// The bands of `c` as (from, to) shares of the width, left side first.
-pub fn bands(c: Compound) -> &'static [(f64, f64)] {
-    match c {
-        Compound::Single => &[(0.0, 1.0)],
-        Compound::Double => &[(0.0, 1.0 / 3.0), (2.0 / 3.0, 1.0)],
-        Compound::ThinThick => &[(0.0, 0.2), (0.4, 1.0)],
-        Compound::ThickThin => &[(0.0, 0.6), (0.8, 1.0)],
-        Compound::Triple => &[(0.0, 1.0 / 6.0), (2.0 / 6.0, 4.0 / 6.0), (5.0 / 6.0, 1.0)],
-    }
-}
-
-/// Unit normal pointing to the right of travel (y down), or None for a zero-length tangent.
-fn right(t: Vec2) -> Option<Vec2> {
-    let l = t.hypot();
-    (l > 1e-12 && l.is_finite()).then(|| Vec2::new(-t.y, t.x) / l)
-}
-
-/// `path` moved `d` to the right of travel (negative: to the left). Line corners meet at their
-/// miter point (bevelled when sharper than about 11°); curves are offset by kurbo; other joins are
-/// bridged by a straight line.
-pub fn offset(path: &BezPath, d: f64, tolerance: f64) -> BezPath {
-    let mut out = BezPath::new();
-    if d.abs() < 1e-9 {
-        return path.clone();
-    }
-    // Each subpath as segments, offset one by one.
-    let mut segs: Vec<PathSeg> = Vec::new();
-    let mut closed = false;
-    let flush = |segs: &mut Vec<PathSeg>, closed: bool, out: &mut BezPath| {
-        let pieces: Vec<(PathSeg, BezPath)> = segs.iter().filter_map(|s| offset_seg(*s, d, tolerance).map(|p| (*s, p))).collect();
-        let begin = out.elements().len();
-        for (i, (seg, piece)) in pieces.iter().enumerate() {
-            let Some(PathEl::MoveTo(p)) = piece.elements().first().copied() else { continue };
-            match i.checked_sub(1).and_then(|j| pieces.get(j)) {
-                None => out.move_to(p),
-                Some((prev, _)) => join(out, *prev, *seg, p, d),
-            }
-            for e in piece.elements().iter().skip(1) {
-                out.push(*e);
-            }
-        }
-        if closed && let (Some((last, _)), Some((first, piece))) = (pieces.last(), pieces.first()) {
-            if let Some(PathEl::MoveTo(p)) = piece.elements().first().copied() {
-                // Lines meeting at the start: both ends move to their miter point.
-                match miter(*last, *first, d) {
-                    Some(m) if is_line(*last) && is_line(*first) => {
-                        set_last(out, m);
-                        if let Some(PathEl::MoveTo(_)) = out.elements().get(begin) {
-                            out.elements_mut()[begin] = PathEl::MoveTo(m);
-                        }
-                    }
-                    _ => out.line_to(p),
-                }
-            }
-            out.close_path();
-        }
-        segs.clear();
-    };
-    let mut start = Point::ZERO;
-    let mut cur = Point::ZERO;
-    for el in path.elements() {
-        match *el {
-            PathEl::MoveTo(p) => {
-                flush(&mut segs, closed, &mut out);
-                closed = false;
-                start = p;
-                cur = p;
-            }
-            PathEl::LineTo(p) => {
-                segs.push(PathSeg::Line(kurbo::Line::new(cur, p)));
-                cur = p;
-            }
-            PathEl::QuadTo(a, b) => {
-                segs.push(PathSeg::Quad(kurbo::QuadBez::new(cur, a, b)));
-                cur = b;
-            }
-            PathEl::CurveTo(a, b, c) => {
-                segs.push(PathSeg::Cubic(CubicBez::new(cur, a, b, c)));
-                cur = c;
-            }
-            PathEl::ClosePath => {
-                if (cur - start).hypot() > 1e-9 {
-                    segs.push(PathSeg::Line(kurbo::Line::new(cur, start)));
-                }
-                closed = true;
-                flush(&mut segs, closed, &mut out);
-                closed = false;
-                cur = start;
-            }
-        }
-    }
-    flush(&mut segs, closed, &mut out);
-    out
-}
-
-fn offset_seg(s: PathSeg, d: f64, tolerance: f64) -> Option<BezPath> {
-    // Far-off or non-finite geometry (hostile files) is left out rather than offset.
-    let sane = |p: Point| p.is_finite() && p.x.abs() < 1e7 && p.y.abs() < 1e7;
-    let ok = match s {
-        PathSeg::Line(l) => sane(l.p0) && sane(l.p1),
-        PathSeg::Quad(q) => sane(q.p0) && sane(q.p1) && sane(q.p2),
-        PathSeg::Cubic(c) => sane(c.p0) && sane(c.p1) && sane(c.p2) && sane(c.p3),
-    };
-    if !ok || !d.is_finite() {
-        return None;
-    }
-    match s {
-        PathSeg::Line(l) => {
-            let n = right(l.p1 - l.p0)?;
-            let mut p = BezPath::new();
-            p.move_to(l.p0 + n * d);
-            p.line_to(l.p1 + n * d);
-            Some(p)
-        }
-        PathSeg::Quad(q) => offset_seg(PathSeg::Cubic(q.raise()), d, tolerance),
-        PathSeg::Cubic(c) => {
-            // Nearly straight cubics (collinear control points) are offset as lines.
-            let chord = c.p3 - c.p0;
-            let flat = |p: Point| chord.cross(p - c.p0).abs() <= 1e-9 * chord.hypot2().max(1e-18);
-            if flat(c.p1) && flat(c.p2) {
-                return offset_seg(PathSeg::Line(kurbo::Line::new(c.p0, c.p3)), d, tolerance);
-            }
-            let mut p = BezPath::new();
-            kurbo::offset::offset_cubic(c, d, tolerance, &mut p);
-            Some(p)
-        }
-    }
-}
-
-/// The segment's tangent at its start and at its end (the first non-zero control vector).
-fn tangents(s: PathSeg) -> (Vec2, Vec2) {
-    let first = |v: &[Vec2]| v.iter().copied().find(|v| v.hypot2() > 1e-18).unwrap_or(Vec2::ZERO);
-    match s {
-        PathSeg::Line(l) => (l.p1 - l.p0, l.p1 - l.p0),
-        PathSeg::Quad(q) => (first(&[q.p1 - q.p0, q.p2 - q.p0]), first(&[q.p2 - q.p1, q.p2 - q.p0])),
-        PathSeg::Cubic(c) => (first(&[c.p1 - c.p0, c.p2 - c.p0, c.p3 - c.p0]), first(&[c.p3 - c.p2, c.p3 - c.p1, c.p3 - c.p0])),
-    }
-}
-
-fn is_line(s: PathSeg) -> bool {
-    matches!(s, PathSeg::Line(_))
-}
-
-/// Move the path's last point to `p`.
-fn set_last(out: &mut BezPath, p: Point) {
-    if let Some(e) = out.elements_mut().last_mut() {
-        match e {
-            PathEl::MoveTo(q) | PathEl::LineTo(q) => *q = p,
-            PathEl::QuadTo(_, q) => *q = p,
-            PathEl::CurveTo(_, _, q) => *q = p,
-            PathEl::ClosePath => {}
-        }
-    }
-}
-
-/// Where the offsets of `prev` and `next` meet at their shared corner (their miter point), or
-/// None for a corner sharper than about 11 degrees or a degenerate tangent.
-fn miter(prev: PathSeg, next: PathSeg, d: f64) -> Option<Point> {
-    let (_, t0) = tangents(prev);
-    let (t1, _) = tangents(next);
-    let (n0, n1) = (right(t0)?, right(t1)?);
-    let denom = 1.0 + n0.dot(n1);
-    (denom > 0.02).then(|| prev.end() + (n0 + n1) * (d / denom)).filter(|m| m.is_finite())
-}
-
-/// Join the offset of `prev` (ending at `out`'s current point) to the offset of `next`, which
-/// starts at `p`: two lines meet at their miter point (both ends moved there, so an inner corner
-/// doesn't loop); anything else is bridged straight.
-fn join(out: &mut BezPath, prev: PathSeg, next: PathSeg, p: Point, d: f64) {
-    match miter(prev, next, d) {
-        Some(m) if is_line(prev) && is_line(next) => set_last(out, m),
-        Some(m) => {
-            out.line_to(m);
-            out.line_to(p);
-        }
-        None => out.line_to(p),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use kurbo::Shape;
-
-    #[test]
-    fn bands_split_the_width_like_powerpoint() {
-        for c in [Compound::Single, Compound::Double, Compound::ThinThick, Compound::ThickThin, Compound::Triple] {
-            let b = bands(c);
-            assert_eq!(b.first().map(|x| x.0), Some(0.0));
-            assert_eq!(b.last().map(|x| x.1), Some(1.0));
-            assert!(b.windows(2).all(|w| w[0].1 < w[1].0), "{c:?}: bands in order with gaps");
-        }
-        // Thin-thick: the thin line on the left, thick-thin its mirror.
-        let (tt, th) = (bands(Compound::ThinThick), bands(Compound::ThickThin));
-        assert!((tt[0].1 - tt[0].0) < (tt[1].1 - tt[1].0));
-        assert!((th[0].1 - th[0].0) > (th[1].1 - th[1].0));
-    }
-
-    #[test]
-    fn offsetting_a_rectangle_grows_or_shrinks_it() {
-        // Clockwise in y-down coordinates: the left of travel is the outside.
-        let r = kurbo::Rect::new(0.0, 0.0, 100.0, 50.0).to_path(0.1);
-        let out = offset(&r, -5.0, 0.01).bounding_box();
-        assert!(
-            (out.x0 + 5.0).abs() < 1e-6 && (out.y0 + 5.0).abs() < 1e-6 && (out.x1 - 105.0).abs() < 1e-6 && (out.y1 - 55.0).abs() < 1e-6,
-            "{out:?}"
-        );
-        let inn = offset(&r, 5.0, 0.01).bounding_box();
-        assert!((inn.x0 - 5.0).abs() < 1e-6 && (inn.y1 - 45.0).abs() < 1e-6, "{inn:?}");
-        // Corners meet at their miter points: the area is the offset rectangle's.
-        assert!((offset(&r, -5.0, 0.01).area().abs() - 110.0 * 60.0).abs() < 1e-6);
-    }
-
-    #[test]
-    fn offsetting_a_circle_changes_its_radius() {
-        let c = kurbo::Circle::new((50.0, 50.0), 20.0).to_path(0.01);
-        let b = offset(&c, 4.0, 0.01).bounding_box();
-        let w = b.width() / 2.0;
-        assert!((w - 16.0).abs() < 0.2 || (w - 24.0).abs() < 0.2, "radius {w}");
-        // A hostile path never panics and yields finite output.
-        let mut p = BezPath::new();
-        p.move_to((0.0, 0.0));
-        p.line_to((0.0, 0.0));
-        p.curve_to((f64::MAX, 0.0), (0.0, f64::MIN_POSITIVE), (1.0, 1.0));
-        p.close_path();
-        let _ = offset(&p, 3.0, 0.01);
-    }
-}

crates/render/src/extent.rs

@@ -1,329 +0,0 @@
-//! The pasteboard: what the editor draws around the slide.
-//!
-//! PowerPoint's Normal view draws shapes, pictures and text that sit partly or wholly off the slide
-//! on the area around it, at full strength and with their effects (master and layout graphics
-//! too), so they can be seen and grabbed. Slide shows, exports and thumbnails clip to the slide.
-//!
-//! The editor renders only what it needs: the slide, grown to take in the drawing that spills off
-//! it and is in view ([`pasteboard_region`]). A slide with nothing off it costs what it always did.
-
-use deckcraft_geom::Xfrm;
-use deckcraft_model::resolve::{self, Ctx};
-use deckcraft_model::style::{Effects, Line};
-use deckcraft_model::{Presentation, Shape, ShapeKind};
-use kurbo::Rect;
-
-use crate::MAX_SIDE;
-
-/// Largest distance (points) a shape's outline or effects are taken to reach beyond its box:
-/// hostile files can't blow the pasteboard up.
-const MAX_SPILL: f64 = 2000.0;
-
-/// The visible area is rounded out to tiles of this many pixels, so scrolling over a pasteboard
-/// that is wider than the window re-renders only when a new tile comes into view.
-pub const TILE: i64 = 256;
-
-/// How far (points) a shape's outline and effects reach beyond its box: half the outline and its
-/// arrowheads, the outer shadow (offset, blur and scale), the glow and the reflection.
-pub(crate) fn spill(line: Option<&Line>, effects: Option<&Effects>, w: f64, h: f64) -> f64 {
-    let fin = |v: f64| if v.is_finite() { v.abs() } else { 0.0 };
-    let mut s: f64 = 0.0;
-    if let Some(l) = line
-        && l.fill.as_ref().is_some_and(|f| !f.is_none())
-    {
-        // Arrowheads reach up to a few line widths past the end point.
-        s = s.max(fin(l.width.unwrap_or(0.75)) * 3.0 + 1.0);
-    }
-    if let Some(e) = effects {
-        let big = fin(w).max(fin(h));
-        if let Some(sh) = &e.outer_shadow {
-            let grow = (fin(sh.sx).max(fin(sh.sy)) - 1.0).max(0.0) * big;
-            s = s.max(fin(sh.dist) + fin(sh.blur) + grow);
-        }
-        if let Some(g) = &e.glow {
-            s = s.max(fin(g.radius));
-        }
-        if let Some(r) = &e.reflection {
-            s = s.max(fin(h) + fin(r.dist));
-        }
-    }
-    s.min(MAX_SPILL)
-}
-
-/// Slide-space box a top-level shape draws into, its spill included.
-fn shape_box(rctx: &Ctx, s: &Shape) -> Option<Rect> {
-    if s.hidden {
-        return None;
-    }
-    let x: Xfrm = resolve::xfrm(rctx, s);
-    if !x.is_finite() {
-        return None;
-    }
-    let b = match &s.kind {
-        ShapeKind::Ink { strokes } => {
-            let mut pts = strokes.iter().flat_map(|k| k.points.iter()).filter(|(px, py, _)| px.is_finite() && py.is_finite());
-            let (px, py, _) = pts.next()?;
-            let r = pts.fold(Rect::new(*px, *py, *px, *py), |r, (px, py, _)| r.union_pt(kurbo::Point::new(*px, *py)));
-            let w = strokes.iter().map(|k| k.width).filter(|w| w.is_finite()).fold(0.0_f64, f64::max).min(MAX_SPILL);
-            return Some(r.inflate(w, w));
-        }
-        _ => x.bounds(),
-    };
-    let (line, _) = resolve::line(rctx, s);
-    let (fx, _) = resolve::effects(rctx, s);
-    let d = spill(Some(&line), fx.as_ref(), x.w, x.h);
-    Some(b.inflate(d, d))
-}
-
-fn union_boxes<'a>(rctx: &Ctx, shapes: impl IntoIterator<Item = &'a Shape>, into: Rect) -> Rect {
-    shapes.into_iter().filter_map(|s| shape_box(rctx, s)).filter(|r| r.is_finite()).fold(into, |a, r| a.union(r))
-}
-
-fn slide_rect(pres: &Presentation) -> Rect {
-    Rect::new(0.0, 0.0, pres.slide_size.width, pres.slide_size.height)
-}
-
-/// What slide `index` draws, in slide space: at least the slide, grown by every shape (and master
-/// and layout graphic) that reaches off it. Estimated from the shapes' boxes, outlines and effects;
-/// text spilling out of its box is found while rendering ([`crate::render_slide_drawn`]).
-pub fn slide_extent(pres: &Presentation, index: usize) -> Rect {
-    let page = slide_rect(pres);
-    let Some(slide) = pres.slides.get(index) else { return page };
-    let Some(rctx) = Ctx::for_slide(pres, slide) else { return page };
-    let mut r = union_boxes(&rctx, &slide.shapes, page);
-    let (show_layout, show_master) = resolve::show_master_shapes(slide, rctx.layout);
-    if show_master {
-        let mctx = Ctx::for_master(pres, rctx.master);
-        r = union_boxes(&mctx, rctx.master.shapes.iter().filter(|s| s.ph.is_none()), r);
-    }
-    if show_layout && let Some(l) = rctx.layout {
-        let lctx = Ctx::for_layout(pres, rctx.master, l);
-        r = union_boxes(&lctx, l.shapes.iter().filter(|s| s.ph.is_none()), r);
-    }
-    r
-}
-
-/// What a layout (or the master, `layout: None`) draws in Slide Master view, in slide space.
-pub fn layout_extent(pres: &Presentation, master: usize, layout: Option<usize>) -> Rect {
-    let page = slide_rect(pres);
-    let Some(m) = pres.masters.get(master) else { return page };
-    match layout.and_then(|i| m.layouts.get(i)) {
-        Some(l) => {
-            let mut r = union_boxes(&Ctx::for_layout(pres, m, l), &l.shapes, page);
-            if l.show_master_shapes {
-                r = union_boxes(&Ctx::for_master(pres, m), m.shapes.iter().filter(|s| s.ph.is_none()), r);
-            }
-            r
-        }
-        None => union_boxes(&Ctx::for_master(pres, m), &m.shapes, page),
-    }
-}
-
-/// A rectangle of pixels on the editor canvas, relative to the slide's top-left corner.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
-pub struct Region {
-    pub x: i32,
-    pub y: i32,
-    pub w: u32,
-    pub h: u32,
-}
-
-impl Region {
-    /// The slide itself, `w` × `h` pixels.
-    pub fn slide(w: u32, h: u32) -> Self {
-        Region { x: 0, y: 0, w: w.max(1), h: h.max(1) }
-    }
-
-    fn edges(&self) -> (i64, i64, i64, i64) {
-        let (x, y) = (self.x as i64, self.y as i64);
-        (x, y, x + self.w as i64, y + self.h as i64)
-    }
-
-    fn from_edges(x0: i64, y0: i64, x1: i64, y1: i64) -> Self {
-        let clamp = |v: i64| v.clamp(i32::MIN as i64, i32::MAX as i64) as i32;
-        let side = |a: i64, b: i64| (b - a).clamp(1, MAX_SIDE as i64) as u32;
-        Region { x: clamp(x0), y: clamp(y0), w: side(x0, x1), h: side(y0, y1) }
-    }
-
-    /// Does this region cover all of `other`?
-    pub fn contains(&self, other: &Region) -> bool {
-        let (a, b) = (self.edges(), other.edges());
-        a.0 <= b.0 && a.1 <= b.1 && a.2 >= b.2 && a.3 >= b.3
-    }
-
-    /// Is the region more than the slide (some of the pasteboard is drawn)?
-    pub fn beyond(&self, slide: (u32, u32)) -> bool {
-        *self != Region::slide(slide.0, slide.1)
-    }
-
-    /// Render options' `offset` that puts the slide's top-left corner where it falls in the region.
-    pub fn offset(&self) -> (f64, f64) {
-        (-(self.x as f64), -(self.y as f64))
-    }
-
-    /// The region's size, for render options' `size`.
-    pub fn size(&self) -> (u32, u32) {
-        (self.w, self.h)
-    }
-}
-
-/// `r` (slide space) in pixels at `scale` pixels per point, rounded outwards; `None` when not finite.
-fn to_px(r: Rect, scale: f64) -> Option<(i64, i64, i64, i64)> {
-    let lim = i32::MAX as f64 / 2.0;
-    let px = |v: f64| if v.is_finite() { Some(v.clamp(-lim, lim)) } else { None };
-    Some((
-        px((r.x0 * scale).floor())? as i64,
-        px((r.y0 * scale).floor())? as i64,
-        px((r.x1 * scale).ceil())? as i64,
-        px((r.y1 * scale).ceil())? as i64,
-    ))
-}
-
-/// The pixels the editor renders: the slide (`slide_px`, its size in pixels at `scale` pixels per
-/// point) plus the part of `extent` (slide space, from [`slide_extent`] or what a render drew) that
-/// falls within `visible`, the canvas's area relative to the slide's top-left corner. The visible
-/// area is rounded out to whole [`TILE`]s.
-pub fn pasteboard_region(slide_px: (u32, u32), scale: f64, extent: Rect, visible: Region) -> Region {
-    let page = Region::slide(slide_px.0, slide_px.1);
-    if !(scale.is_finite() && scale > 0.0) {
-        return page;
-    }
-    let Some((ex0, ey0, ex1, ey1)) = to_px(extent, scale) else { return page };
-    let (vx0, vy0, vx1, vy1) = visible.edges();
-    let (vx0, vy0) = (vx0.div_euclid(TILE) * TILE, vy0.div_euclid(TILE) * TILE);
-    let (vx1, vy1) = ((vx1 + TILE - 1).div_euclid(TILE) * TILE, (vy1 + TILE - 1).div_euclid(TILE) * TILE);
-    let (cx0, cy0, cx1, cy1) = (ex0.max(vx0), ey0.max(vy0), ex1.min(vx1), ey1.min(vy1));
-    if cx0 >= cx1 || cy0 >= cy1 {
-        return page;
-    }
-    let (px0, py0, px1, py1) = page.edges();
-    Region::from_edges(cx0.min(px0), cy0.min(py0), cx1.max(px1), cy1.max(py1))
-}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::unwrap_used, clippy::expect_used)]
-
-    use super::*;
-    use deckcraft_model::Shape;
-
-    fn black() -> deckcraft_model::ColorRef {
-        deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::BLACK)
-    }
-
-    fn deck_with(x: f64, y: f64, w: f64, h: f64) -> Presentation {
-        let mut p = Presentation::default();
-        let sl = std::sync::Arc::make_mut(&mut p.slides[0]);
-        sl.shapes.push(Shape { id: deckcraft_model::ShapeId(900), xfrm: Some(Xfrm::new(x, y, w, h)), ..Default::default() });
-        p
-    }
-
-    #[test]
-    fn a_slide_with_nothing_off_it_extends_no_further_than_the_slide() {
-        let p = deck_with(100.0, 100.0, 50.0, 50.0);
-        assert_eq!(slide_extent(&p, 0), Rect::new(0.0, 0.0, p.slide_size.width, p.slide_size.height));
-    }
-
-    #[test]
-    fn shapes_off_the_slide_grow_the_extent() {
-        let p = deck_with(-200.0, 50.0, 100.0, 80.0);
-        let e = slide_extent(&p, 0);
-        assert!(e.x0 <= -200.0 && e.x0 > -220.0, "{e:?}");
-        assert_eq!(e.y0, 0.0);
-        assert_eq!(e.x1, p.slide_size.width);
-        // Missing slides are just the page.
-        assert_eq!(slide_extent(&p, 7), Rect::new(0.0, 0.0, p.slide_size.width, p.slide_size.height));
-    }
-
-    #[test]
-    fn hidden_shapes_and_hostile_boxes_do_not_grow_it() {
-        let mut p = deck_with(-5000.0, 0.0, 10.0, 10.0);
-        std::sync::Arc::make_mut(&mut p.slides[0]).shapes.last_mut().unwrap().hidden = true;
-        let page = Rect::new(0.0, 0.0, p.slide_size.width, p.slide_size.height);
-        assert_eq!(slide_extent(&p, 0), page);
-        let p = deck_with(f64::NAN, 0.0, 10.0, 10.0);
-        assert_eq!(slide_extent(&p, 0), page);
-        let p = deck_with(f64::INFINITY, 0.0, 10.0, 10.0);
-        assert_eq!(slide_extent(&p, 0), page);
-    }
-
-    #[test]
-    fn effects_count_towards_the_extent() {
-        let mut p = deck_with(10.0, -100.0, 100.0, 50.0);
-        let sh = std::sync::Arc::make_mut(&mut p.slides[0]).shapes.last_mut().unwrap();
-        sh.effects = Some(Effects {
-            outer_shadow: Some(deckcraft_model::style::Shadow {
-                color: black(),
-                blur: 10.0,
-                dist: 20.0,
-                dir: 270.0,
-                inner: false,
-                sx: 1.0,
-                sy: 1.0,
-                kx: 0.0,
-                ky: 0.0,
-                align: String::new(),
-                rotate_with_shape: false,
-            }),
-            ..Default::default()
-        });
-        assert!(slide_extent(&p, 0).y0 <= -130.0);
-        assert_eq!(
-            spill(
-                None,
-                Some(&Effects { glow: Some(deckcraft_model::style::Glow { color: black(), radius: f64::MAX }), ..Default::default() }),
-                1.0,
-                1.0
-            ),
-            MAX_SPILL
-        );
-    }
-
-    #[test]
-    fn master_graphics_off_the_slide_count_but_not_master_placeholders() {
-        let mut p = Presentation::default();
-        let m = std::sync::Arc::make_mut(&mut p.masters[0]);
-        m.shapes.push(Shape { id: deckcraft_model::ShapeId(901), xfrm: Some(Xfrm::new(-150.0, 10.0, 100.0, 50.0)), ..Default::default() });
-        assert!(slide_extent(&p, 0).x0 <= -150.0);
-        assert!(layout_extent(&p, 0, None).x0 <= -150.0);
-        assert!(layout_extent(&p, 0, Some(0)).x0 <= -150.0 || !p.masters[0].layouts[0].show_master_shapes);
-    }
-
-    #[test]
-    fn the_region_is_the_slide_unless_something_off_it_is_in_view() {
-        let slide = (960, 540);
-        let page = Region::slide(960, 540);
-        let view = Region { x: -100, y: -50, w: 1160, h: 640 };
-        let whole = Rect::new(0.0, 0.0, 960.0, 540.0);
-        assert_eq!(pasteboard_region(slide, 1.0, whole, view), page);
-        assert!(!pasteboard_region(slide, 1.0, whole, view).beyond(slide));
-        // Off to the left, in view: the region reaches it.
-        let r = pasteboard_region(slide, 1.0, Rect::new(-80.0, 0.0, 960.0, 540.0), view);
-        assert_eq!((r.x, r.y, r.w, r.h), (-80, 0, 1040, 540));
-        assert!(r.beyond(slide) && r.contains(&page));
-        assert_eq!(r.offset(), (80.0, 0.0));
-        // Far off and out of view (the view rounds out to tiles): only what's visible.
-        let r = pasteboard_region(slide, 1.0, Rect::new(-5000.0, 0.0, 960.0, 540.0), view);
-        assert_eq!(r.x, -256);
-        // Wholly out of view: the slide.
-        assert_eq!(pasteboard_region(slide, 1.0, Rect::new(-5000.0, 0.0, -4000.0, 540.0).union(whole), Region { x: 0, y: 0, w: 960, h: 540 }), page);
-        // Scale applies; nonsense falls back to the slide.
-        let r = pasteboard_region((480, 270), 0.5, Rect::new(-80.0, 0.0, 960.0, 540.0), view);
-        assert_eq!(r.x, -40);
-        assert_eq!(pasteboard_region(slide, f64::NAN, whole, view), page);
-        assert_eq!(pasteboard_region(slide, 1.0, Rect::new(f64::NAN, 0.0, 1.0, 1.0), view), page);
-        // Huge extents are capped.
-        let r =
-            pasteboard_region(slide, 1.0, Rect::new(-1e12, -1e12, 1e12, 1e12), Region { x: -1_000_000, y: -1_000_000, w: 2_000_000, h: 2_000_000 });
-        assert!(r.w <= MAX_SIDE && r.h <= MAX_SIDE);
-    }
-
-    #[test]
-    fn scrolling_within_a_tile_keeps_the_region() {
-        let slide = (2000, 1125);
-        let e = Rect::new(-500.0, 0.0, 960.0, 540.0);
-        let a = pasteboard_region(slide, 2.0, e, Region { x: -300, y: 0, w: 1000, h: 700 });
-        let b = pasteboard_region(slide, 2.0, e, Region { x: -290, y: 10, w: 1000, h: 700 });
-        assert_eq!(a, b);
-    }
-}

crates/render/src/images.rs

@@ -66,55 +66,27 @@ fn with<R>(f: impl FnOnce(&mut Cache) -> R) -> R {
 }
 
 fn adjust_key(a: &PictureAdjust) -> u64 {
-    use std::hash::Hasher;
-    // A real hash: an FNV-style xor-multiply mix let (b, c) and (-b, -c) collide (the sign bits
-    // cancel), so a picture brightened and contrasted showed the darkened copy's pixels.
-    let mut hs = std::hash::DefaultHasher::new();
-    let mut mix = |v: u64| hs.write_u64(v);
+    let mut h: u64 = 1469598103934665603;
+    let mut mix = |v: u64| {
+        h ^= v;
+        h = h.wrapping_mul(1099511628211);
+    };
     mix(a.brightness.to_bits());
     mix(a.contrast.to_bits());
     mix(a.saturation.unwrap_or(1.0).to_bits());
     mix(a.grayscale as u64);
-    mix(a.bilevel.map_or(u64::MAX, f64::to_bits));
-    mix(a.alpha_inv as u64);
     mix(a.sharpen.to_bits());
     if let Some(c) = a.clear_color {
         mix(((c.r as u64) << 16) | ((c.g as u64) << 8) | c.b as u64 | 1 << 40);
     }
-    if let Some((d, l)) = duotone_rgb(a) {
-        for c in [d, l] {
-            mix(((c.r as u64) << 24) | ((c.g as u64) << 16) | ((c.b as u64) << 8) | c.a as u64 | 1 << 41);
-        }
-    }
-    hs.finish()
+    h
 }
 
-/// The duotone's dark and light colours. The painter resolves them to plain RGB first (see
-/// `paint::resolved`); a colour that is still a scheme reference falls back to black and white.
-fn duotone_rgb(a: &PictureAdjust) -> Option<(deckcraft_color::Rgba, deckcraft_color::Rgba)> {
-    use deckcraft_model::style::ColorBase;
-    let (d, l) = a.duotone.as_ref()?;
-    let rgb = |c: &deckcraft_model::style::ColorRef, or: deckcraft_color::Rgba| match &c.base {
-        ColorBase::Rgb { rgb } if c.mods.is_empty() => *rgb,
-        _ => or,
-    };
-    Some((rgb(d, deckcraft_color::Rgba::BLACK), rgb(l, deckcraft_color::Rgba::WHITE)))
-}
-
-/// Decode encoded bytes (PNG, JPEG, GIF, WebP, BMP, TIFF; WMF and EMF drawn at
-/// [`crate::metafile::DEFAULT_SIDE`]) to straight RGBA.
+/// Decode encoded bytes (PNG, JPEG, GIF, WebP, BMP, TIFF) to straight RGBA.
 pub fn decode(bytes: &[u8]) -> Option<image::RgbaImage> {
-    decode_at(bytes, crate::metafile::DEFAULT_SIDE)
-}
-
-/// [`decode`], with a metafile drawn with its longer side `side` px.
-fn decode_at(bytes: &[u8], side: u32) -> Option<image::RgbaImage> {
     if bytes.len() > 512 << 20 {
         return None;
     }
-    if crate::metafile::is_metafile(bytes) {
-        return crate::metafile::rasterize(bytes, side);
-    }
     let img = image::load_from_memory(bytes).ok()?;
     let (w, h) = (img.width(), img.height());
     if w == 0 || h == 0 || (w as u64) * (h as u64) > 400_000_000 {
@@ -123,56 +95,6 @@ fn decode_at(bytes: &[u8], side: u32) -> Option<image::RgbaImage> {
     Some(img.to_rgba8())
 }
 
-/// A raster picture's own size in 96-dpi pixels (so 0.75 pt each), read from its header: its
-/// pixel size, scaled by the resolution it records (PNG `pHYs`, JPEG JFIF density) when that
-/// isn't 96 dpi, as PowerPoint sizes pictures. `None` for metafiles and anything unreadable.
-pub fn natural_size(bytes: &[u8]) -> Option<(f64, f64)> {
-    if crate::metafile::is_metafile(bytes) {
-        return None;
-    }
-    let (w, h) = image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format().ok()?.into_dimensions().ok()?;
-    if w == 0 || h == 0 {
-        return None;
-    }
-    let (dx, dy) = dpi(bytes).unwrap_or((96.0, 96.0));
-    Some((w as f64 * 96.0 / dx, h as f64 * 96.0 / dy))
-}
-
-/// The resolution (whole dots per inch across and down) a PNG or JPEG records, when it records
-/// one in a plausible range.
-pub fn dpi(bytes: &[u8]) -> Option<(f64, f64)> {
-    // Whole dots per inch: PNGs store dots per metre, so 96 dpi reads as 95.9866.
-    let ok = |d: f64| (d.is_finite() && (10.0..=10000.0).contains(&d)).then_some(d.round());
-    let be32 = |b: &[u8], i: usize| b.get(i..i + 4).map(|s| u32::from_be_bytes([s[0], s[1], s[2], s[3]]));
-    let be16 = |b: &[u8], i: usize| b.get(i..i + 2).map(|s| u16::from_be_bytes([s[0], s[1]]));
-    if bytes.starts_with(b"\x89PNG\r\n\x1a\n") {
-        let mut i = 8usize;
-        for _ in 0..64 {
-            let len = be32(bytes, i)? as usize;
-            let kind = bytes.get(i + 4..i + 8)?;
-            if kind == b"pHYs" {
-                let (x, y, unit) = (be32(bytes, i + 8)?, be32(bytes, i + 12)?, *bytes.get(i + 16)?);
-                return if unit == 1 { Some((ok(x as f64 * 0.0254)?, ok(y as f64 * 0.0254)?)) } else { None };
-            }
-            if kind == b"IDAT" || kind == b"IEND" {
-                return None;
-            }
-            i = i.checked_add(12)?.checked_add(len)?;
-        }
-        return None;
-    }
-    if bytes.starts_with(&[0xFF, 0xD8]) && bytes.get(6..11) == Some(b"JFIF\0".as_slice()) {
-        let unit = *bytes.get(13)?;
-        let (x, y) = (be16(bytes, 14)? as f64, be16(bytes, 16)? as f64);
-        return match unit {
-            1 => Some((ok(x)?, ok(y)?)),
-            2 => Some((ok(x * 2.54)?, ok(y * 2.54)?)),
-            _ => None,
-        };
-    }
-    None
-}
-
 /// A premultiplied pixmap of the picture, downsampled so its longer side is near `want` px.
 pub fn decode_for(bytes: &Arc<Vec<u8>>, want: f64, adj: &PictureAdjust) -> Option<Arc<Pixmap>> {
     let addr = Arc::as_ptr(bytes) as usize;
@@ -192,13 +114,13 @@ pub fn decode_for(bytes: &Arc<Vec<u8>>, want: f64, adj: &PictureAdjust) -> Optio
     }) {
         return Some(pm);
     }
-    let target = 1u32 << bucket;
-    let Some(mut img) = decode_at(bytes, target) else {
+    let Some(mut img) = decode(bytes) else {
         with(|c| {
             c.bad.insert(addr, bytes.clone());
         });
         return None;
     };
+    let target = 1u32 << bucket;
     let (w, h) = img.dimensions();
     if w.max(h) > target.max(16) && w.max(h) > 4096.min(target * 2) {
         let k = target as f64 / w.max(h) as f64;
@@ -308,18 +230,9 @@ pub(crate) fn gif_pixmap(bytes: &Arc<Vec<u8>>, adj: &PictureAdjust, t: f64) -> O
 
 fn apply_adjust(img: &mut image::RgbaImage, a: &PictureAdjust) {
     let sat = a.saturation.unwrap_or(1.0);
-    if a.brightness == 0.0
-        && a.contrast == 0.0
-        && sat == 1.0
-        && !a.grayscale
-        && a.clear_color.is_none()
-        && a.duotone.is_none()
-        && a.bilevel.is_none()
-        && !a.alpha_inv
-    {
+    if a.brightness == 0.0 && a.contrast == 0.0 && sat == 1.0 && !a.grayscale && a.clear_color.is_none() && a.duotone.is_none() {
         return;
     }
-    let duo = duotone_rgb(a);
     let b = a.brightness.clamp(-1.0, 1.0) * 255.0;
     let c = a.contrast.clamp(-1.0, 1.0);
     let cf = if c >= 0.0 { 1.0 / (1.0 - c * 0.99) } else { 1.0 + c };
@@ -333,120 +246,26 @@ fn apply_adjust(img: &mut image::RgbaImage, a: &PictureAdjust) {
             continue;
         }
         let mut rgb = [p[0] as f64, p[1] as f64, p[2] as f64];
-        let y = luma(rgb);
+        let y = 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2];
         let s = if a.grayscale { 0.0 } else { sat };
         for v in &mut rgb {
             *v = y + (*v - y) * s;
-            // Measured on PowerPoint's export of grey ramps: contrast scales about mid-grey by
-            // `cf`, and brightness adds b · 255 scaled by (1 + cf) / 2 (half of it is applied
-            // before the contrast stretch, half after): +40% bright, +40% contrast maps 0 to 54.
-            *v = (*v - 127.5) * cf + 127.5 + b * (1.0 + cf) / 2.0;
-        }
-        // Duotone: the pixel's luminance picks a colour between the dark and the light one.
-        if let Some((d, l)) = duo {
-            let t = (luma(rgb) / 255.0).clamp(0.0, 1.0);
-            rgb =
-                [d.r as f64 + (l.r as f64 - d.r as f64) * t, d.g as f64 + (l.g as f64 - d.g as f64) * t, d.b as f64 + (l.b as f64 - d.b as f64) * t];
-        }
-        // Black and white: white where the luminance reaches the threshold.
-        if let Some(t) = a.bilevel {
-            let v = if luma(rgb) >= t * 255.0 { 255.0 } else { 0.0 };
-            rgb = [v; 3];
+            *v = (*v - 128.0) * cf + 128.0 + b;
         }
         for (i, v) in rgb.iter().enumerate() {
             if let Some(ch) = p.0.get_mut(i) {
                 *ch = v.round().clamp(0.0, 255.0) as u8;
             }
         }
-        if a.alpha_inv {
-            p[3] = 255 - p[3];
-        }
     }
 }
 
-/// Luminance as PowerPoint weighs it for grayscale, black-and-white and duotone pictures
-/// (measured: Rec. 709 weights on the stored values; pure red greys to 54, green to 182).
-fn luma(rgb: [f64; 3]) -> f64 {
-    0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]
-}
-
 #[cfg(test)]
 mod tests {
     #![allow(clippy::expect_used)]
 
     use super::*;
 
-    #[test]
-    fn duotone_maps_luminance_between_its_two_colours() {
-        use deckcraft_color::Rgba;
-        use deckcraft_model::style::ColorRef;
-        let mut img = image::RgbaImage::from_fn(3, 1, |x, _| image::Rgba([[0, 0, 0, 255], [128, 128, 128, 200], [255, 255, 255, 255]][x as usize]));
-        let adj =
-            PictureAdjust { duotone: Some((ColorRef::rgb(Rgba::rgb(100, 40, 0)), ColorRef::rgb(Rgba::rgb(250, 240, 200)))), ..Default::default() };
-        apply_adjust(&mut img, &adj);
-        assert_eq!(img.get_pixel(0, 0).0, [100, 40, 0, 255], "black takes the dark colour");
-        assert_eq!(img.get_pixel(2, 0).0, [250, 240, 200, 255], "white takes the light colour");
-        let mid = img.get_pixel(1, 0).0;
-        assert!((mid[0] as i32 - 175).abs() <= 1 && (mid[1] as i32 - 140).abs() <= 1 && (mid[2] as i32 - 100).abs() <= 1, "{mid:?}");
-        assert_eq!(mid[3], 200, "alpha is kept");
-        // Different duotones are cached separately.
-        let other = PictureAdjust { duotone: Some((ColorRef::rgb(Rgba::rgb(0, 0, 0)), ColorRef::rgb(Rgba::rgb(255, 0, 0)))), ..Default::default() };
-        assert_ne!(adjust_key(&adj), adjust_key(&other));
-        assert_ne!(adjust_key(&adj), adjust_key(&PictureAdjust::default()));
-    }
-
-    #[test]
-    fn brightness_and_contrast_map_greys_like_powerpoint() {
-        // Grey levels PowerPoint's export gives for inputs 0, 32, 64, 96 (and 128, 160).
-        let run = |b: f64, c: f64, input: &[u8]| -> Vec<u8> {
-            let mut img = image::RgbaImage::from_fn(input.len() as u32, 1, |x, _| {
-                let v = input[x as usize];
-                image::Rgba([v, v, v, 255])
-            });
-            apply_adjust(&mut img, &PictureAdjust { brightness: b, contrast: c, ..Default::default() });
-            img.pixels().map(|p| p[0]).collect()
-        };
-        let near = |got: Vec<u8>, want: &[u8]| got.iter().zip(want).all(|(g, w)| (*g as i32 - *w as i32).abs() <= 5);
-        assert!(near(run(0.4, 0.4, &[0, 32, 64, 96]), &[54, 105, 157, 210]), "{:?}", run(0.4, 0.4, &[0, 32, 64, 96]));
-        assert!(near(run(0.4, -0.4, &[0, 32, 64, 96]), &[133, 152, 171, 190]));
-        assert!(near(run(-0.4, 0.4, &[128, 160, 192]), &[0, 45, 97]));
-        assert!(near(run(0.0, -0.8, &[0, 128, 255]), &[102, 127, 152]));
-    }
-
-    #[test]
-    fn grayscale_black_and_white_and_inverted_alpha_like_powerpoint() {
-        let swatches = [[255u8, 0, 0], [0, 255, 0], [0, 0, 255], [200, 100, 50], [60, 160, 110], [120, 120, 130]];
-        let run = |adj: PictureAdjust| -> Vec<[u8; 4]> {
-            let mut img = image::RgbaImage::from_fn(swatches.len() as u32, 1, |x, _| {
-                let c = swatches[x as usize];
-                image::Rgba([c[0], c[1], c[2], 200])
-            });
-            apply_adjust(&mut img, &adj);
-            img.pixels().map(|p| p.0).collect()
-        };
-        // PowerPoint's export of these swatches in grayscale: 54, 182, 18, 117, 135, 120.
-        let g = run(PictureAdjust { grayscale: true, ..Default::default() });
-        for (got, want) in g.iter().zip([54u8, 182, 18, 117, 135, 120]) {
-            assert!((got[0] as i32 - want as i32).abs() <= 1 && got[0] == got[1] && got[1] == got[2], "{got:?} vs {want}");
-        }
-        // Black and white at 50%: only green and the light green reach mid-grey.
-        let bw: Vec<u8> = run(PictureAdjust { bilevel: Some(0.5), ..Default::default() }).iter().map(|p| p[0]).collect();
-        assert_eq!(bw, [0, 255, 0, 0, 255, 0]);
-        // Inverted alpha: 200 becomes 55.
-        assert!(run(PictureAdjust { alpha_inv: true, ..Default::default() }).iter().all(|p| p[3] == 55));
-    }
-
-    #[test]
-    fn opposite_brightness_and_contrast_are_cached_apart() {
-        let a = PictureAdjust { brightness: 0.4, contrast: 0.4, ..Default::default() };
-        let b = PictureAdjust { brightness: -0.4, contrast: -0.4, ..Default::default() };
-        assert_ne!(adjust_key(&a), adjust_key(&b));
-        let c = PictureAdjust { brightness: 0.4, contrast: -0.4, ..Default::default() };
-        let d = PictureAdjust { brightness: -0.4, contrast: 0.4, ..Default::default() };
-        assert_ne!(adjust_key(&c), adjust_key(&d));
-        assert_eq!(adjust_key(&a), adjust_key(&a.clone()));
-    }
-
     #[test]
     fn a_gif_of_many_tiny_frames_keeps_only_the_frame_cap() {
         use image::{Delay, Frame, Rgba, RgbaImage};

crates/render/src/metafile.rs

@@ -1,360 +0,0 @@
-//! Windows Metafile and Enhanced Metafile pictures (`image/x-wmf`, `image/x-emf`): parsed by
-//! `deckcraft-metafile` and drawn as vectors into a bitmap of the size the slide needs, so they go
-//! through the same crop, tile and recolour path as any other picture.
-//!
-//! Text items name the font the file asks for; they are drawn with the face slide text would use
-//! for that family (`FontDb::document_face`, so a missing font falls back the same way), symbol
-//! fonts mapped as bullets map them, and the file's own advances (the dx array) placing each
-//! character.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use deckcraft_fonts::{FontDb, FontFace};
-use deckcraft_metafile::{HAlign, Item, PlacedItem, Text, Tile, VAlign};
-use kurbo::{Affine, BezPath, Rect, Shape as _};
-use skrifa::MetadataProvider as _;
-use vello_cpu::{Pixmap, RenderContext, Resources, peniko};
-
-/// Longest side of a metafile drawn without a target size (export, thumbnails of the picture).
-pub const DEFAULT_SIDE: u32 = 1024;
-/// Largest side drawn.
-const MAX_SIDE: u32 = 8192;
-/// Pattern cells smaller than this (output pixels) are drawn as the tile's average colour: a
-/// sub-pixel pattern would only alias.
-const MIN_CELL_PX: f64 = 1.5;
-/// Size of text whose font gives no height (LOGFONT height 0), in text units.
-const DEFAULT_EM: f64 = 12.0;
-
-/// Is `bytes` a WMF or EMF file?
-pub fn is_metafile(bytes: &[u8]) -> bool {
-    deckcraft_metafile::is_metafile(bytes)
-}
-
-/// Draw the metafile `bytes` into straight RGBA with its longer side `side` px (transparent where
-/// it draws nothing). `None` when it doesn't parse or has no size.
-pub fn rasterize(bytes: &[u8], side: u32) -> Option<image::RgbaImage> {
-    let mut pic = deckcraft_metafile::parse(bytes).ok()?;
-    if !pic.has_size() {
-        return None;
-    }
-    let side = side.clamp(16, MAX_SIDE) as f64;
-    let (pw, ph) = (pic.width as f64, pic.height as f64);
-    let k = side / pw.max(ph);
-    let w = (pw * k).round().clamp(1.0, MAX_SIDE as f64) as u16;
-    let h = (ph * k).round().clamp(1.0, MAX_SIDE as f64) as u16;
-    let pixmaps: Vec<Option<Arc<Pixmap>>> = pic.items.iter_mut().map(|it| it.take_pixels().and_then(|(w, h, px)| premul(w, h, &px))).collect();
-    // Pattern tiles shared by several fills are converted once.
-    let mut tiles: HashMap<*const Tile, (Option<Arc<Pixmap>>, peniko::Color)> = HashMap::new();
-    let mut ctx = RenderContext::new_with(w, h, vello_cpu::RenderSettings { num_threads: 0, ..Default::default() });
-    let r = Rect::new(0.0, 0.0, w as f64, h as f64);
-    ctx.push_clip_layer(&r.to_path(0.1));
-    for it in pic.place(r, [0.0; 4]) {
-        match it {
-            PlacedItem::Path { path, fill, stroke, even_odd } => {
-                if let Some(f) = fill {
-                    ctx.set_paint(rgba(f));
-                    ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
-                    ctx.fill_path(&path);
-                }
-                // GDI pens: round caps and joins; a cosmetic (zero-width) pen is one pixel.
-                if let Some((s, sw)) = stroke {
-                    ctx.set_paint(rgba(s));
-                    ctx.set_stroke(kurbo::Stroke::new(sw.max(1.0)).with_caps(kurbo::Cap::Round).with_join(kurbo::Join::Round));
-                    ctx.stroke_path(&path);
-                }
-            }
-            PlacedItem::Bitmap { index, rect } => {
-                let Some(Some(pm)) = pixmaps.get(index) else { continue };
-                let (bw, bh) = (pm.width().max(1) as f64, pm.height().max(1) as f64);
-                ctx.set_paint(vello_cpu::Image {
-                    image: vello_cpu::ImageSource::Pixmap(pm.clone()),
-                    sampler: peniko::ImageSampler::default().with_quality(peniko::ImageQuality::Medium),
-                });
-                ctx.set_paint_transform(Affine::translate((rect.x0, rect.y0)) * Affine::scale_non_uniform(rect.width() / bw, rect.height() / bh));
-                ctx.fill_rect(&rect);
-                ctx.reset_paint_transform();
-            }
-            PlacedItem::Pattern { index, path, even_odd, tile } => {
-                let Some(Item::Pattern { tile: t, .. }) = pic.items.get(index) else { continue };
-                let key = Arc::as_ptr(t);
-                let (pm, avg) = tiles.entry(key).or_insert_with(|| (premul(t.width, t.height, &t.rgba), average(&t.rgba))).clone();
-                ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
-                let cell = tile.determinant().abs().sqrt();
-                match pm {
-                    Some(pm) if cell >= MIN_CELL_PX => {
-                        ctx.set_paint(vello_cpu::Image {
-                            image: vello_cpu::ImageSource::Pixmap(pm),
-                            sampler: peniko::ImageSampler {
-                                x_extend: peniko::Extend::Repeat,
-                                y_extend: peniko::Extend::Repeat,
-                                quality: peniko::ImageQuality::Low,
-                                alpha: 1.0,
-                            },
-                        });
-                        ctx.set_paint_transform(tile);
-                        ctx.fill_path(&path);
-                        ctx.reset_paint_transform();
-                    }
-                    _ => {
-                        ctx.set_paint(avg);
-                        ctx.fill_path(&path);
-                    }
-                }
-            }
-            PlacedItem::Text { index, transform, clip } => {
-                let Some(Item::Text(t)) = pic.items.get(index) else { continue };
-                if let Some(c) = clip {
-                    ctx.push_clip_layer(&c.to_path(0.1));
-                }
-                draw_text(&mut ctx, t, transform);
-                if clip.is_some() {
-                    ctx.pop_layer();
-                }
-            }
-        }
-    }
-    ctx.set_fill_rule(peniko::Fill::NonZero);
-    ctx.pop_layer();
-    ctx.flush();
-    let mut px = vec![0u8; w as usize * h as usize * 4];
-    if let Some(pm) = vello_cpu::PixmapMut::new(w, h, &mut px) {
-        ctx.render(pm, &mut Resources::new());
-    }
-    // Premultiplied to straight.
-    for p in px.as_chunks_mut::<4>().0 {
-        let a = p[3] as u32;
-        if a != 0 && a != 255 {
-            for c in p.iter_mut().take(3) {
-                *c = ((*c as u32 * 255 + a / 2) / a).min(255) as u8;
-            }
-        }
-    }
-    image::RgbaImage::from_raw(w as u32, h as u32, px)
-}
-
-/// One glyph placed in text space (x along the baseline from the string's start, font units at
-/// `scale` text units each).
-struct Glyph {
-    face: Arc<FontFace>,
-    gid: u32,
-    x: f64,
-    y: f64,
-}
-
-/// Draws a text item; `m` maps its text space to the output.
-fn draw_text(ctx: &mut RenderContext, t: &Text, m: Affine) {
-    let db = FontDb::global();
-    let font = &t.font;
-    let family = if font.family.trim().is_empty() { "Arial" } else { font.family.trim() };
-    let (bold, italic) = (font.weight >= 600, font.italic);
-    let style = match (bold, italic) {
-        (true, true) => "Bold Italic",
-        (true, false) => "Bold",
-        (false, true) => "Italic",
-        (false, false) => "Regular",
-    };
-    let face = db.document_face(family, style);
-    let upem = face.upem.max(1.0);
-    let (asc, desc) = win_metrics(&face);
-    // LOGFONT height: negative is the em, positive the cell (ascent plus descent).
-    let h = f64::from(font.height);
-    let em = if h < 0.0 {
-        -h
-    } else if h > 0.0 {
-        h * upem / (asc + desc).max(1.0)
-    } else {
-        DEFAULT_EM
-    };
-    let k = em / upem;
-    if !k.is_finite() || k <= 0.0 {
-        return;
-    }
-    // Characters as drawn: symbol fonts (Wingdings…) map like bullets; each character takes the
-    // face that has it.
-    let chars: Vec<char> = t.text.chars().map(|c| deckcraft_text::symbol_char(&face, family, c).unwrap_or(c)).collect();
-    let faces: Vec<Arc<FontFace>> = chars
-        .iter()
-        .map(|c| {
-            if c.is_whitespace() || c.is_control() || face.covers(*c) { face.clone() } else { db.cascade(&[*c], std::slice::from_ref(&face), style) }
-        })
-        .collect();
-    // Shape runs of one face; record each glyph's pen position and its character.
-    let mut shaped: Vec<(Glyph, usize)> = Vec::with_capacity(chars.len());
-    let mut char_pen: Vec<f64> = vec![0.0; chars.len() + 1];
-    let mut pen = 0.0;
-    let mut i = 0;
-    while i < chars.len() {
-        let Some(f) = faces.get(i).cloned() else { break };
-        let mut j = i + 1;
-        while faces.get(j).is_some_and(|g| g.id() == f.id()) {
-            j += 1;
-        }
-        let run: String = chars.get(i..j).unwrap_or(&[]).iter().collect();
-        // Byte offset in the run → character index in the string.
-        let byte_char: Vec<usize> = run.char_indices().map(|(b, _)| b).collect();
-        let ku = f.upem.max(1.0);
-        for g in deckcraft_fonts::shape(&f, &run, &[], |c| c) {
-            let ci = i + byte_char.partition_point(|b| *b < g.cluster).min(j - i - 1);
-            let s = em / ku;
-            shaped.push((Glyph { face: f.clone(), gid: g.gid, x: pen + f64::from(g.x_offset) * s, y: -f64::from(g.y_offset) * s }, ci));
-            pen += f64::from(g.x_advance) * s;
-            if let Some(p) = char_pen.get_mut(ci + 1) {
-                *p = pen;
-            }
-        }
-        i = j;
-    }
-    // Character start pens: a character's start is the previous one's end.
-    for ci in 1..char_pen.len() {
-        let prev = char_pen.get(ci - 1).copied().unwrap_or(0.0);
-        if let Some(p) = char_pen.get_mut(ci)
-            && *p < prev
-        {
-            *p = prev;
-        }
-    }
-    // The file's advances place each character; glyphs keep their offset within their character.
-    let use_dx = !t.dx.is_empty() && t.dx.len() == chars.len();
-    let mut width = pen;
-    let mut x_scale = 1.0;
-    if use_dx {
-        let mut starts = Vec::with_capacity(chars.len() + 1);
-        let mut x = 0.0;
-        for d in &t.dx {
-            starts.push(x);
-            x += f64::from(*d);
-        }
-        width = x;
-        for (g, ci) in &mut shaped {
-            let (start, pen_start) = (starts.get(*ci).copied().unwrap_or(0.0), char_pen.get(*ci).copied().unwrap_or(0.0));
-            g.x = start + (g.x - pen_start);
-        }
-    } else if font.width > 0.0 {
-        // A LOGFONT width narrows or widens the font against its average character width.
-        let avg = avg_char_width(&face) * k;
-        if avg > 0.0 {
-            x_scale = (f64::from(font.width) / avg).clamp(0.05, 20.0);
-            width *= x_scale;
-            for (g, _) in &mut shaped {
-                g.x *= x_scale;
-            }
-        }
-    }
-    let x0 = match t.h_align {
-        HAlign::Left => 0.0,
-        HAlign::Center => -width / 2.0,
-        HAlign::Right => -width,
-    };
-    let (a, d) = (asc * k, desc * k);
-    let base = match t.v_align {
-        VAlign::Baseline => 0.0,
-        VAlign::Top => a,
-        VAlign::Bottom => -d,
-    };
-    let at = m * Affine::translate((x0, base));
-    ctx.set_fill_rule(peniko::Fill::NonZero);
-    if let Some(bg) = t.background
-        && width > 0.0
-    {
-        ctx.set_paint(rgba(bg));
-        ctx.fill_path(&(at * Rect::new(0.0, -a, width, d).to_path(0.1)));
-    }
-    let color = rgba(t.color);
-    ctx.set_paint(color);
-    for (g, _) in &shaped {
-        let path = db.outline(&g.face, g.gid);
-        if path.elements().is_empty() {
-            continue;
-        }
-        let s = em / g.face.upem.max(1.0);
-        let skew = if italic && !g.face.italic { Affine::new([1.0, 0.0, -0.2, 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
-        let gm = at * Affine::translate((g.x, g.y)) * Affine::scale_non_uniform(x_scale, 1.0) * skew * Affine::scale(s);
-        let p: BezPath = gm * path.as_ref().clone();
-        ctx.fill_path(&p);
-        if bold && g.face.weight < 600.0 {
-            ctx.set_stroke(kurbo::Stroke::new(em * 0.025 * scale_of(at)).with_join(kurbo::Join::Round));
-            ctx.stroke_path(&p);
-        }
-    }
-    // Underline and strike-out: the font's own positions and thickness.
-    let metrics = face.skrifa().map(|f| f.metrics(skrifa::instance::Size::unscaled(), face.location()));
-    let deco = |on: bool, d: Option<skrifa::metrics::Decoration>, fallback: (f64, f64)| -> Option<Rect> {
-        if !on || width <= 0.0 {
-            return None;
-        }
-        let (off, th) = d.map_or(fallback, |d| (f64::from(d.offset) * k, f64::from(d.thickness) * k));
-        let th = if th > 0.0 { th } else { em / 20.0 };
-        // Offsets are y-up from the baseline; text space is y-down.
-        Some(Rect::new(0.0, -off - th / 2.0, width, -off + th / 2.0))
-    };
-    let lines = [
-        deco(font.underline, metrics.as_ref().and_then(|m| m.underline), (-em * 0.1, em / 20.0)),
-        deco(font.strike, metrics.as_ref().and_then(|m| m.strikeout), (em * 0.26, em / 20.0)),
-    ];
-    for r in lines.into_iter().flatten() {
-        ctx.fill_path(&(at * r.to_path(0.1)));
-    }
-}
-
-/// Mean scale of an affine transform's linear part.
-fn scale_of(m: Affine) -> f64 {
-    m.determinant().abs().sqrt()
-}
-
-/// The face's Windows ascent and descent (OS/2 `usWinAscent`/`usWinDescent`, as GDI measures the
-/// cell), in font units; the typographic ones when the font has no OS/2 table.
-fn win_metrics(face: &FontFace) -> (f64, f64) {
-    use skrifa::raw::TableProvider as _;
-    let os2 = face.skrifa().and_then(|f| f.os2().ok()).map(|o| (f64::from(o.us_win_ascent()), f64::from(o.us_win_descent())));
-    match os2 {
-        Some((a, d)) if a + d > 0.0 => (a, d),
-        _ => (face.ascent.max(0.0), face.descent.max(0.0)),
-    }
-}
-
-/// OS/2 `xAvgCharWidth` in font units (half an em without it).
-fn avg_char_width(face: &FontFace) -> f64 {
-    use skrifa::raw::TableProvider as _;
-    face.skrifa().and_then(|f| f.os2().ok()).map(|o| f64::from(o.x_avg_char_width())).filter(|w| *w > 0.0).unwrap_or(face.upem * 0.5)
-}
-
-fn rgba(c: [u8; 4]) -> peniko::Color {
-    peniko::Color::from_rgba8(c[0], c[1], c[2], c[3])
-}
-
-/// The average colour of straight RGBA pixels (alpha-weighted).
-fn average(px: &[u8]) -> peniko::Color {
-    let (mut r, mut g, mut b, mut a, mut n) = (0u64, 0u64, 0u64, 0u64, 0u64);
-    for p in px.as_chunks::<4>().0 {
-        let w = u64::from(p[3]);
-        r += u64::from(p[0]) * w;
-        g += u64::from(p[1]) * w;
-        b += u64::from(p[2]) * w;
-        a += w;
-        n += 1;
-    }
-    if a == 0 || n == 0 {
-        return peniko::Color::from_rgba8(0, 0, 0, 0);
-    }
-    peniko::Color::from_rgba8((r / a) as u8, (g / a) as u8, (b / a) as u8, (a / n) as u8)
-}
-
-/// Straight RGBA rows to a premultiplied pixmap.
-fn premul(w: u32, h: u32, px: &[u8]) -> Option<Arc<Pixmap>> {
-    if w == 0 || h == 0 || w > u16::MAX as u32 || h > u16::MAX as u32 || px.len() < w as usize * h as usize * 4 {
-        return None;
-    }
-    let data = px
-        .as_chunks::<4>()
-        .0
-        .iter()
-        .take(w as usize * h as usize)
-        .map(|p| {
-            let a = p[3] as u16;
-            let m = |c: u8| ((c as u16 * a + 127) / 255) as u8;
-            vello_cpu::color::PremulRgba8 { r: m(p[0]), g: m(p[1]), b: m(p[2]), a: p[3] }
-        })
-        .collect();
-    Some(Arc::new(Pixmap::from_parts(data, w as u16, h as u16)))
-}

crates/render/src/morph_text.rs

@@ -219,7 +219,7 @@ pub(crate) fn draw(
         for d in &l.decos {
             ctx.set_transform(place);
             ctx.set_paint(color(d.color, alpha));
-            crate::fill_deco(ctx, d);
+            ctx.fill_rect(&d.rect);
         }
     }
 }

crates/render/src/paint.rs

@@ -3,7 +3,7 @@
 use deckcraft_color::Rgba;
 use deckcraft_geom::preset::FillMode;
 use deckcraft_model::resolve::Ctx;
-use deckcraft_model::style::{ColorRef, Fill, GradientShape, PictureFill, PictureMode};
+use deckcraft_model::style::{Fill, GradientShape, PictureFill, PictureMode};
 use deckcraft_model::{PhType, Presentation};
 use kurbo::{Affine, BezPath, Point, Rect, Shape as _};
 use vello_cpu::{RenderContext, peniko};
@@ -35,150 +35,90 @@ pub fn fill_path(
             if g.stops.is_empty() {
                 return;
             }
-            // `rotWithShape="0"`: the gradient keeps to the slide's axes when the shape is
-            // rotated or flipped, laid out over the box the shape covers on the slide.
-            let c = m.as_coeffs();
-            let turned = c[1].abs() > 1e-9 || c[2].abs() > 1e-9 || c[0] < 0.0 || c[3] < 0.0;
-            let path_kind = matches!(&g.shape, GradientShape::Path { path: k, .. } if matches!(k.as_str(), "rect" | "shape"));
-            if !g.rotate_with_shape && turned && !path_kind && m.determinant().abs() > 1e-12 {
-                let on_slide = m.transform_rect_bbox(bounds);
-                let upright = deckcraft_model::style::Gradient { rotate_with_shape: true, ..g.clone() };
-                let paint_path = m * path.clone();
-                fill_path(ctx, rctx, &Fill::Gradient(upright), ph, &paint_path, on_slide, Affine::IDENTITY, mode, alpha, pres);
-                return;
-            }
-            // A linear gradient spans its tile rectangle (the shape's box unless `tileRect` moves
-            // its edges); a radial one ends on the circle around it, from a focus placed in the
-            // shape's own box (PowerPoint's "from corner" presets centre the tile on the corner).
-            let tile = tile_box(bounds, g.tile);
-            let stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos, shade(rctx.color(&s.color, ph), mode))).collect();
-            ctx.set_paint(gradient(&g.shape, stops, bounds, alpha));
-
-            let mut stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0), shade(rctx.color(&s.color, ph), mode))).collect();
+            let mut stops: Vec<(f32, peniko::Color)> =
+                g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0) as f32, color(shade(rctx.color(&s.color, ph), mode), alpha))).collect();
             stops.sort_by(|a, b| a.0.total_cmp(&b.0));
-            // Rectangle and outline paths: rasterised (see `pathgrad`).
-            if let GradientShape::Path { path: kind, focus } = &g.shape
-                && matches!(kind.as_str(), "rect" | "shape")
-            {
-                crate::pathgrad::fill(ctx, kind, *focus, &crate::ramp::expand(&stops), bounds, path, m, alpha);
-                return;
-            }
-            // PowerPoint's ramp between stops (linear light, S-shaped), see `ramp`.
-            let stops: Vec<peniko::ColorStop> =
-                crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
+            let stops: Vec<peniko::ColorStop> = stops.into_iter().map(|(o, c)| peniko::ColorStop { offset: o, color: c.into() }).collect();
             let grad = match &g.shape {
                 GradientShape::Linear { angle, .. } => {
                     // Angle measured clockwise from left→right; span the bounds along that direction.
                     let a = angle.to_radians();
                     let (dx, dy) = (a.cos(), a.sin());
-                    let c = tile.center();
-                    let half = (tile.width() * dx.abs() + tile.height() * dy.abs()) / 2.0;
+                    let c = bounds.center();
+                    let half = (bounds.width() * dx.abs() + bounds.height() * dy.abs()) / 2.0;
                     peniko::Gradient::new_linear(Point::new(c.x - dx * half, c.y - dy * half), Point::new(c.x + dx * half, c.y + dy * half))
                         .with_stops(stops.as_slice())
                 }
-                GradientShape::Path { focus, .. } => circle_gradient(*focus, bounds, tile).with_stops(stops.as_slice()),
+                GradientShape::Path { focus, .. } => {
+                    let fx = bounds.x0 + bounds.width() * (focus[0] + (1.0 - focus[2])) / 2.0;
+                    let fy = bounds.y0 + bounds.height() * (focus[1] + (1.0 - focus[3])) / 2.0;
+                    // Reach the farthest corner, so a gradient from a corner covers the whole box.
+                    let r = [(bounds.x0, bounds.y0), (bounds.x1, bounds.y0), (bounds.x0, bounds.y1), (bounds.x1, bounds.y1)]
+                        .iter()
+                        .map(|(x, y)| ((x - fx).powi(2) + (y - fy).powi(2)).sqrt())
+                        .fold(1e-6, f64::max);
+                    peniko::Gradient::new_radial(Point::new(fx, fy), r as f32).with_stops(stops.as_slice())
+                }
             };
             ctx.set_paint(grad);
             ctx.fill_path(path);
         }
         Fill::Picture(pf) => {
-            // `rotWithShape="0"`: upright on the slide, stretched over the box the turned shape
-            // covers, clipped to it.
-            let c = m.as_coeffs();
-            let turned = c[1].abs() > 1e-9 || c[2].abs() > 1e-9 || c[0] < 0.0 || c[3] < 0.0;
-            if pf.upright && turned && m.determinant().abs() > 1e-12 {
-                let on_slide = m.transform_rect_bbox(bounds);
-                let on_path = m * path.clone();
-                ctx.set_transform(Affine::IDENTITY);
-                ctx.push_clip_layer(&on_path);
-                picture(ctx, pres, &resolved(rctx, pf, ph), on_slide, Affine::IDENTITY, None);
-                ctx.pop_layer();
-                return;
-            }
             ctx.push_clip_layer(path);
-            picture(ctx, pres, &resolved(rctx, pf, ph), bounds, m, None);
+            picture(ctx, pres, pf, bounds, m, None);
             ctx.pop_layer();
         }
         Fill::Pattern(p) => {
             let fg = rctx.color(&p.fg, ph);
             let bg = rctx.color(&p.bg, ph);
-            crate::pattern::fill(ctx, &p.preset, fg, bg, alpha, path, m);
+            ctx.set_paint(color(bg, alpha));
+            ctx.fill_path(path);
+            ctx.push_clip_layer(path);
+            ctx.set_paint(color(fg, alpha));
+            pattern(ctx, &p.preset, bounds, m);
+            ctx.pop_layer();
         }
     }
 }
 
-/// `pf` with its duotone colours resolved to plain RGB against the slide's colours and the
-/// placeholder colour `ph` (theme background pictures recolour with `phClr`), so the decoded-image
-/// cache can apply and key them without a colour scheme.
-pub fn resolved<'a>(rctx: &Ctx, pf: &'a PictureFill, ph: Option<Rgba>) -> std::borrow::Cow<'a, PictureFill> {
-    let Some((d, l)) = &pf.adjust.duotone else { return std::borrow::Cow::Borrowed(pf) };
-    let mut out = pf.clone();
-    out.adjust.duotone = Some((ColorRef::rgb(rctx.color(d, ph)), ColorRef::rgb(rctx.color(l, ph))));
-    std::borrow::Cow::Owned(out)
-}
-
-/// `bounds` with its edges moved in by `tile` (left, top, right, bottom insets as fractions of its
-/// size; negative moves them out), as `a:tileRect` and `a:fillRect` lay out a fill.
-pub fn tile_box(bounds: Rect, tile: [f64; 4]) -> Rect {
-    if tile.iter().all(|v| *v == 0.0) || tile.iter().any(|v| !v.is_finite()) {
-        return bounds;
-    }
-    let (w, h) = (bounds.width(), bounds.height());
-    let [l, t, r, b] = tile;
-    let x0 = bounds.x0 + l * w;
-    let x1 = bounds.x1 - r * w;
-    let y0 = bounds.y0 + t * h;
-    let y1 = bounds.y1 - b * h;
-    // An inverted tile (insets past each other) lays out nothing sensible: keep the box.
-    if x1 - x0 <= 1e-9 || y1 - y0 <= 1e-9 { bounds } else { Rect::new(x0, y0, x1, y1) }
-}
-
-/// The paint of a gradient of `shape` with `stops` (position, colour) spanning `bounds`, faded
-/// by `alpha`, ramping between stops as PowerPoint does (see `ramp`).
-pub fn gradient(shape: &GradientShape, mut stops: Vec<(f64, Rgba)>, bounds: Rect, alpha: f64) -> peniko::Gradient {
-    for s in &mut stops {
-        s.0 = s.0.clamp(0.0, 1.0);
-    }
-    stops.sort_by(|a, b| a.0.total_cmp(&b.0));
-    let stops: Vec<peniko::ColorStop> =
-        crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
-    match shape {
-        GradientShape::Linear { angle, .. } => {
-            // Angle measured clockwise from left→right; span the bounds along that direction.
-            let a = angle.to_radians();
-            let (dx, dy) = (a.cos(), a.sin());
-            let c = bounds.center();
-            let half = (bounds.width() * dx.abs() + bounds.height() * dy.abs()) / 2.0;
-            peniko::Gradient::new_linear(Point::new(c.x - dx * half, c.y - dy * half), Point::new(c.x + dx * half, c.y + dy * half))
-                .with_stops(stops.as_slice())
+/// Draw a pattern's foreground marks over `bounds` (8 pt cells).
+fn pattern(ctx: &mut RenderContext, preset: &str, b: Rect, m: Affine) {
+    let k = crate::scale_of(m);
+    let cell = 6.0 / if k.is_finite() { k.clamp(0.25, 4.0) } else { 1.0 };
+    let cell = cell.max(2.0);
+    let mut p = BezPath::new();
+    let (nx, ny) = (((b.width() / cell).ceil() as i64).clamp(0, 2000), ((b.height() / cell).ceil() as i64).clamp(0, 2000));
+    let lw = cell * 0.18;
+    let dense = preset.starts_with("dk") || preset.contains("50") || preset.contains("75") || preset.contains("90");
+    for j in 0..=ny {
+        for i in 0..=nx {
+            let x = b.x0 + i as f64 * cell;
+            let y = b.y0 + j as f64 * cell;
+            let r = match preset {
+                p if p.contains("Horz") || p == "horz" || p.contains("horzBrick") => Rect::new(x, y, x + cell, y + lw),
+                p if p.contains("Vert") || p == "vert" => Rect::new(x, y, x + lw, y + cell),
+                p if p.contains("cross") || p.contains("Grid") || p.contains("grid") => {
+                    p_add(&mut p_rect(x, y, cell, lw), &mut BezPath::new());
+                    Rect::new(x, y, x + cell, y + lw).union(Rect::new(x, y, x + lw, y + cell))
+                }
+                _ => {
+                    let d = if dense { cell * 0.35 } else { cell * 0.2 };
+                    Rect::new(x, y, x + d, y + d)
+                }
+            };
+            p.extend(r.to_path(0.1).iter());
+            if preset.contains("cross") || preset.contains("Grid") || preset.contains("grid") {
+                p.extend(Rect::new(x, y, x + lw, y + cell).to_path(0.1).iter());
+            }
         }
-        GradientShape::Path { focus, .. } => circle_gradient(*focus, bounds, bounds).with_stops(stops.as_slice()),
     }
+    ctx.fill_path(&p);
 }
 
-/// A `circle` path gradient over `bounds` with focus rectangle `focus` (`fillToRect` insets, as
-/// fractions). As PowerPoint draws it (fitted to its exports): the first stop is a point at the
-/// focus (the middle of the focus rectangle) and the last is the circle around the whole box (its
-/// centre, half its diagonal), with circles in between moving from one to the other. A focus off
-/// the centre so bunches the colours on its near side; a gradient "from a corner" reaches its
-/// last colour at that corner too, not only at the far one.
-///
-/// With a tile rectangle (`tile`, otherwise `bounds` itself) the end circle is the one around
-/// the tile, while the focus stays placed in `bounds`.
-pub fn circle_gradient(focus: [f64; 4], bounds: Rect, tile: Rect) -> peniko::Gradient {
-    let fx = bounds.x0 + bounds.width() * (focus[0] + (1.0 - focus[2])) / 2.0;
-    let fy = bounds.y0 + bounds.height() * (focus[1] + (1.0 - focus[3])) / 2.0;
-    let c = tile.center();
-    let r = (tile.width().hypot(tile.height()) / 2.0).max(1e-6);
-    let f = Point::new(fx, fy);
-    if !(f.is_finite() && c.is_finite() && r.is_finite()) {
-        return peniko::Gradient::new_radial(c, r as f32);
-    }
-    // A focus on or outside the end circle has no circle through it: keep it just inside.
-    let d = f - c;
-    let f = if d.hypot() > r * 0.999 { c + d * (r * 0.999 / d.hypot()) } else { f };
-    peniko::Gradient::new_two_point_radial(f, 0.0, c, r as f32)
+fn p_rect(x: f64, y: f64, w: f64, h: f64) -> BezPath {
+    Rect::new(x, y, x + w, y + h).to_path(0.1)
 }
+fn p_add(_a: &mut BezPath, _b: &mut BezPath) {}
 
 /// Draw a picture fill into `bounds` (shape-local) honouring crop and stretch/tile modes; an animated
 /// GIF shows its frame at `gif_time` seconds.
@@ -216,67 +156,24 @@ pub fn picture(ctx: &mut RenderContext, pres: &Presentation, pf: &PictureFill, b
         image: vello_cpu::ImageSource::Pixmap(pm.clone()),
         sampler: peniko::ImageSampler { quality: peniko::ImageQuality::High, ..Default::default() },
     };
-    if let PictureMode::Tile { sx, sy, tx, ty, flip, align } = &pf.mode {
-        // The tile's size: the picture's own size (96 dpi) scaled. A scale of zero or less draws
-        // nothing, as in PowerPoint.
-        if !(*sx > 0.0 && *sy > 0.0 && sx.is_finite() && sy.is_finite()) {
-            return;
-        }
-        let (nw, nh) = images::natural_size(&item.data).unwrap_or((iw, ih));
-        // PowerPoint draws the tile at a whole number of output pixels.
-        let k = px_scale.max(1e-9);
-        let snap = |v: f64| (v * k).round().max(1.0) / k;
-        let (tile_w, tile_h) = (snap(nw * 0.75 * sx), snap(nh * 0.75 * sy));
-        if !(tile_w > 1e-6 && tile_h > 1e-6 && tile_w.is_finite() && tile_h.is_finite()) {
-            return;
-        }
-        let o = tile_origin(bounds, align, (tile_w, tile_h), (*tx, *ty));
-        // Every other tile is mirrored across the flip axes: a reflected repeat.
-        let ext = |mirror: bool| if mirror { peniko::Extend::Reflect } else { peniko::Extend::Repeat };
-        let tiled = vello_cpu::Image {
-            image: vello_cpu::ImageSource::Pixmap(pm.clone()),
-            sampler: peniko::ImageSampler {
-                x_extend: ext(matches!(flip.as_str(), "x" | "xy")),
-                y_extend: ext(matches!(flip.as_str(), "y" | "xy")),
-                quality: peniko::ImageQuality::High,
-                alpha: 1.0,
-            },
-        };
-        ctx.set_transform(m);
-        if alpha < 0.999 {
-            ctx.push_layer(None, None, Some(alpha as f32), None, None);
-        }
-        ctx.set_paint(tiled);
-        ctx.set_paint_transform(Affine::translate(o.to_vec2()) * Affine::scale_non_uniform(tile_w / iw, tile_h / ih));
-        ctx.fill_rect(&bounds);
-        ctx.reset_paint_transform();
-        if alpha < 0.999 {
-            ctx.pop_layer();
+    if let PictureMode::Tile { sx, sy, tx, ty, .. } = &pf.mode {
+        let (sx, sy) = (if *sx > 0.0 { *sx } else { 1.0 }, if *sy > 0.0 { *sy } else { 1.0 });
+        let tile_w = iw * 0.75 * sx;
+        let tile_h = ih * 0.75 * sy;
+        let nx = ((bounds.width() / tile_w.max(1.0)).ceil() as i64).clamp(0, 200);
+        let ny = ((bounds.height() / tile_h.max(1.0)).ceil() as i64).clamp(0, 200);
+        for j in -1..=ny {
+            for i in -1..=nx {
+                let r = Rect::new(bounds.x0 + tx + i as f64 * tile_w, bounds.y0 + ty + j as f64 * tile_h, 0.0, 0.0);
+                let r = Rect::new(r.x0, r.y0, r.x0 + tile_w, r.y0 + tile_h);
+                draw_image(ctx, &image, iw, ih, r, m, alpha);
+            }
         }
         return;
     }
     draw_image(ctx, &image, iw, ih, dest, m, alpha);
 }
 
-/// Where the first tile of a tiled picture fill goes in `bounds`: its corner, edge middle or
-/// centre named by `align` (`tl`, `t`, `tr`, `l`, `ctr`, `r`, `bl`, `b`, `br`) on the same point
-/// of the box, then moved by the offset (points).
-pub fn tile_origin(bounds: Rect, align: &str, tile: (f64, f64), offset: (f64, f64)) -> Point {
-    let (ax, ay) = match align {
-        "t" => (0.5, 0.0),
-        "tr" => (1.0, 0.0),
-        "l" => (0.0, 0.5),
-        "ctr" => (0.5, 0.5),
-        "r" => (1.0, 0.5),
-        "bl" => (0.0, 1.0),
-        "b" => (0.5, 1.0),
-        "br" => (1.0, 1.0),
-        _ => (0.0, 0.0),
-    };
-    let (ox, oy) = (if offset.0.is_finite() { offset.0 } else { 0.0 }, if offset.1.is_finite() { offset.1 } else { 0.0 });
-    Point::new(bounds.x0 + ax * (bounds.width() - tile.0) + ox, bounds.y0 + ay * (bounds.height() - tile.1) + oy)
-}
-
 fn draw_image(ctx: &mut RenderContext, image: &vello_cpu::Image, iw: f64, ih: f64, dest: Rect, m: Affine, alpha: f64) {
     let t = m * Affine::translate(dest.origin().to_vec2()) * Affine::scale_non_uniform(dest.width() / iw, dest.height() / ih);
     ctx.set_transform(t);

crates/render/src/pathgrad.rs

@@ -1,265 +0,0 @@
-//! Path gradients (`a:path`) that follow a rectangle or the shape's own outline, which no vello
-//! gradient draws: they're rasterised into a small image of the bounds and painted with it.
-//!
-//! Measured on PowerPoint's export (black to grey to white from the centre):
-//! - `rect`: the colour position is the larger of the horizontal and vertical distances from the
-//!   focus, each as a share of the distance to that side's edge (X-shaped contours);
-//! - `shape`: contours are the outline scaled about the focus (an ellipse gives ellipses, a
-//!   triangle triangles): the share of the way from the focus to the outline along the same ray.
-//!
-//! `circle` stays a radial vello gradient (see `paint::gradient`).
-
-use std::sync::Arc;
-
-use deckcraft_color::Rgba;
-use kurbo::{Affine, BezPath, PathEl, Point, Rect};
-use vello_cpu::{Pixmap, RenderContext, peniko};
-
-/// Longest side of the rasterised gradient, in pixels (bilinear sampling smooths the rest).
-const MAX_SIDE: f64 = 384.0;
-
-/// Colour position (0 at the focus, 1 at the edge) of `p` for path `kind` in `bounds` with the
-/// focus rect `focus` (fractions inset from left, top, right, bottom), `outline` being the
-/// shape's flattened polygon(s) for `shape`.
-pub fn position(kind: &str, bounds: Rect, focus: [f64; 4], outline: &[Vec<Point>], p: Point) -> f64 {
-    let f = Rect::new(
-        bounds.x0 + bounds.width() * focus[0].clamp(0.0, 1.0),
-        bounds.y0 + bounds.height() * focus[1].clamp(0.0, 1.0),
-        bounds.x1 - bounds.width() * focus[2].clamp(0.0, 1.0),
-        bounds.y1 - bounds.height() * focus[3].clamp(0.0, 1.0),
-    );
-    let f = if f.x0 <= f.x1 && f.y0 <= f.y1 { f } else { Rect::from_center_size(f.center(), (0.0, 0.0)) };
-    match kind {
-        "shape" if !outline.is_empty() => {
-            // A focus rectangle (not a point) is the first colour throughout, as PowerPoint draws
-            // it; outside, the colour runs from the rectangle's edge to the outline along the ray
-            // from its centre.
-            if f.width() > 1e-9 && f.height() > 1e-9 {
-                if f.contains(p) {
-                    return 0.0;
-                }
-                let c = f.center();
-                let to_outline = shape_position(outline, c, p);
-                let d = (p - c).hypot();
-                if to_outline <= 0.0 || d <= 0.0 {
-                    return 1.0;
-                }
-                // Where the ray leaves the focus rectangle, as a share of the way to `p`.
-                let v = p - c;
-                let kx = if v.x.abs() > 1e-12 { (f.width() / 2.0) / v.x.abs() } else { f64::INFINITY };
-                let ky = if v.y.abs() > 1e-12 { (f.height() / 2.0) / v.y.abs() } else { f64::INFINITY };
-                let rect_share = kx.min(ky).min(1.0);
-                // p is `to_outline` of the way to the outline; the rectangle edge `rect_share` of
-                // the way to p.
-                let outline_share = 1.0 / to_outline; // outline distance in units of |p - c|
-                return ((1.0 - rect_share) / (outline_share - rect_share).max(1e-9)).clamp(0.0, 1.0);
-            }
-            shape_position(outline, f.center(), p)
-        }
-        _ => {
-            // Distance outside the focus rect along each axis, over the room to that side's edge.
-            let axis = |v: f64, lo: f64, hi: f64, edge_lo: f64, edge_hi: f64| {
-                if v < lo {
-                    (lo - v) / (lo - edge_lo).max(1e-9)
-                } else if v > hi {
-                    (v - hi) / (edge_hi - hi).max(1e-9)
-                } else {
-                    0.0
-                }
-            };
-            axis(p.x, f.x0, f.x1, bounds.x0, bounds.x1).max(axis(p.y, f.y0, f.y1, bounds.y0, bounds.y1)).clamp(0.0, 1.0)
-        }
-    }
-}
-
-/// The share of the way from `c` to the outline along the ray through `p` (1 when the ray meets
-/// no edge).
-fn shape_position(outline: &[Vec<Point>], c: Point, p: Point) -> f64 {
-    let d = p - c;
-    let len = d.hypot();
-    if len < 1e-9 {
-        return 0.0;
-    }
-    // The outline scaled about `c` by t reaches `p` first (smallest t) where the ray's farthest
-    // crossing does: the only crossing for a focus inside a convex outline, and the one that
-    // still works for a focus off the shape (a corner of an ellipse's box).
-    let mut best = f64::INFINITY;
-    for poly in outline {
-        for w in poly.windows(2) {
-            let (a, b) = (w[0], w[1]);
-            let e = b - a;
-            let den = d.cross(e);
-            if den.abs() < 1e-12 {
-                continue;
-            }
-            let ac = a - c;
-            let s = ac.cross(e) / den;
-            let u = ac.cross(d) / den;
-            if s > 1e-9 && (-1e-9..=1.0 + 1e-9).contains(&u) {
-                best = if best.is_finite() { best.max(s) } else { s };
-            }
-        }
-    }
-    if best.is_finite() { (1.0 / best).clamp(0.0, 1.0) } else { 1.0 }
-}
-
-/// The outline flattened into closed polygons.
-pub fn polygons(path: &BezPath) -> Vec<Vec<Point>> {
-    let mut out: Vec<Vec<Point>> = Vec::new();
-    let mut cur: Vec<Point> = Vec::new();
-    kurbo::flatten(path.iter(), 0.25, |el| match el {
-        PathEl::MoveTo(p) => {
-            if cur.len() > 1 {
-                out.push(std::mem::take(&mut cur));
-            }
-            cur = vec![p];
-        }
-        PathEl::LineTo(p) => cur.push(p),
-        PathEl::ClosePath => {
-            if let Some(f) = cur.first().copied() {
-                cur.push(f);
-            }
-        }
-        _ => {}
-    });
-    if cur.len() > 1 {
-        out.push(cur);
-    }
-    for poly in &mut out {
-        if let (Some(f), Some(l)) = (poly.first().copied(), poly.last().copied())
-            && (f - l).hypot() > 1e-9
-        {
-            poly.push(f);
-        }
-    }
-    out.retain(|p| p.len() > 2 && p.len() < 100_000);
-    out
-}
-
-/// A 256-entry colour ramp for the sorted, already expanded `stops` (linear in sRGB between them).
-pub fn ramp(stops: &[(f64, Rgba)]) -> Vec<Rgba> {
-    (0..256)
-        .map(|i| {
-            let t = i as f64 / 255.0;
-            let after = stops.iter().position(|s| s.0 >= t);
-            match after {
-                Some(0) | None => stops.get(after.unwrap_or(stops.len().saturating_sub(1))).map(|s| s.1).unwrap_or(Rgba::BLACK),
-                Some(j) => {
-                    let (Some(a), Some(b)) = (stops.get(j - 1), stops.get(j)) else { return Rgba::BLACK };
-                    let k = if b.0 - a.0 > 1e-12 { (t - a.0) / (b.0 - a.0) } else { 1.0 };
-                    a.1.lerp(b.1, k)
-                }
-            }
-        })
-        .collect()
-}
-
-/// Fill `path` with a `rect` or `shape` path gradient of `stops` (sorted and expanded, see
-/// `ramp::expand`) over `bounds`, faded by `alpha`; `m` maps the path to the output.
-#[allow(clippy::too_many_arguments)]
-pub fn fill(ctx: &mut RenderContext, kind: &str, focus: [f64; 4], stops: &[(f64, Rgba)], bounds: Rect, path: &BezPath, m: Affine, alpha: f64) {
-    if bounds.width() <= 0.0 || bounds.height() <= 0.0 || !bounds.is_finite() || stops.is_empty() {
-        return;
-    }
-    let k = crate::scale_of(m);
-    let k = if k.is_finite() && k > 0.0 { k } else { 1.0 };
-    let longest = bounds.width().max(bounds.height()) * k;
-    let s = (MAX_SIDE / longest).min(1.0) * k;
-    let (pw, ph) = (((bounds.width() * s).ceil() as u32).clamp(1, 4096), ((bounds.height() * s).ceil() as u32).clamp(1, 4096));
-    let outline = if kind == "shape" { polygons(path) } else { Vec::new() };
-    let lut = ramp(stops);
-    let a = alpha.clamp(0.0, 1.0);
-    let mut data = Vec::with_capacity((pw * ph) as usize);
-    for j in 0..ph {
-        for i in 0..pw {
-            let p = Point::new(bounds.x0 + (i as f64 + 0.5) / pw as f64 * bounds.width(), bounds.y0 + (j as f64 + 0.5) / ph as f64 * bounds.height());
-            let t = position(kind, bounds, focus, &outline, p);
-            let c = lut.get((t * 255.0).round().clamp(0.0, 255.0) as usize).copied().unwrap_or(Rgba::BLACK);
-            let ca = (c.a as f64 * a).round().clamp(0.0, 255.0);
-            let mul = |v: u8| (v as f64 * ca / 255.0).round().clamp(0.0, 255.0) as u8;
-            data.push(vello_cpu::color::PremulRgba8 { r: mul(c.r), g: mul(c.g), b: mul(c.b), a: ca as u8 });
-        }
-    }
-    let pm = Arc::new(Pixmap::from_parts(data, pw as u16, ph as u16));
-    ctx.set_transform(m);
-    ctx.set_paint(vello_cpu::Image {
-        image: vello_cpu::ImageSource::Pixmap(pm),
-        sampler: peniko::ImageSampler { quality: peniko::ImageQuality::Medium, ..Default::default() },
-    });
-    ctx.set_paint_transform(
-        Affine::translate(bounds.origin().to_vec2()) * Affine::scale_non_uniform(bounds.width() / pw as f64, bounds.height() / ph as f64),
-    );
-    ctx.fill_path(path);
-    ctx.reset_paint_transform();
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use kurbo::Shape;
-
-    const CENTRE: [f64; 4] = [0.5, 0.5, 0.5, 0.5];
-
-    #[test]
-    fn rect_paths_take_the_larger_axis_share() {
-        // PowerPoint, 280x200 box from the centre: 20 px across is 1/7, 20 px down is 1/5.
-        let b = Rect::new(0.0, 0.0, 280.0, 200.0);
-        let at = |x: f64, y: f64| position("rect", b, CENTRE, &[], Point::new(x, y));
-        assert!((at(160.0, 100.0) - 20.0 / 140.0).abs() < 1e-9);
-        assert!((at(140.0, 120.0) - 20.0 / 100.0).abs() < 1e-9);
-        assert!((at(168.0, 120.0) - 0.2).abs() < 1e-9, "the diagonal takes the larger share");
-        assert_eq!(at(0.0, 0.0), 1.0);
-        // From a corner (fillToRect 0,0,100%,100%): the far corner is the end.
-        let corner = [0.0, 0.0, 1.0, 1.0];
-        assert!((position("rect", b, corner, &[], Point::new(140.0, 50.0)) - 0.5).abs() < 1e-9);
-    }
-
-    #[test]
-    fn shape_paths_follow_the_outline() {
-        let b = Rect::new(0.0, 0.0, 280.0, 200.0);
-        let ellipse = polygons(&kurbo::Ellipse::from_rect(b).to_path(0.01));
-        let at = |x: f64, y: f64| position("shape", b, CENTRE, &ellipse, Point::new(x, y));
-        assert!((at(160.0, 100.0) - 20.0 / 140.0).abs() < 0.01);
-        assert!((at(140.0, 120.0) - 0.2).abs() < 0.01);
-        // Half way to the outline along any ray is 0.5.
-        let (dx, dy) = (140.0 * 0.6, 100.0 * 0.8);
-        assert!((at(140.0 + dx * 0.5, 100.0 + dy * 0.5) - 0.5).abs() < 0.01);
-        // A triangle: half way from its centre to its apex is 0.5.
-        let mut tri = BezPath::new();
-        tri.move_to((140.0, 0.0));
-        tri.line_to((280.0, 200.0));
-        tri.line_to((0.0, 200.0));
-        tri.close_path();
-        let polys = polygons(&tri);
-        assert!((position("shape", b, CENTRE, &polys, Point::new(140.0, 50.0)) - 0.5).abs() < 1e-6);
-    }
-
-    #[test]
-    fn shape_paths_from_off_the_shape_or_a_focus_box() {
-        let b = Rect::new(0.0, 0.0, 280.0, 200.0);
-        let ellipse = polygons(&kurbo::Ellipse::from_rect(b).to_path(0.01));
-        // Focus on the box's corner, outside the ellipse: contours are the ellipse shrunk towards
-        // the corner, so its far edge is the end and its middle part way (it was all the end
-        // colour).
-        let corner = [0.0, 0.0, 1.0, 1.0];
-        let mid = position("shape", b, corner, &ellipse, Point::new(140.0, 100.0));
-        assert!(mid > 0.3 && mid < 0.8, "{mid}");
-        assert!(position("shape", b, corner, &ellipse, Point::new(279.0, 100.0)) > 0.95);
-        // A focus rectangle is the first colour inside, and the colour runs from its edge out.
-        let boxed = [0.25, 0.25, 0.25, 0.25];
-        assert_eq!(position("shape", b, boxed, &ellipse, Point::new(150.0, 110.0)), 0.0);
-        let half = position("shape", b, boxed, &ellipse, Point::new(140.0 + 70.0 + 35.0, 100.0));
-        assert!((half - 0.5).abs() < 0.02, "{half}");
-    }
-
-    #[test]
-    fn the_ramp_runs_through_the_stops() {
-        let stops = [(0.0, Rgba::rgb(0, 0, 0)), (0.5, Rgba::rgb(128, 128, 128)), (1.0, Rgba::rgb(255, 255, 255))];
-        let r = ramp(&stops);
-        assert_eq!(r.len(), 256);
-        assert_eq!(r[0], Rgba::rgb(0, 0, 0));
-        assert_eq!(r[255], Rgba::rgb(255, 255, 255));
-        assert!((r[64].r as i32 - 64).abs() <= 2);
-        assert!(ramp(&[(0.3, Rgba::rgb(9, 9, 9))]).iter().all(|c| *c == Rgba::rgb(9, 9, 9)));
-    }
-}

crates/render/src/pattern.rs

@@ -1,211 +0,0 @@
-//! Preset pattern fills (`a:pattFill`): an 8×8 two-colour tile, each cell one 96-dpi pixel
-//! (0.75 pt) of the slide, as PowerPoint draws them.
-//!
-//! The tiles were read from PowerPoint's own slide export of every preset (black on white, at
-//! exactly two output pixels per pattern pixel), so the marks, their density and their phase
-//! match it. Bit 7 of each row is the leftmost cell; a set bit is the foreground colour.
-
-use std::sync::Arc;
-
-use deckcraft_color::Rgba;
-use kurbo::{Affine, BezPath};
-use vello_cpu::{Pixmap, RenderContext, peniko};
-
-/// Side of one pattern cell, in points.
-pub const CELL: f64 = 0.75;
-
-const TILES: &[(&str, [u8; 8])] = &[
-    ("pct5", [0x80, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00]),
-    ("pct10", [0x80, 0x00, 0x08, 0x00, 0x80, 0x00, 0x08, 0x00]),
-    ("pct20", [0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00]),
-    ("pct25", [0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22]),
-    ("pct30", [0xAA, 0x44, 0xAA, 0x11, 0xAA, 0x44, 0xAA, 0x11]),
-    ("pct40", [0xAA, 0x55, 0xAA, 0x51, 0xAA, 0x55, 0xAA, 0x15]),
-    ("pct50", [0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55]),
-    ("pct60", [0xEE, 0x55, 0xBB, 0x55, 0xEE, 0x55, 0xBB, 0x55]),
-    ("pct70", [0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD]),
-    ("pct75", [0x77, 0xFF, 0xDD, 0xFF, 0x77, 0xFF, 0xDD, 0xFF]),
-    ("pct80", [0xEF, 0xFF, 0xFE, 0xFF, 0xEF, 0xFF, 0xFE, 0xFF]),
-    ("pct90", [0xFF, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0x7F]),
-    ("horz", [0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
-    ("vert", [0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
-    ("ltHorz", [0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00]),
-    ("ltVert", [0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88]),
-    ("dkHorz", [0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00]),
-    ("dkVert", [0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC]),
-    ("narHorz", [0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00]),
-    ("narVert", [0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
-    ("dashHorz", [0xF0, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00]),
-    ("dashVert", [0x80, 0x80, 0x80, 0x80, 0x08, 0x08, 0x08, 0x08]),
-    ("cross", [0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
-    ("dnDiag", [0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01]),
-    ("upDiag", [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80]),
-    ("ltDnDiag", [0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11]),
-    ("ltUpDiag", [0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88]),
-    ("dkDnDiag", [0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99]),
-    ("dkUpDiag", [0x33, 0x66, 0xCC, 0x99, 0x33, 0x66, 0xCC, 0x99]),
-    ("wdDnDiag", [0xC1, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x83]),
-    ("wdUpDiag", [0x83, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xC1]),
-    ("dashDnDiag", [0x00, 0x00, 0x88, 0x44, 0x22, 0x11, 0x00, 0x00]),
-    ("dashUpDiag", [0x00, 0x00, 0x11, 0x22, 0x44, 0x88, 0x00, 0x00]),
-    ("diagCross", [0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81]),
-    ("smCheck", [0x99, 0x66, 0x66, 0x99, 0x99, 0x66, 0x66, 0x99]),
-    ("lgCheck", [0xF0, 0xF0, 0xF0, 0xF0, 0x0F, 0x0F, 0x0F, 0x0F]),
-    ("smGrid", [0xFF, 0x88, 0x88, 0x88, 0xFF, 0x88, 0x88, 0x88]),
-    ("lgGrid", [0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
-    ("dotGrid", [0xAA, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00]),
-    ("smConfetti", [0x80, 0x08, 0x40, 0x02, 0x10, 0x01, 0x20, 0x04]),
-    ("lgConfetti", [0xB1, 0x30, 0x03, 0x1B, 0xD8, 0xC0, 0x0C, 0x8D]),
-    ("horzBrick", [0xFF, 0x80, 0x80, 0x80, 0xFF, 0x08, 0x08, 0x08]),
-    ("diagBrick", [0x01, 0x02, 0x04, 0x08, 0x18, 0x24, 0x42, 0x81]),
-    ("solidDmnd", [0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00]),
-    ("openDmnd", [0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, 0x01]),
-    ("dotDmnd", [0x80, 0x00, 0x22, 0x00, 0x08, 0x00, 0x22, 0x00]),
-    ("plaid", [0xAA, 0x55, 0xAA, 0x55, 0xF0, 0xF0, 0xF0, 0xF0]),
-    ("sphere", [0x77, 0x89, 0x8F, 0x8F, 0x77, 0x98, 0xF8, 0xF8]),
-    ("weave", [0x88, 0x54, 0x22, 0x45, 0x88, 0x14, 0x22, 0x51]),
-    ("divot", [0x00, 0x10, 0x08, 0x10, 0x00, 0x80, 0x01, 0x80]),
-    ("shingle", [0x03, 0x84, 0x48, 0x30, 0x0C, 0x02, 0x01, 0x01]),
-    ("wave", [0x00, 0x18, 0x25, 0xC0, 0x00, 0x18, 0x25, 0xC0]),
-    ("trellis", [0xFF, 0x66, 0xFF, 0x99, 0xFF, 0x66, 0xFF, 0x99]),
-    ("zigZag", [0x81, 0x42, 0x24, 0x18, 0x81, 0x42, 0x24, 0x18]),
-];
-
-/// The 8×8 tile of preset `name` (`pct50` for an unknown name).
-pub fn tile(name: &str) -> [u8; 8] {
-    TILES
-        .iter()
-        .find(|(n, _)| *n == name)
-        .or_else(|| TILES.iter().find(|(n, _)| *n == "pct50"))
-        .map(|(_, t)| *t)
-        .unwrap_or([0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55])
-}
-
-/// Is cell (`x`, `y`) of the tile the foreground?
-pub fn is_fg(tile: &[u8; 8], x: usize, y: usize) -> bool {
-    tile.get(y % 8).is_some_and(|row| row & (0x80 >> (x % 8)) != 0)
-}
-
-fn premul(c: Rgba, alpha: f64) -> vello_cpu::color::PremulRgba8 {
-    let a = (c.a as f64 * alpha.clamp(0.0, 1.0)).round().clamp(0.0, 255.0);
-    let m = |v: u8| (v as f64 * a / 255.0).round().clamp(0.0, 255.0) as u8;
-    vello_cpu::color::PremulRgba8 { r: m(c.r), g: m(c.g), b: m(c.b), a: a as u8 }
-}
-
-/// Fill `path` (in the space `m` maps to the output) with preset `name` in `fg` on `bg`, faded by
-/// `alpha`.
-pub fn fill(ctx: &mut RenderContext, name: &str, fg: Rgba, bg: Rgba, alpha: f64, path: &BezPath, m: Affine) {
-    let det = m.determinant();
-    if !det.is_finite() || det.abs() <= 1e-12 {
-        return;
-    }
-    let t = tile(name);
-    let (f, b) = (premul(fg, alpha), premul(bg, alpha));
-    let data: Vec<vello_cpu::color::PremulRgba8> = (0..64).map(|i| if is_fg(&t, i % 8, i / 8) { f } else { b }).collect();
-    let pm = Arc::new(Pixmap::from_parts(data, 8, 8));
-    ctx.set_transform(m);
-    ctx.set_paint(vello_cpu::Image {
-        image: vello_cpu::ImageSource::Pixmap(pm),
-        sampler: peniko::ImageSampler {
-            x_extend: peniko::Extend::Repeat,
-            y_extend: peniko::Extend::Repeat,
-            // Bilinear, as PowerPoint samples the tile: exact at a whole number of output pixels
-            // per cell; between, a pixel straddling two cells takes a blend of both (fitted to its
-            // export at 0.75 px per cell: mean error 0.067 against 0.082 for the nearest cell).
-            quality: peniko::ImageQuality::Medium,
-            alpha: 1.0,
-        },
-    });
-    // Cells are laid out on the output from its origin (the slide's top-left corner), so
-    // neighbouring shapes' patterns line up, as in PowerPoint.
-    let k = crate::scale_of(m);
-    let k = if k.is_finite() && k > 0.0 { k } else { 1.0 };
-    ctx.set_paint_transform(m.inverse() * Affine::scale(CELL * k));
-    ctx.fill_path(path);
-    ctx.reset_paint_transform();
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn every_drawingml_preset_has_a_tile() {
-        // ECMA-376 ST_PresetPatternVal.
-        let all = [
-            "pct5",
-            "pct10",
-            "pct20",
-            "pct25",
-            "pct30",
-            "pct40",
-            "pct50",
-            "pct60",
-            "pct70",
-            "pct75",
-            "pct80",
-            "pct90",
-            "horz",
-            "vert",
-            "ltHorz",
-            "ltVert",
-            "dkHorz",
-            "dkVert",
-            "narHorz",
-            "narVert",
-            "dashHorz",
-            "dashVert",
-            "cross",
-            "dnDiag",
-            "upDiag",
-            "ltDnDiag",
-            "ltUpDiag",
-            "dkDnDiag",
-            "dkUpDiag",
-            "wdDnDiag",
-            "wdUpDiag",
-            "dashDnDiag",
-            "dashUpDiag",
-            "diagCross",
-            "smCheck",
-            "lgCheck",
-            "smGrid",
-            "lgGrid",
-            "dotGrid",
-            "smConfetti",
-            "lgConfetti",
-            "horzBrick",
-            "diagBrick",
-            "solidDmnd",
-            "openDmnd",
-            "dotDmnd",
-            "plaid",
-            "sphere",
-            "weave",
-            "divot",
-            "shingle",
-            "wave",
-            "trellis",
-            "zigZag",
-        ];
-        assert_eq!(all.len(), 54);
-        for n in all {
-            assert!(TILES.iter().any(|(t, _)| *t == n), "{n}");
-        }
-        assert_eq!(TILES.len(), 54);
-    }
-
-    #[test]
-    fn percent_presets_get_denser() {
-        // The pctN tiles set more cells as N grows (PowerPoint's own: pct5 sets 2 of 64, pct50
-        // half, pct90 all but 2).
-        let share = |n: &str| {
-            let t = tile(n);
-            (0..64).filter(|i| is_fg(&t, i % 8, i / 8)).count()
-        };
-        let names = ["pct5", "pct10", "pct20", "pct25", "pct30", "pct40", "pct50", "pct60", "pct70", "pct75", "pct80", "pct90"];
-        assert!(names.windows(2).all(|w| share(w[0]) <= share(w[1])), "{:?}", names.map(share));
-        assert_eq!((share("pct5"), share("pct50"), share("pct90")), (2, 32, 62));
-        assert_eq!(tile("nonsense"), tile("pct50"));
-    }
-}

crates/render/src/ramp.rs

@@ -1,128 +0,0 @@
-//! Gradient colour ramps as PowerPoint draws them.
-//!
-//! A gradient of exactly two stops, at 0 % and 100 % (what a two-colour gradient is), is not
-//! blended linearly in sRGB by PowerPoint: it mixes the colours in linear light, and the second
-//! colour's share follows an S-shaped curve of the position. Black to white is 105 (not 64) a
-//! quarter of the way, 186 (not 128) half way and 238 (not 191) three quarters of the way, in any
-//! direction, on shapes and on slide backgrounds. Gradients with three or more stops, or with a
-//! stop moved off an end, blend linearly in sRGB (measured from PowerPoint's own slide export).
-//! The renderer interpolates linearly in sRGB, so a two-colour gradient is expanded into short
-//! pieces whose colours follow PowerPoint's ramp.
-
-use deckcraft_color::Rgba;
-
-/// The next stop's share of the linear-light mix at sixteenths of a segment (0 at the first stop,
-/// 1 at the second). Measured, then made symmetric: `w(1 - t) = 1 - w(t)`.
-const WEIGHT: [f64; 17] =
-    [0.0, 0.0205, 0.0469, 0.0878, 0.1431, 0.2143, 0.2989, 0.3972, 0.5, 0.6028, 0.7011, 0.7857, 0.8569, 0.9122, 0.9531, 0.9795, 1.0];
-
-/// Pieces each segment between two stops is cut into.
-const PIECES: usize = 16;
-
-/// The next stop's share at `t` (0..1) between two stops.
-pub fn weight(t: f64) -> f64 {
-    if !t.is_finite() {
-        return 0.0;
-    }
-    let x = t.clamp(0.0, 1.0) * (WEIGHT.len() - 1) as f64;
-    let i = (x.floor() as usize).min(WEIGHT.len() - 2);
-    let f = x - i as f64;
-    let (a, b) = (WEIGHT.get(i).copied().unwrap_or(0.0), WEIGHT.get(i + 1).copied().unwrap_or(1.0));
-    a + (b - a) * f
-}
-
-fn to_linear(v: u8) -> f64 {
-    let v = v as f64 / 255.0;
-    if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
-}
-
-fn to_srgb(v: f64) -> u8 {
-    let v = v.clamp(0.0, 1.0);
-    let s = if v <= 0.0031308 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 };
-    (s * 255.0).round().clamp(0.0, 255.0) as u8
-}
-
-/// The colour at `t` between stops `a` and `b`. Alpha mixes by the same share.
-pub fn mix(a: Rgba, b: Rgba, t: f64) -> Rgba {
-    let w = weight(t);
-    let ch = |x: u8, y: u8| to_srgb(to_linear(x) + (to_linear(y) - to_linear(x)) * w);
-    Rgba { r: ch(a.r, b.r), g: ch(a.g, b.g), b: ch(a.b, b.b), a: (a.a as f64 + (b.a as f64 - a.a as f64) * w).round().clamp(0.0, 255.0) as u8 }
-}
-
-/// Sorted stops (position 0..1, colour) as a renderer interpolating linearly in sRGB should get
-/// them: a two-colour gradient (two stops, at 0 and 1) expanded to follow PowerPoint's ramp,
-/// anything else unchanged.
-pub fn expand(stops: &[(f64, Rgba)]) -> Vec<(f64, Rgba)> {
-    let two_colour = matches!(stops, [(p, _), (q, _)] if *p <= 1e-6 && *q >= 1.0 - 1e-6);
-    if !two_colour {
-        return stops.to_vec();
-    }
-    let mut out = Vec::with_capacity(stops.len() * PIECES + 1);
-    for (i, &(p, c)) in stops.iter().enumerate() {
-        out.push((p, c));
-        let Some(&(q, d)) = stops.get(i + 1) else { continue };
-        if q - p <= 1e-6 || c == d {
-            continue;
-        }
-        for k in 1..PIECES {
-            let t = k as f64 / PIECES as f64;
-            out.push((p + (q - p) * t, mix(c, d, t)));
-        }
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn black_to_white_follows_powerpoint() {
-        // PowerPoint's export: 105 at a quarter, 186 half way, 238 at three quarters.
-        let (k, w) = (Rgba::rgb(0, 0, 0), Rgba::rgb(255, 255, 255));
-        for (t, want) in [(0.25, 105), (0.5, 186), (0.75, 238)] {
-            let got = mix(k, w, t).r as i32;
-            assert!((got - want).abs() <= 3, "{t}: {got} vs {want}");
-        }
-    }
-
-    #[test]
-    fn colour_pairs_follow_powerpoint() {
-        // Blue (4472C4) to orange (ED7D31) half way: PowerPoint draws (178, 120, 146).
-        let m = mix(Rgba::rgb(68, 114, 196), Rgba::rgb(237, 125, 49), 0.5);
-        assert!((m.r as i32 - 178).abs() <= 3 && (m.g as i32 - 120).abs() <= 3 && (m.b as i32 - 146).abs() <= 3, "{m:?}");
-        // Red to blue a quarter of the way: (238, 0, 105).
-        let m = mix(Rgba::rgb(255, 0, 0), Rgba::rgb(0, 0, 255), 0.25);
-        assert!((m.r as i32 - 238).abs() <= 3 && (m.b as i32 - 105).abs() <= 3, "{m:?}");
-    }
-
-    #[test]
-    fn the_ends_are_the_stops_and_the_weight_is_symmetric() {
-        let (a, b) = (Rgba::rgb(10, 200, 30), Rgba::rgb(240, 20, 90));
-        assert_eq!(mix(a, b, 0.0), a);
-        assert_eq!(mix(a, b, 1.0), b);
-        for k in 0..=32 {
-            let t = k as f64 / 32.0;
-            assert!((weight(t) + weight(1.0 - t) - 1.0).abs() < 1e-9);
-            assert!(weight(t) <= weight((t + 0.01).min(1.0)), "monotonic");
-        }
-        assert_eq!(weight(f64::NAN), 0.0);
-    }
-
-    #[test]
-    fn expand_keeps_stops_and_hard_edges() {
-        let (r, g) = (Rgba::rgb(255, 0, 0), Rgba::rgb(0, 255, 0));
-        // Three or more stops, or a stop off an end, blend linearly in sRGB: unchanged.
-        let e = expand(&[(0.0, r), (0.5, r), (0.5, g), (1.0, g)]);
-        assert_eq!(e, vec![(0.0, r), (0.5, r), (0.5, g), (1.0, g)]);
-        assert_eq!(expand(&[(0.2, r), (1.0, g)]), vec![(0.2, r), (1.0, g)]);
-        assert_eq!(expand(&[(0.0, r), (0.5, g), (1.0, r)]).len(), 3);
-        // Two equal colours add nothing.
-        assert_eq!(expand(&[(0.0, r), (1.0, r)]), vec![(0.0, r), (1.0, r)]);
-        let e = expand(&[(0.0, r), (1.0, g)]);
-        assert_eq!(e.len(), PIECES + 1);
-        assert_eq!(e.first(), Some(&(0.0, r)));
-        assert_eq!(e.last(), Some(&(1.0, g)));
-        assert!(e.windows(2).all(|w| w[0].0 <= w[1].0));
-    }
-}

crates/render/src/table.rs

@@ -3,7 +3,7 @@
 use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
 use deckcraft_model::resolve::Ctx;
 use deckcraft_model::style::{ColorRef, Fill};
-use deckcraft_model::table::{Cell, Table, TableBorder, TablePart, TablePartStyle, TableStyleDef};
+use deckcraft_model::table::{Cell, Table};
 use deckcraft_model::text::{Anchor, TextBody, TextDir};
 use deckcraft_model::{Presentation, Shape};
 use deckcraft_text::Fields;
@@ -18,12 +18,6 @@ pub struct CellLook {
     pub text: Option<Rgba>,
     pub bold: bool,
     pub border: Option<(Rgba, f64)>,
-    /// Left, right, top and bottom borders from a file-defined style (a fully transparent colour
-    /// means no border); `None` falls back to `border`.
-    pub sides: [Option<(Rgba, f64)>; 4],
-    /// A file-defined style's fill as a paint (gradients, see-through colours), with its
-    /// placeholder colour; drawn instead of `fill`.
-    pub paint: Option<(Fill, Option<Rgba>)>,
 }
 
 fn accent(ctx: &Ctx, style: &str) -> Rgba {
@@ -39,109 +33,7 @@ fn accent(ctx: &Ctx, style: &str) -> Rgba {
     ctx.color(&ColorRef::scheme(slot), None)
 }
 
-/// The look of cell (`r`, `c`) from a table style the file defines: each part that applies to
-/// the cell (whole table, bands, first and last rows and columns, corners, in that order) sets the
-/// fill, text and the borders on its region's edges (its inside lines within it).
-fn look_def(ctx: &Ctx, def: &TableStyleDef, t: &Table, r: usize, c: usize) -> CellLook {
-    let (rows, cols) = (t.rows.len(), t.cols.len());
-    let (r1, c1) = t.cell(r, c).map(|cell| (r + cell.row_span.max(1) as usize - 1, c + cell.grid_span.max(1) as usize - 1)).unwrap_or((r, c));
-    let (r1, c1) = (r1.min(rows.saturating_sub(1)), c1.min(cols.saturating_sub(1)));
-    let last_r = rows.saturating_sub(1);
-    let last_c = cols.saturating_sub(1);
-    let header = t.first_row && r == 0;
-    let total = t.last_row && r1 == last_r && rows > 1;
-    let first_col = t.first_col && c == 0;
-    let last_col = t.last_col && c1 == last_c && cols > 1;
-    let body_r = r.saturating_sub(usize::from(t.first_row));
-    let body_c = c.saturating_sub(usize::from(t.first_col));
-    let mut look = CellLook { fill: None, text: None, bold: false, border: None, sides: [None; 4], paint: None };
-    for part in TablePart::ALL {
-        // (applies, region rows, region cols)
-        let (on, region) = match part {
-            TablePart::WholeTbl => (true, (0, last_r, 0, last_c)),
-            TablePart::Band1H => (t.band_row && !header && !total && body_r % 2 == 0, (r, r1, 0, last_c)),
-            TablePart::Band2H => (t.band_row && !header && !total && body_r % 2 == 1, (r, r1, 0, last_c)),
-            TablePart::Band1V => (t.band_col && !first_col && !last_col && body_c % 2 == 0, (0, last_r, c, c1)),
-            TablePart::Band2V => (t.band_col && !first_col && !last_col && body_c % 2 == 1, (0, last_r, c, c1)),
-            TablePart::LastCol => (last_col, (0, last_r, c, last_c)),
-            TablePart::FirstCol => (first_col, (0, last_r, 0, c1)),
-            TablePart::LastRow => (total, (r, last_r, 0, last_c)),
-            TablePart::FirstRow => (header, (0, r1, 0, last_c)),
-            TablePart::SeCell => (total && last_col, (r, r1, c, c1)),
-            TablePart::SwCell => (total && first_col, (r, r1, c, c1)),
-            TablePart::NeCell => (header && last_col, (r, r1, c, c1)),
-            TablePart::NwCell => (header && first_col, (r, r1, c, c1)),
-        };
-        if !on {
-            continue;
-        }
-        let Some(ps) = def.part(part) else { continue };
-        if let Some(p) = style_fill(ctx, ps) {
-            look.fill = fill_color(ctx, &p.0, p.1);
-            look.paint = Some(p);
-        }
-        if let Some(tc) = &ps.text_color {
-            look.text = Some(ctx.color(tc, None));
-        }
-        if let Some(b) = ps.bold {
-            look.bold = b;
-        }
-        let (r0, rr1, c0, cc1) = region;
-        // Left, right, top, bottom of the cell: the part's edge or its inside line.
-        let pick = [if c == c0 { 0 } else { 5 }, if c1 == cc1 { 1 } else { 5 }, if r == r0 { 2 } else { 4 }, if r1 == rr1 { 3 } else { 4 }];
-        for (side, i) in pick.iter().enumerate() {
-            if let (Some(Some(b)), Some(slot)) = (ps.borders.get(*i), look.sides.get_mut(side)) {
-                *slot = Some(border_look(ctx, b));
-            }
-        }
-    }
-    look
-}
-
-/// A style part's fill, a theme fill reference resolved to the theme's fill with its colour as
-/// the placeholder colour.
-fn style_fill(ctx: &Ctx, ps: &TablePartStyle) -> Option<(Fill, Option<Rgba>)> {
-    if let Some((idx, col)) = &ps.fill_ref {
-        let ph = ctx.color(col, None);
-        return Some(match ctx.master.theme.format.fills.get((*idx as usize).saturating_sub(1)) {
-            Some(f) if *idx > 0 => (f.clone(), Some(ph)),
-            _ if *idx == 0 => (Fill::None, None),
-            _ => (Fill::solid(ColorRef::rgb(ph)), None),
-        });
-    }
-    ps.fill.clone().map(|f| (f, None))
-}
-
-/// A fill's colour for a table cell (gradients and pictures by their first colour).
-fn fill_color(ctx: &Ctx, f: &Fill, ph: Option<Rgba>) -> Option<Rgba> {
-    match f {
-        Fill::None => Some(Rgba::TRANSPARENT),
-        Fill::Solid { color: c } => Some(ctx.color(c, ph)),
-        Fill::Gradient(g) => g.stops.first().map(|s| ctx.color(&s.color, ph)),
-        Fill::Pattern(p) => Some(ctx.color(&p.bg, ph)),
-        _ => None,
-    }
-}
-
-/// A style border's colour and width (a transparent colour for no line).
-fn border_look(ctx: &Ctx, b: &TableBorder) -> (Rgba, f64) {
-    match b {
-        TableBorder::Line { line } => match &line.fill {
-            Some(Fill::Solid { color: c }) => (ctx.color(c, None), line.width.unwrap_or(0.75)),
-            Some(Fill::Gradient(g)) => (g.stops.first().map(|s| ctx.color(&s.color, None)).unwrap_or(Rgba::BLACK), line.width.unwrap_or(0.75)),
-            _ => (Rgba::TRANSPARENT, 0.0),
-        },
-        TableBorder::Ref { idx, color } => {
-            let w = ctx.master.theme.format.lines.get((*idx as usize).saturating_sub(1)).and_then(|l| l.width).unwrap_or(0.75);
-            if *idx == 0 { (Rgba::TRANSPARENT, 0.0) } else { (ctx.color(color, None), w) }
-        }
-    }
-}
-
 pub fn look(ctx: &Ctx, t: &Table, r: usize, c: usize) -> CellLook {
-    if let Some(def) = ctx.pres.table_styles.iter().find(|d| d.id.eq_ignore_ascii_case(&t.style)) {
-        return look_def(ctx, def, t, r, c);
-    }
     let a = accent(ctx, &t.style);
     let kind = t.style.split('-').next().unwrap_or("medium2");
     let header = t.first_row && r == 0;
@@ -155,23 +47,19 @@ pub fn look(ctx: &Ctx, t: &Table, r: usize, c: usize) -> CellLook {
     let white = Rgba::WHITE;
     let dark_text = ctx.color(&ColorRef::scheme(SchemeSlot::Tx1), None);
     match kind {
-        "none" => CellLook { fill: None, text: None, bold: false, border: None, sides: [None; 4], paint: None },
-        "grid" => CellLook { fill: None, text: None, bold: false, border: Some((dark_text, 0.75)), sides: [None; 4], paint: None },
+        "none" => CellLook { fill: None, text: None, bold: false, border: None },
+        "grid" => CellLook { fill: None, text: None, bold: false, border: Some((dark_text, 0.75)) },
         "light1" => CellLook {
             fill: if band || band_c { Some(tint(20000)) } else { None },
             text: None,
             bold: header || total || first_col || last_col,
             border: if header { Some((a, 1.0)) } else { None },
-            sides: [None; 4],
-            paint: None,
         },
         "light2" => CellLook {
             fill: if header { Some(a) } else { None },
             text: if header { Some(white) } else { None },
             bold: header || total || first_col,
             border: Some((a, 1.0)),
-            sides: [None; 4],
-            paint: None,
         },
         "dark1" => CellLook {
             fill: Some(if header {
@@ -184,16 +72,12 @@ pub fn look(ctx: &Ctx, t: &Table, r: usize, c: usize) -> CellLook {
             text: Some(white),
             bold: header || total || first_col,
             border: Some((white, 1.0)),
-            sides: [None; 4],
-            paint: None,
         },
         "medium4" => CellLook {
             fill: Some(if header || band || band_c { tint(40000) } else { tint(20000) }),
             text: None,
             bold: header || total || first_col || last_col,
             border: Some((a, 0.75)),
-            sides: [None; 4],
-            paint: None,
         },
         _ => CellLook {
             // medium2: strong header, banded light tints, white grid.
@@ -207,8 +91,6 @@ pub fn look(ctx: &Ctx, t: &Table, r: usize, c: usize) -> CellLook {
             text: if header || total || first_col || last_col { Some(white) } else { None },
             bold: header || total || first_col || last_col,
             border: Some((white, 1.0)),
-            sides: [None; 4],
-            paint: None,
         },
     }
 }
@@ -297,36 +179,9 @@ pub fn cell_rects(t: &Table, heights: &[f64]) -> Vec<(usize, usize, Rect)> {
     out
 }
 
-/// Draws the table; returns the box its cells cover (table space), which grows with their text.
-#[allow(clippy::too_many_arguments)]
-pub fn draw(
-    ctx: &mut RenderContext,
-    pres: &Presentation,
-    rctx: &Ctx,
-    t: &Table,
-    m: Affine,
-    _w: f64,
-    _h: f64,
-    fields: &dyn deckcraft_text::Fields,
-) -> Option<kurbo::Rect> {
+pub fn draw(ctx: &mut RenderContext, pres: &Presentation, rctx: &Ctx, t: &Table, m: Affine, _w: f64, _h: f64, fields: &dyn deckcraft_text::Fields) {
     let _ = pres;
     let rects = cell_rects(t, &row_heights(rctx, t, fields));
-    let covered = rects.iter().map(|(_, _, r)| *r).reduce(|a, b| a.union(b));
-    // Table backgrounds behind every cell: a file-defined style's, then the table's own fill.
-    let style_bg = rctx
-        .pres
-        .table_styles
-        .iter()
-        .find(|d| d.id.eq_ignore_ascii_case(&t.style))
-        .and_then(|d| d.background.as_ref())
-        .and_then(|b| style_fill(rctx, b));
-    let own_bg = t.background.clone().map(|f| (f, None));
-    if let Some(all) = rects.iter().map(|(_, _, r)| *r).reduce(|a, b| a.union(b)) {
-        for (bg, ph) in style_bg.into_iter().chain(own_bg) {
-            ctx.set_transform(m);
-            crate::paint::fill_path(ctx, rctx, &bg, ph, &all.to_path(0.1), all, m, deckcraft_geom::preset::FillMode::Norm, 1.0, rctx.pres);
-        }
-    }
     for (r, c, rect) in &rects {
         let Some(cell) = t.cell(*r, *c) else { continue };
         let lk = look(rctx, t, *r, *c);
@@ -335,28 +190,12 @@ pub fn draw(
             Some(f) => {
                 crate::paint::fill_path(ctx, rctx, f, None, &rect.to_path(0.1), *rect, m, deckcraft_geom::preset::FillMode::Norm, 1.0, rctx.pres)
             }
-            None => match &lk.paint {
-                Some((f, ph)) => {
-                    crate::paint::fill_path(ctx, rctx, f, *ph, &rect.to_path(0.1), *rect, m, deckcraft_geom::preset::FillMode::Norm, 1.0, rctx.pres)
+            None => {
+                if let Some(fc) = lk.fill {
+                    ctx.set_paint(color(fc, 1.0));
+                    ctx.fill_rect(rect);
                 }
-                None => {
-                    if let Some(fc) = lk.fill.filter(|f| f.a > 0) {
-                        ctx.set_paint(color(fc, 1.0));
-                        ctx.fill_rect(rect);
-                    }
-                }
-            },
-        }
-    }
-    // Diagonal borders, under the edges: drawn like any line (dashes, compound, caps).
-    for (r, c, rect) in &rects {
-        let Some(cell) = t.cell(*r, *c) else { continue };
-        for (line, a, b) in [(&cell.diag_down, (rect.x0, rect.y0), (rect.x1, rect.y1)), (&cell.diag_up, (rect.x0, rect.y1), (rect.x1, rect.y0))] {
-            let Some(l) = line.as_ref().filter(|l| l.fill.as_ref().is_some_and(|f| !f.is_none())) else { continue };
-            let mut p = BezPath::new();
-            p.move_to(a);
-            p.line_to(b);
-            crate::stroke(ctx, rctx, l, None, &p, None, m, l.width.unwrap_or(1.0).max(0.0), 1.0);
+            }
         }
     }
     // Borders: explicit cell borders, else the style's grid.
@@ -372,20 +211,15 @@ pub fn draw(
         for (i, e) in edges.iter().enumerate() {
             let line = cell.borders.get(i).and_then(|b| b.as_ref());
             let (col, wd) = match line {
-                // An explicit border is drawn like any line: dashed, compound, gradient.
-                Some(l) => {
-                    if l.fill.as_ref().is_some_and(|f| !f.is_none()) {
-                        let mut p = BezPath::new();
-                        p.move_to((e.0, e.1));
-                        p.line_to((e.2, e.3));
-                        crate::stroke(ctx, rctx, l, None, &p, None, m, l.width.unwrap_or(1.0).max(0.25), 1.0);
-                    }
-                    continue;
-                }
-                None => match lk.sides.get(i).copied().flatten().or(lk.border) {
-                    Some(b) if b.0.a > 0 && b.1 > 0.0 => b,
+                Some(l) => match &l.fill {
+                    Some(Fill::Solid { color: cc }) => (rctx.color(cc, None), l.width.unwrap_or(1.0)),
+                    Some(Fill::None) => continue,
                     _ => continue,
                 },
+                None => match lk.border {
+                    Some(b) => b,
+                    None => continue,
+                },
             };
             let mut p = BezPath::new();
             p.move_to((e.0, e.1));
@@ -407,5 +241,4 @@ pub fn draw(
         crate::draw_text(ctx, rctx, &tmp, &body, *rect, m, fields, None);
         let _ = peniko::Fill::NonZero;
     }
-    covered
 }