diff --git a/CodenameOne/src/com/codename1/ui/GeneratedSVGImage.java b/CodenameOne/src/com/codename1/ui/GeneratedSVGImage.java new file mode 100644 index 0000000000..1ddf5ad973 --- /dev/null +++ b/CodenameOne/src/com/codename1/ui/GeneratedSVGImage.java @@ -0,0 +1,581 @@ +/* + * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + */ +package com.codename1.ui; + +import com.codename1.ui.animations.AnimationTime; +import com.codename1.util.MathUtil; + +/// Base class for SVG images emitted by the build-time transcoder +/// (`maven/svg-transcoder`). +/// +/// A subclass is generated per source SVG file. The subclass overrides +/// [#paintSVG(Graphics, long)] to issue the actual drawing commands and +/// passes its intrinsic dimensions and viewBox to the constructor. This class +/// handles three concerns the generated code should not have to think about: +/// +/// 1. **Viewport mapping** -- the viewBox is scaled into the destination +/// rectangle on every paint, so the same generated class can render at any +/// requested width/height without re-emitting code. +/// +/// 2. **DPI-aware default sizing** -- the SVG's declared `width`/`height` are +/// interpreted as design pixels at [com.codename1.ui.CN1Constants#DENSITY_MEDIUM] +/// (the same convention CN1 uses for its multi-image density buckets) and +/// scaled to the device density so an icon that looks "right" on a desktop +/// simulator also looks right on a high-DPI handset. Override with +/// [#scaled(int, int)] or by passing explicit dimensions on construction. +/// +/// 3. **Deterministic animation time** -- animation progress is read from +/// [AnimationTime#now()], so tests that pin the clock with +/// [AnimationTime#setTime(long)] capture predictable frames. The "first +/// paint" timestamp is captured the first time [#paintSVG] is invoked, +/// making animations start at `t = 0` from the user's perspective +/// regardless of when the image instance was constructed. +/// +/// Generated SVGs are normally registered with a [com.codename1.ui.util.Resources] +/// object via the auto-generated `com.codename1.generated.svg.SVGRegistry` so +/// they appear under their original filename when calling +/// [com.codename1.ui.util.Resources#getImage(String)]. +public abstract class GeneratedSVGImage extends Image { + + /// Sentinel value used by [#progress] when an animation declared + /// `repeatCount="indefinite"`. + public static final int REPEAT_INDEFINITE = -1; + + private final int intrinsicWidth; + private final int intrinsicHeight; + private final int sourceDensity; + private final int width; + private final int height; + private final float viewBoxX; + private final float viewBoxY; + private final float viewBoxWidth; + private final float viewBoxHeight; + private final boolean animated; + private long animationStartMs = -1L; + + /// Construct with intrinsic SVG dimensions and viewBox metadata. The + /// rendered size defaults to the intrinsic dimensions scaled by the + /// device's density (so SVGs designed at standard mdpi look correct on + /// every screen). Use [#scaled(int, int)] for explicit pixel sizing. + /// + /// #### Parameters + /// + /// - `intrinsicWidth`: SVG-declared width in design pixels + /// + /// - `intrinsicHeight`: SVG-declared height in design pixels + /// + /// - `viewBoxX`: x origin of the viewBox in SVG user units + /// + /// - `viewBoxY`: y origin of the viewBox in SVG user units + /// + /// - `viewBoxWidth`: width of the viewBox; falls back to `intrinsicWidth` if `<= 0` + /// + /// - `viewBoxHeight`: height of the viewBox; falls back to `intrinsicHeight` if `<= 0` + /// + /// - `animated`: true if any SMIL animation was found inside the SVG + protected GeneratedSVGImage(int intrinsicWidth, int intrinsicHeight, + float viewBoxX, float viewBoxY, + float viewBoxWidth, float viewBoxHeight, + boolean animated) { + this(intrinsicWidth, intrinsicHeight, + viewBoxX, viewBoxY, viewBoxWidth, viewBoxHeight, + animated, CN1Constants.DENSITY_MEDIUM); + } + + /// Construct with an explicit source density for the SVG's declared + /// dimensions. This is the constructor the auto-generated `SVGRegistry` + /// targets when the CSS for an SVG declared a `cn1-source-dpi` -- the + /// runtime width/height then track that hint instead of assuming + /// [com.codename1.ui.CN1Constants#DENSITY_MEDIUM]. + /// + /// #### Parameters + /// + /// - `sourceDensity`: one of the `CN1Constants.DENSITY_*` constants, + /// describing the device class the SVG was designed for. A value of + /// `0` falls back to the SVG's intrinsic pixels (no scaling). + protected GeneratedSVGImage(int intrinsicWidth, int intrinsicHeight, + float viewBoxX, float viewBoxY, + float viewBoxWidth, float viewBoxHeight, + boolean animated, int sourceDensity) { + super(null); + this.intrinsicWidth = intrinsicWidth; + this.intrinsicHeight = intrinsicHeight; + this.sourceDensity = sourceDensity; + int density = readDeviceDensitySafely(); + this.width = scaleForDensity(intrinsicWidth, density, sourceDensity); + this.height = scaleForDensity(intrinsicHeight, density, sourceDensity); + this.viewBoxX = viewBoxX; + this.viewBoxY = viewBoxY; + this.viewBoxWidth = viewBoxWidth <= 0 ? intrinsicWidth : viewBoxWidth; + this.viewBoxHeight = viewBoxHeight <= 0 ? intrinsicHeight : viewBoxHeight; + this.animated = animated; + } + + /// Construct with explicit absolute width/height -- expressed in device + /// pixels here, but the auto-generated subclass takes them in millimeters + /// and converts via [Display#convertToPixels(float)] so the dimensions + /// carry across DPIs the same way `font-size: 3mm` does. This is the + /// constructor the [SVGRegistry] uses when the CSS rule specified + /// `cn1-svg-width` / `cn1-svg-height`, overriding any density-based + /// sizing. + /// + /// #### Parameters + /// + /// - `explicitWidth`: rendered width in device pixels (`>= 1`) + /// + /// - `explicitHeight`: rendered height in device pixels (`>= 1`) + protected GeneratedSVGImage(int intrinsicWidth, int intrinsicHeight, + float viewBoxX, float viewBoxY, + float viewBoxWidth, float viewBoxHeight, + boolean animated, + int explicitWidth, int explicitHeight) { + super(null); + if (explicitWidth < 1 || explicitHeight < 1) { + throw new IllegalArgumentException( + "SVG dimensions must be >= 1 pixel; got width=" + explicitWidth + + " height=" + explicitHeight + + ". Check the cn1-svg-width / cn1-svg-height CSS hint --" + + " a 0.something mm value rounds down to 0 pixels."); + } + this.intrinsicWidth = intrinsicWidth; + this.intrinsicHeight = intrinsicHeight; + this.sourceDensity = 0; + this.width = explicitWidth; + this.height = explicitHeight; + this.viewBoxX = viewBoxX; + this.viewBoxY = viewBoxY; + this.viewBoxWidth = viewBoxWidth <= 0 ? intrinsicWidth : viewBoxWidth; + this.viewBoxHeight = viewBoxHeight <= 0 ? intrinsicHeight : viewBoxHeight; + this.animated = animated; + } + + /// Convert a length in millimeters to device pixels using the current + /// [Display] DPI. Provided as a static helper for the generated subclass + /// constructors that accept mm-typed dimensions. Throws + /// [IllegalArgumentException] for `mm <= 0` -- callers should never pin + /// an SVG to a zero-or-negative physical size. Falls back to treating + /// the input as a literal pixel count when [Display] is not initialized + /// (e.g. during unit tests that construct an image before + /// `Display.init()` has run). + public static int mmToPixels(float mm) { + if (mm <= 0f || Float.isNaN(mm)) { + throw new IllegalArgumentException("SVG dimension must be > 0mm; got " + mm); + } + int pixels; + try { + pixels = Display.getInstance().convertToPixels(mm); + } catch (Throwable t) { + pixels = (int) Math.round(mm); + } + if (pixels < 1) { + throw new IllegalArgumentException("SVG dimension " + mm + + "mm resolves to " + pixels + " px on this device --" + + " pick a larger cn1-svg-width / cn1-svg-height value."); + } + return pixels; + } + + @Override + public final int getWidth() { + return width; + } + + @Override + public final int getHeight() { + return height; + } + + @Override + public final boolean isAnimation() { + return animated; + } + + /// Returning `true` requests a repaint on the next animation tick so the + /// embedding component re-reads the SMIL clock. The animation state itself + /// is re-derived from [AnimationTime#now()] on each paint, so there is + /// nothing to advance imperatively. + @Override + public final boolean animate() { + return animated; + } + + /// Generated implementations render the SVG content using the supplied + /// graphics context. `elapsedMs` is the number of milliseconds since the + /// first paint of this image instance, measured against + /// [AnimationTime#now()] so test code can pin the clock. + /// + /// #### Parameters + /// + /// - `g`: the graphics context, already transformed so SVG user-space + /// coordinates map onto the destination rectangle + /// + /// - `elapsedMs`: animation time in milliseconds, `0` for non-animated SVGs + protected abstract void paintSVG(Graphics g, long elapsedMs); + + @Override + protected final void drawImage(Graphics g, Object nativeGraphics, int x, int y) { + drawImage(g, nativeGraphics, x, y, width, height); + } + + @Override + protected final void drawImage(Graphics g, Object nativeGraphics, + int x, int y, int w, int h) { + if (!g.isShapeSupported()) { + return; + } + long elapsed = currentAnimationOffsetMs(); + + Transform saved = null; + try { + saved = g.getTransform(); + } catch (Throwable ignored) { + saved = null; + } + int savedColor = g.getColor(); + int savedAlpha = g.getAlpha(); + boolean savedAA = g.isAntiAliased(); + try { + // Anti-alias every SVG render. Vector shapes drawn without AA + // look stair-stepped on every port we ship, and the perf cost + // on modern hardware is negligible. + g.setAntiAliased(true); + float sx = (float) w / viewBoxWidth; + float sy = (float) h / viewBoxHeight; + Transform t; + if (saved != null) { + t = saved.copy(); + } else { + t = Transform.makeIdentity(); + } + t.translate((float) x, (float) y); + t.scale(sx, sy); + t.translate(-viewBoxX, -viewBoxY); + g.setTransform(t); + paintSVG(g, elapsed); + } finally { + if (saved != null) { + g.setTransform(saved); + } else { + g.setTransform(Transform.makeIdentity()); + } + g.setColor(savedColor); + g.setAlpha(savedAlpha); + g.setAntiAliased(savedAA); + } + } + + /// Returns a lightweight view onto this image that reports `width` / + /// `height` from [#getWidth] / [#getHeight] but reuses the underlying + /// rendering. The returned image's animation clock is shared with the + /// source so progress is consistent across both views. + @Override + public final Image scaled(int width, int height) { + return new SVGScaledView(this, width, height); + } + + /// Reset the per-instance animation start so the next paint begins at + /// `t = 0`. Tests typically prefer [AnimationTime#setTime(long)] instead, + /// which controls every animation in the VM at once. + public final void resetAnimation() { + animationStartMs = -1L; + } + + /// The intrinsic SVG width before DPI scaling -- useful for tests or + /// callers that want to apply a different sizing heuristic. + public final int getIntrinsicWidth() { + return intrinsicWidth; + } + + /// The intrinsic SVG height before DPI scaling. + public final int getIntrinsicHeight() { + return intrinsicHeight; + } + + /// Compute the animation offset that the next [#paintSVG] call would see, + /// capturing the per-instance start timestamp from [AnimationTime#now()] + /// on first call. Package-visible so tests can exercise the clock without + /// needing a Graphics context with shape support; production code reaches + /// this through [#drawImage(Graphics, Object, int, int, int, int)]. + long currentAnimationOffsetMs() { + if (!animated) { + return 0L; + } + long now = AnimationTime.now(); + if (animationStartMs < 0L) { + animationStartMs = now; + } + long elapsed = now - animationStartMs; + return elapsed < 0L ? 0L : elapsed; + } + + private static int readDeviceDensitySafely() { + // Display may not be fully initialized when the image is constructed + // (e.g. during static-init of an SVGRegistry that's loaded before + // Display.init in a unit test). Fall back to DENSITY_MEDIUM, which is + // the design-time default and produces 1:1 pixels for the intrinsic + // dimensions. + try { + return Display.getInstance().getDeviceDensity(); + } catch (Throwable t) { + return CN1Constants.DENSITY_MEDIUM; + } + } + + /// Returns the source density the SVG was designed for, in + /// `CN1Constants.DENSITY_*` units. `0` means "no scaling, use intrinsic + /// pixels". CSS can override the default via `cn1-source-dpi:`. + public final int getSourceDensity() { + return sourceDensity; + } + + private static int scaleForDensity(int designPixels, int density, int sourceDensity) { + if (designPixels <= 0) { + return 1; + } + if (sourceDensity <= 0 || density <= 0 || density == sourceDensity) { + return designPixels; + } + int scaled = (int) Math.floor(((double) designPixels * density) / sourceDensity + 0.5); + return scaled < 1 ? 1 : scaled; + } + + // --------------------------------------------------------------------- + // SMIL helpers -- referenced by generated code; keep signatures stable. + // --------------------------------------------------------------------- + + /// Compute the active progress through an animation cycle, in the range + /// `[0, 1]`. Honors begin offsets, repeat counts and the SMIL fill="freeze" + /// behavior. Generated code calls this per animated attribute per paint. + public static float progress(long elapsedMs, long beginMs, long durMs, + int repeatCount, boolean freeze) { + if (durMs <= 0L) { + return freeze ? 1f : 0f; + } + long t = elapsedMs - beginMs; + if (t < 0L) { + return 0f; + } + if (repeatCount == REPEAT_INDEFINITE) { + long cycle = t % durMs; + return (float) cycle / (float) durMs; + } + long total = durMs * (long) repeatCount; + if (t >= total) { + return freeze ? 1f : 0f; + } + long cycle = t % durMs; + return (float) cycle / (float) durMs; + } + + public static float lerp(float from, float to, float t) { + return from + (to - from) * t; + } + + /// Lerp between two ARGB colors. Each channel is linearly interpolated. + public static int lerpColor(int fromArgb, int toArgb, float t) { + int fa = (fromArgb >>> 24) & 0xFF; + int fr = (fromArgb >>> 16) & 0xFF; + int fg = (fromArgb >>> 8) & 0xFF; + int fb = fromArgb & 0xFF; + int ta = (toArgb >>> 24) & 0xFF; + int tr = (toArgb >>> 16) & 0xFF; + int tg = (toArgb >>> 8) & 0xFF; + int tb = toArgb & 0xFF; + int a = round(fa + (ta - fa) * t); + int r = round(fr + (tr - fr) * t); + int g = round(fg + (tg - fg) * t); + int b = round(fb + (tb - fb) * t); + return ((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF); + } + + /// Multi-stop floating point lerp. Stops are evenly spaced in `[0, 1]`. + public static float lerpValues(float[] values, float t) { + if (values == null || values.length == 0) { + return 0f; + } + if (values.length == 1) { + return values[0]; + } + if (t <= 0f) { + return values[0]; + } + if (t >= 1f) { + return values[values.length - 1]; + } + float seg = 1f / (values.length - 1); + int i = (int) Math.floor(t / seg); + if (i >= values.length - 1) { + i = values.length - 2; + } + float local = (t - i * seg) / seg; + return values[i] + (values[i + 1] - values[i]) * local; + } + + /// Build a font for a generated SVG `` element. Always loads a + /// `native:` TrueType face (HelveticaNeue on iOS, Roboto on Android, + /// the platform default elsewhere) so the size argument is honored at + /// arbitrary pixel resolutions. Weight / style maps to the matching + /// face name because some platforms ignore the derive weight argument. + public static Font svgTextFont(float sizePixels, int styleBits) { + boolean bold = (styleBits & Font.STYLE_BOLD) != 0; + boolean italic = (styleBits & Font.STYLE_ITALIC) != 0; + String face; + if (italic && bold) { + face = "native:ItalicBold"; + } else if (italic) { + face = "native:ItalicRegular"; + } else if (bold) { + face = "native:MainBold"; + } else { + face = "native:MainRegular"; + } + Font f = Font.createTrueTypeFont(face, face); + if (f == null) { + throw new IllegalStateException( + "SVG text rendering requires the native: font scheme;" + + " platform reported no TrueType support for " + face); + } + return f.derive(sizePixels, styleBits); + } + + private static int round(float v) { + int r = (int) (v + 0.5f); + if (r < 0) { + return 0; + } + if (r > 255) { + return 255; + } + return r; + } + + /// Append an SVG elliptical arc segment to the given path using the + /// endpoint parameterization defined by the SVG 1.1 spec (appendix F.6). + /// The current point of `p` is treated as the arc's start; on return the + /// current point is the end of the arc. Decomposes into up to four + /// cubic Beziers -- a single quadrant per Bezier -- for accuracy. + public static void svgArc(com.codename1.ui.geom.GeneralPath p, + float x1, float y1, + float rx, float ry, + float xAxisRotationDeg, + boolean largeArc, boolean sweep, + float x2, float y2) { + if (rx == 0f || ry == 0f) { + p.lineTo(x2, y2); + return; + } + float arx = Math.abs(rx); + float ary = Math.abs(ry); + double phi = Math.toRadians(xAxisRotationDeg); + double cosPhi = Math.cos(phi); + double sinPhi = Math.sin(phi); + + // F.6.5.1 -- compute (x1', y1') + double dx2 = (x1 - x2) / 2.0; + double dy2 = (y1 - y2) / 2.0; + double x1p = cosPhi * dx2 + sinPhi * dy2; + double y1p = -sinPhi * dx2 + cosPhi * dy2; + + // F.6.6.2 -- ensure radii are large enough + double rx2 = arx * arx; + double ry2 = ary * ary; + double x1p2 = x1p * x1p; + double y1p2 = y1p * y1p; + double radiiCheck = x1p2 / rx2 + y1p2 / ry2; + if (radiiCheck > 1.0) { + double s = Math.sqrt(radiiCheck); + arx = (float) (s * arx); + ary = (float) (s * ary); + rx2 = arx * arx; + ry2 = ary * ary; + } + + // F.6.5.2 -- compute (cx', cy') + double sign = (largeArc == sweep) ? -1.0 : 1.0; + double sq = (rx2 * ry2 - rx2 * y1p2 - ry2 * x1p2) / (rx2 * y1p2 + ry2 * x1p2); + if (sq < 0.0) { + sq = 0.0; + } + double coef = sign * Math.sqrt(sq); + double cxp = coef * (arx * y1p / ary); + double cyp = coef * -(ary * x1p / arx); + + // F.6.5.3 -- compute (cx, cy) + double sx2 = (x1 + x2) / 2.0; + double sy2 = (y1 + y2) / 2.0; + double cx = sx2 + (cosPhi * cxp - sinPhi * cyp); + double cy = sy2 + (sinPhi * cxp + cosPhi * cyp); + + // F.6.5.4 -- start angle and sweep + double ux = (x1p - cxp) / arx; + double uy = (y1p - cyp) / ary; + double vx = (-x1p - cxp) / arx; + double vy = (-y1p - cyp) / ary; + double theta1 = vectorAngle(1.0, 0.0, ux, uy); + double deltaTheta = vectorAngle(ux, uy, vx, vy); + if (!sweep && deltaTheta > 0.0) { + deltaTheta -= 2.0 * Math.PI; + } else if (sweep && deltaTheta < 0.0) { + deltaTheta += 2.0 * Math.PI; + } + + // Split into segments small enough that the cubic approximation stays accurate. + int segments = (int) Math.ceil(Math.abs(deltaTheta) / (Math.PI / 2.0)); + if (segments < 1) { + segments = 1; + } + double dt = deltaTheta / segments; + double t = (4.0 / 3.0) * Math.tan(dt / 4.0); + + double cosTheta1 = Math.cos(theta1); + double sinTheta1 = Math.sin(theta1); + double px = x1; + double py = y1; + for (int i = 0; i < segments; i++) { + double theta2 = theta1 + dt; + double cosTheta2 = Math.cos(theta2); + double sinTheta2 = Math.sin(theta2); + double ex = cx + arx * (cosPhi * cosTheta2 - sinPhi * sinTheta2); + double ey = cy + ary * (sinPhi * cosTheta2 + cosPhi * sinTheta2); + double dx1L = -arx * sinTheta1; + double dy1L = ary * cosTheta1; + double dx2L = -arx * sinTheta2; + double dy2L = ary * cosTheta2; + double c1xL = px + t * (cosPhi * dx1L - sinPhi * dy1L); + double c1yL = py + t * (sinPhi * dx1L + cosPhi * dy1L); + double c2xL = ex - t * (cosPhi * dx2L - sinPhi * dy2L); + double c2yL = ey - t * (sinPhi * dx2L + cosPhi * dy2L); + p.curveTo((float) c1xL, (float) c1yL, + (float) c2xL, (float) c2yL, + (float) ex, (float) ey); + theta1 = theta2; + cosTheta1 = cosTheta2; + sinTheta1 = sinTheta2; + px = ex; + py = ey; + } + } + + private static double vectorAngle(double ux, double uy, double vx, double vy) { + double dot = ux * vx + uy * vy; + double len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy)); + double cos = dot / len; + if (cos < -1.0) { + cos = -1.0; + } + if (cos > 1.0) { + cos = 1.0; + } + // CLDC's java.lang.Math has no acos; use the CN1 helper. + double a = MathUtil.acos(cos); + if ((ux * vy - uy * vx) < 0.0) { + a = -a; + } + return a; + } +} diff --git a/CodenameOne/src/com/codename1/ui/SVGScaledView.java b/CodenameOne/src/com/codename1/ui/SVGScaledView.java new file mode 100644 index 0000000000..064dd7eb08 --- /dev/null +++ b/CodenameOne/src/com/codename1/ui/SVGScaledView.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + */ +package com.codename1.ui; + +/// Lightweight scaled view returned by [GeneratedSVGImage#scaled(int, int)]. +/// Reports the caller-supplied width and height from [#getWidth] / [#getHeight] +/// so component layout sees the correct size, while delegating all rendering +/// (and animation state) to the source SVG. +final class SVGScaledView extends Image { + + private final GeneratedSVGImage source; + private final int width; + private final int height; + + SVGScaledView(GeneratedSVGImage source, int width, int height) { + super(null); + if (width < 1 || height < 1) { + throw new IllegalArgumentException( + "scaled() requires positive dimensions; got width=" + width + + " height=" + height); + } + this.source = source; + this.width = width; + this.height = height; + } + + @Override + public int getWidth() { + return width; + } + + @Override + public int getHeight() { + return height; + } + + @Override + public boolean isAnimation() { + return source.isAnimation(); + } + + @Override + public boolean animate() { + return source.animate(); + } + + @Override + protected void drawImage(Graphics g, Object nativeGraphics, int x, int y) { + source.drawImage(g, nativeGraphics, x, y, width, height); + } + + @Override + protected void drawImage(Graphics g, Object nativeGraphics, int x, int y, int w, int h) { + // Honor the requested draw size rather than our reported size; the + // surrounding component may stretch us inside a different rectangle. + source.drawImage(g, nativeGraphics, x, y, w, h); + } + + @Override + public Image scaled(int width, int height) { + return new SVGScaledView(source, width, height); + } +} diff --git a/CodenameOne/src/com/codename1/ui/util/MutableResource.java b/CodenameOne/src/com/codename1/ui/util/MutableResource.java index e1a322b504..a693df4ebe 100644 --- a/CodenameOne/src/com/codename1/ui/util/MutableResource.java +++ b/CodenameOne/src/com/codename1/ui/util/MutableResource.java @@ -102,6 +102,7 @@ Image createImage(DataInputStream input) throws IOException { } } + @Override public void setImage(String name, Image value) { if (value instanceof Timeline) { throw new UnsupportedOperationException("Timeline resources are not supported in MutableResource"); diff --git a/CodenameOne/src/com/codename1/ui/util/Resources.java b/CodenameOne/src/com/codename1/ui/util/Resources.java index 3a2e5b5257..19dba4f877 100644 --- a/CodenameOne/src/com/codename1/ui/util/Resources.java +++ b/CodenameOne/src/com/codename1/ui/util/Resources.java @@ -117,6 +117,12 @@ public class Resources { private static int lastLoadedDPI; private static boolean runtimeMultiImages; private static boolean failOnMissingTruetype = true; + + /// Global image registry populated by the build-time SVG transcoder. Keyed + /// by the source filename ("home.svg") and also under the filename stem + /// ("home") so CSS-style `url(home.svg)` references and direct + /// `getImage("home")` calls both resolve to the same instance. + private static final Map generatedImages = new HashMap(); /// Hashtable containing the mapping between element types and their names in the /// resource hashtable private final HashMap resourceTypes = new HashMap(); @@ -880,9 +886,56 @@ public boolean isImage(String name) { /// /// cached image instance public Image getImage(String id) { + // The generated-image registry wins over the local resources map + // so the build-time SVG transcoder's installGlobal() call -- run + // from the per-port wiring (JavaSEPort.init reflectively, or the + // iOS / Android Stub emitted by IPhoneBuilder / AndroidGradleBuilder + // when the project contains SVGs) -- overrides the 1x1 PNG + // placeholder the CSS compiler stored under the same name. + Image gen; + synchronized (generatedImages) { + gen = generatedImages.get(id); + } + if (gen != null) { + return gen; + } return (Image) resources.get(id); } + /// Install an [Image] into this resources bundle under the given name so a + /// subsequent [#getImage(String)] returns it. Used by the build-time SVG + /// transcoder registry to inject generated images alongside the resources + /// loaded from the `.res` file. + public void setImage(String id, Image image) { + if (id == null || image == null) { + return; + } + resources.put(id, image); + resourceTypes.put(id, Byte.valueOf(MAGIC_IMAGE)); + } + + /// Add an [Image] to the global registry consulted by every + /// [#getImage(String)] call as a fallback. Intended for the + /// auto-generated `com.codename1.generated.svg.SVGRegistry` produced by + /// the SVG transcoder mojo -- application code should not normally call + /// this directly. + /// + /// Registers the image both under the supplied `id` and (if `id` ends with + /// `.svg`) under the bare filename stem so a CSS reference like + /// `url(home.svg)` and a code reference like `getImage("home")` both + /// resolve to the same instance. + public static void registerGeneratedImage(String id, Image image) { + if (id == null || image == null) { + return; + } + synchronized (generatedImages) { + generatedImages.put(id, image); + if (id.endsWith(".svg")) { + generatedImages.put(id.substring(0, id.length() - 4), image); + } + } + } + /// Returns the data resource from the file /// /// #### Parameters diff --git a/Ports/JavaSE/src/com/codename1/impl/javase/Executor.java b/Ports/JavaSE/src/com/codename1/impl/javase/Executor.java index 53f5741b38..5483d15b84 100644 --- a/Ports/JavaSE/src/com/codename1/impl/javase/Executor.java +++ b/Ports/JavaSE/src/com/codename1/impl/javase/Executor.java @@ -331,6 +331,10 @@ public void run() { @Override public void run() { try { + // JavaSEPort.init() already loads + // com.codename1.generated.svg.SVGRegistry reflectively + // when it's on the classpath, so no per-Executor + // install is needed here. m.invoke(app, new Object[]{null}); Method start = c.getMethod("start", new Class[0]); if(start.getExceptionTypes() != null && start.getExceptionTypes().length > 0) { diff --git a/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java b/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java index 0aa6ddadd7..db15e60fba 100644 --- a/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java +++ b/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java @@ -6605,11 +6605,37 @@ private void loadSkinFile(String f, JFrame frm) { } } + /** Reflectively run the build-time SVG transcoder's registry if the + * current classpath contains one. Lets desktop / simulator runs pick + * up transcoded SVGs without the per-platform Stub needing an explicit + * call -- the Stub call is omitted on JavaSE because the user's + * ${mainName}Stub doesn't know at template-expansion time whether the + * project ships any SVGs. Apps without an SVG registry are unaffected. */ + private static boolean svgRegistryInstalled; + private static void installGeneratedSvgRegistry() { + if (svgRegistryInstalled) { + return; + } + try { + Class r = Class.forName("com.codename1.generated.svg.SVGRegistry"); + r.getMethod("installGlobal").invoke(null); + } catch (ClassNotFoundException noSvgs) { + // Project ships no SVGs -- skip silently. + } catch (Throwable t) { + // Don't take init() down if the registry blows up; surface it + // but let the app keep running so missing SVGs don't blank the + // whole UI. + t.printStackTrace(); + } + svgRegistryInstalled = true; + } + /** * @inheritDoc */ public void init(Object m) { inInit = true; + installGeneratedSvgRegistry(); /* File updater = new File(System.getProperty("user.home") + File.separator + ".codenameone" + File.separator + "UpdateCodenameOne.jar"); if(!updater.exists()) { diff --git a/docs/developer-guide/SVG-Transcoder.asciidoc b/docs/developer-guide/SVG-Transcoder.asciidoc new file mode 100644 index 0000000000..d919128ead --- /dev/null +++ b/docs/developer-guide/SVG-Transcoder.asciidoc @@ -0,0 +1,224 @@ += Build-Time SVG Images +:source-highlighter: highlight.js + +The build-time SVG transcoder lets you author UI icons and +illustrations as SVG and have them rendered as native Codename One +`Image` instances on every platform (iOS, Android, JavaSE simulator, +JavaScript) without shipping a runtime SVG parser. + +== Motivation + +Codename One's older `Image.createSVG()` API depends on a per-platform +native SVG renderer that ships only on a couple of backends (J2ME and +the JavaSE simulator); iOS and Android applications fall back to PNG +multi-image buckets, giving up the resolution-independence that SVG was +designed for. The +https://github.com/codenameone/flamingo-svg-transcoder[legacy Flamingo +SVG transcoder] was a precursor to this work -- a build-time tool that +emitted Java drawing code from an SVG -- but it pre-dated CN1's affine +transform pipeline and was missing a Maven hook, CSS integration, +animations, and most of the SVG spec. + +This transcoder is its successor and covers each of those gaps. Every +SVG you drop into `src/main/css/` is parsed by `codenameone-svg-transcoder`, +emitted as a Java class that subclasses `com.codename1.ui.GeneratedSVGImage`, +and rendered through the standard `Graphics` shape API. The same vector +source produces pixel-perfect output at any size on every port. + +== Quick start + +. Drop your SVG next to `theme.css` in `src/main/css/`: ++ +[source] +---- +src/main/css/ + theme.css + home.svg +---- + +. Reference it from CSS and pin its rendered size in millimeters -- + the recommended sizing knob, since it carries unchanged across every + device DPI: ++ +[source,css] +---- +HomeIcon { + background: url(home.svg); + cn1-svg-width: 6mm; + cn1-svg-height: 6mm; + bg-type: image_scaled_fit; +} +---- + +. Build the project: ++ +[source,bash] +---- +mvn package +---- + +That's it. App code doesn't call into the registry. The transcoder +emits `com.codename1.generated.svg.SVGRegistry` only when SVGs are +present, and the per-port build wiring (`IPhoneBuilder`, +`AndroidGradleBuilder`, the JavaSE port) loads it automatically before +`init(Object)`. `Resources.getGlobalResources().getImage("home.svg")` +returns the transcoded image; CSS rules that reference the SVG by URL +pick it up via the same registry. + +== Why millimeters + +`cn1-svg-width` / `cn1-svg-height` are the sizing knob you should +reach for first. + +* A 6mm icon is 6mm tall on a 1x desktop, 6mm on a high-DPI handset, + and 6mm on a 4K tablet. The transcoder routes both values through + `Display.convertToPixels()` at install time, the same way + `font-size: 3mm` behaves elsewhere in CN1 CSS. +* SVGs in the wild routinely declare odd `width`/`height` attributes + (a 1024×1024 export of a 24×24 icon, no dimensions at all, etc.). + Pinning the rendered size in millimeters sidesteps that guesswork + -- the SVG's declared pixel size and the device DPI become + irrelevant. +* It's the only sizing mode that survives a re-export of the SVG + from the asset pipeline. `cn1-source-dpi` and the implicit + medium-density default both depend on the SVG's declared pixel + size, so a tool that rescales the source on export will change + the rendered size without any warning. + +[source,css] +---- +StarIcon { background: url(star.svg); cn1-svg-width: 4mm; cn1-svg-height: 4mm; } +PrimaryIcon { background: url(home.svg); cn1-svg-width: 6mm; cn1-svg-height: 6mm; } +LogoBanner { background: url(logo.svg); cn1-svg-width: 32mm; cn1-svg-height: 12mm; } +---- + +Use `cn1-source-dpi: ` (accepted keywords: `low`, `medium`, +`high`, `very-high`, `hd`, `560`, `2hd`, `4k`) only when an SVG has +sensible declared pixel dimensions for a known density target and you +want the rendered size to track `Display.getDeviceDensity()` instead +of millimeters. With no hint at all, the SVG's declared dimensions are +treated as design pixels at `DENSITY_MEDIUM`. + +If both keys appear on the same rule, `cn1-svg-width` / +`cn1-svg-height` wins. + +== How the build flow works + +The `cn1app` archetype binds the `transcode-svg` goal to the +`generate-sources` phase: + +[source,xml] +---- + + transcode-svg + generate-sources + + transcode-svg + + +---- + +When Maven runs the mojo: + +. It scans `src/main/css/` and `src/main/svg/` for `*.svg` files. If + there are none, the goal is a no-op -- no registry class is emitted, + no per-port stub injection happens. +. For each SVG it emits `target/generated-sources/svg/com/codename1/generated/svg/.java` + -- one class per file -- plus a single `SVGRegistry` class whose + `installGlobal()` registers every transcoded image with the global + `Resources` table. +. It scans `src/main/css/**/*.css` for `url(*.svg)` occurrences and the + enclosing rule's `cn1-svg-width` / `cn1-svg-height` / `cn1-source-dpi` + hints. Those values are baked into the registry's `installGlobal()` + call per image. +. It drops a 1×1 transparent PNG placeholder into + `target/css-resources/` so the standalone CSS compiler can finish + even though the file extension on the URL is `.svg`. The placeholder + is overwritten in the theme by the runtime registry call. + +The simulator / desktop ports load `SVGRegistry` reflectively, so a +project that adds its first SVG today rebuilds and runs without any +code change. The iOS and Android builders detect the generated class +in the user's compile output and weave `installGlobal()` into the +generated `Stub` right before the first `init(Object)`; a project with +no SVGs gets no weaving. + +== Calling the registry yourself + +If you don't use `theme.css` but still want a transcoded SVG, construct +the generated class directly: + +[source,java] +---- +Image home = new com.codename1.generated.svg.Home(6f, 6f); // 6mm × 6mm +button.setIcon(home); +---- + +Constructors come in three flavours, matching the three CSS sizing +mechanisms above. The two-`float` constructor takes millimeters; that's +the one to prefer for the reasons in the previous section. + +[source,java] +---- +public Home(float widthMm, float heightMm) { ... } // for cn1-svg-width / cn1-svg-height +public Home(int sourceDensity) { ... } // for cn1-source-dpi hints +public Home() { ... } // default DENSITY_MEDIUM source +---- + +`scaled(int, int)` returns a lightweight view that reports the +requested dimensions from `getWidth()` / `getHeight()` and shares the +animation clock with its source. + +== SVG feature coverage + +The transcoder targets the SVG 1.1 static-shape vocabulary plus the +SMIL animation subset: + +|=== +| Feature | Status + +| ``, ``, ``, ``, ``, `` | Full +| `` (M/L/H/V/C/S/Q/T/A/Z, relative + smooth-curve reflection) | Full +| `` with `transform="translate \| scale \| rotate \| skew \| matrix"` | Full +| `fill`, `stroke`, `stroke-width`, `stroke-linecap/linejoin/miterlimit` | Full +| `opacity`, `fill-opacity`, `stroke-opacity` | Full (animatable) +| `` | Full (shape-clipped fill on every port) +| `` | First-stop fallback +| `` (numeric attributes) | Full +| `` | Full +| `` (instant value snap) | Full +| `` / `` (single-style fills, transforms) | Supported +| `` referenced via `clip-path="url(#id)"` | Supported (rect/circle/path); nested clip refs ignored +| `` | Treated as clip -- alpha masking falls back to opaque +| SVG `filter` primitives | Not supported +| CSS-keyframe animations | Not supported (SMIL only) +|=== + +SMIL animations read the current time from +`com.codename1.ui.animations.AnimationTime`, so tests can pin the +clock with `AnimationTime.setTime(t)` to capture a deterministic +frame. Animated SVGs return `true` from `Image.isAnimation()` -- as +with `Timeline`, you must register the image with a `Form`'s animation +manager (or set it as a `Component.setIcon` with `isAnimation()` true) +for the repaint loop to tick the SMIL clock. + +== Troubleshooting + +`Resources.getImage("name.svg")` returns null or a 1×1 transparent PNG:: + The transcoder didn't run, or it ran with zero SVGs. Confirm the SVG + lives under `src/main/css/` (or `src/main/svg/`) and that the + `transcode-svg` goal is bound in the project POM. For arbitrary + Resources bundles loaded outside the global slot, call + `com.codename1.ui.util.Resources.registerGeneratedImage(name, image)` + yourself with a fresh `new com.codename1.generated.svg.YourSvg(widthMm, heightMm)`. + +SVG looks the wrong size:: + Switch the rule to `cn1-svg-width` / `cn1-svg-height` in millimeters. + The other sizing modes depend on the SVG's declared pixel size, which + is what's biting you here. + +Spinner / pulse renders but doesn't animate:: + Check that the image is mounted into a `Component` whose animation + manager ticks (`Labels` added to a `Form` do this automatically). For + a pure-`Graphics`-driven capture (screenshot tests) pin + `AnimationTime.setTime(...)` and re-render. diff --git a/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml b/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml index e8405cf321..48f44b9c85 100644 --- a/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml +++ b/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml @@ -358,6 +358,19 @@ codenameone-maven-plugin + + + transcode-svg + generate-sources + + transcode-svg + + generate-gui-sources process-sources diff --git a/maven/codenameone-maven-plugin/pom.xml b/maven/codenameone-maven-plugin/pom.xml index 0c0719bcbd..11153bccbb 100644 --- a/maven/codenameone-maven-plugin/pom.xml +++ b/maven/codenameone-maven-plugin/pom.xml @@ -49,6 +49,11 @@ codenameone-designer jar-with-dependencies + + ${project.groupId} + codenameone-svg-transcoder + ${project.version} + org.apache.maven maven-plugin-api diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/AndroidGradleBuilder.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/AndroidGradleBuilder.java index 4e66757796..5ab90c0c24 100644 --- a/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/AndroidGradleBuilder.java +++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/AndroidGradleBuilder.java @@ -2931,6 +2931,17 @@ public void usesClassMethod(String cls, String method) { File stubFileSourceFile = new File(stubFileSourceDir, request.getMainClass() + "Stub.java"); + + // If the build-time SVG transcoder produced a registry class, weave + // its installGlobal() call into the Stub right before the first + // i.init(this) so theme.getImage("foo.svg") returns the transcoded + // SVG immediately. Skipped silently for apps without any SVGs. + String svgRegistryInstall = ""; + File svgRegistryClassFile = new File(dummyClassesDir, + "com/codename1/generated/svg/SVGRegistry.class"); + if (svgRegistryClassFile.isFile()) { + svgRegistryInstall = " com.codename1.generated.svg.SVGRegistry.installGlobal();\n"; + } String consumableCode; consumableCode = "public boolean isConsumable(String sku) {\n" + " boolean retVal = super.isConsumable(sku);\n" @@ -3211,6 +3222,7 @@ public void usesClassMethod(String cls, String method) { + " public void run(Form currentForm, boolean wasStopped) {\n" + " if(firstTime) {\n" + " firstTime = false;\n" + + svgRegistryInstall + " i.init(this);\n" + fcmRegisterPushCode + " } else {\n" diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/IPhoneBuilder.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/IPhoneBuilder.java index 51f93d1907..a7da3de126 100644 --- a/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/IPhoneBuilder.java +++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/IPhoneBuilder.java @@ -1125,6 +1125,17 @@ public void usesClassMethod(String cls, String method) { disableScreenshots = " Display.getInstance().setProperty(\"DisableScreenshots\", \"true\");\n"; } + // If the build-time SVG transcoder produced a registry class, weave + // its installGlobal() call into the Stub right before the first + // init(Object) so theme.getImage("foo.svg") returns the transcoded + // SVG immediately. Skipped silently for apps that have no SVGs. + String svgRegistryInstall = ""; + File svgRegistryClassFile = new File(classesDir, + "com/codename1/generated/svg/SVGRegistry.class"); + if (svgRegistryClassFile.isFile()) { + svgRegistryInstall = " com.codename1.generated.svg.SVGRegistry.installGlobal();\n"; + } + String didEnterBackground = " stopped = true;\n" + " final long bgTask = com.codename1.impl.ios.IOSImplementation.beginBackgroundTask();\n" + " Display.getInstance().callSerially(new Runnable() { \n" @@ -1169,6 +1180,7 @@ public void usesClassMethod(String cls, String method) { + " if(!initialized) {\n" + " initialized = true;\n" + + svgRegistryInstall + " i.init(this);\n" + createStartInvocation(request, "i") + " } else {\n" diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/TranscodeSVGMojo.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/TranscodeSVGMojo.java new file mode 100644 index 0000000000..f3249812db --- /dev/null +++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/TranscodeSVGMojo.java @@ -0,0 +1,410 @@ +package com.codename1.maven; + +import com.codename1.svg.transcoder.SVGTranscoder; +import com.codename1.svg.transcoder.SVGTranscoder.GeneratedClass; + +import org.apache.maven.plugin.MojoExecutionException; +import org.apache.maven.plugin.MojoFailureException; +import org.apache.maven.plugins.annotations.LifecyclePhase; +import org.apache.maven.plugins.annotations.Mojo; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; + +import java.io.BufferedWriter; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.io.Reader; +import java.io.Writer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Scans an application module for SVG files, transcodes each into a + * {@code com.codename1.ui.GeneratedSVGImage} subclass under + * {@code target/generated-sources/svg}, and emits a registry class that + * installs each transcoded image into a Resources instance (and the global + * fallback) under its source filename. + * + *

Source layout

+ * SVG files are picked up from both {@code src/main/css/} and + * {@code src/main/svg/}. Drop your SVGs next to the CSS file that references + * them; the mojo finds them either way. Theme CSS keeps the natural + * {@code background: url(spinner.svg);} reference. + * + *

CSS hints

+ * For each {@code url(*.svg)} occurrence the mojo also looks at the rule's + * {@code cn1-source-dpi:} declaration (the same hint used for multi-images). + * The transcoded SVG is then constructed with that source density so its + * intrinsic dimensions scale to the device-pixel size CN1 multi-images + * normally produce. Without a {@code cn1-source-dpi} the SVG's declared + * dimensions are treated as design pixels at {@code DENSITY_MEDIUM}. + * + *

CSS placeholders

+ * To keep the standalone CSS compiler from failing on the {@code .svg} URL + * (it expects to rasterize the referenced file), the mojo emits a 1x1 + * transparent PNG next to each CSS-referenced SVG. The placeholder lands in + * {@code target/css-resources/} (a directory added to the compile-time CSS + * search path); the runtime SVGRegistry's {@code install()} then overrides + * the placeholder entry in the resources bundle with the real transcoded + * SVG instance. + */ +@Mojo(name = "transcode-svg", defaultPhase = LifecyclePhase.GENERATE_SOURCES, + requiresDependencyResolution = ResolutionScope.NONE, + requiresDependencyCollection = ResolutionScope.NONE) +public class TranscodeSVGMojo extends AbstractCN1Mojo { + + private static final String[] DEFAULT_SVG_DIRS = { "src/main/svg", "src/main/css" }; + + private static final String DEFAULT_PACKAGE = "com.codename1.generated.svg"; + + private static final String REGISTRY_CLASS_NAME = "SVGRegistry"; + + /** 1x1 transparent PNG (43 bytes). Used as a placeholder so the CSS + * compiler resolves {@code url(*.svg)} references without trying to + * rasterize the SVG XML. */ + private static final byte[] PLACEHOLDER_PNG = new byte[] { + (byte)0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, + 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, (byte)0xC4, + (byte)0x89, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x44, 0x41, + 0x54, 0x78, (byte)0x9C, 0x62, 0x00, 0x01, 0x00, 0x00, + 0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, (byte)0xB4, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, (byte)0xAE, + 0x42, 0x60, (byte)0x82 + }; + + @Parameter(property = "cn1.svg.sourceDirs") + private List svgSourceDirs; + + @Parameter(property = "cn1.svg.outputDir", + defaultValue = "${project.build.directory}/generated-sources/svg") + private File svgOutputDir; + + @Parameter(property = "cn1.svg.placeholderDir", + defaultValue = "${project.build.directory}/css-resources") + private File svgPlaceholderDir; + + @Parameter(property = "cn1.svg.package", defaultValue = DEFAULT_PACKAGE) + private String svgPackage; + + @Override + protected void executeImpl() throws MojoExecutionException, MojoFailureException { + List svgs = locateSvgs(); + Map cssHints = scanCssHints(); + + if (svgs.isEmpty() && !cssHints.isEmpty()) { + getLog().warn("CSS references " + cssHints.size() + + " SVG(s) but no .svg files were found under " + + String.join(", ", effectiveSourceDirs())); + } + + File packageDir = new File(svgOutputDir, svgPackage.replace('.', '/')); + long registrySrcMtime = lastModified(svgs); + List generated = new ArrayList(); + Set usedClassNames = new HashSet(); + + if (svgs.isEmpty()) { + // No SVGs in this project -- skip the registry entirely so the + // per-platform Stub injection (IPhoneBuilder / AndroidGradleBuilder + // checking for SVGRegistry.class) stays a no-op. JavaSE Executor's + // dynamic load also tolerates the absence. Sweep a leftover from a + // previous build so a stale class doesn't trick the .isFile() check. + File leftover = new File(packageDir, REGISTRY_CLASS_NAME + ".java"); + if (leftover.exists()) { + leftover.delete(); + } + emitPlaceholders(cssHints.keySet()); + registerSourceRoot(); + return; + } + + packageDir.mkdirs(); + for (File svg : svgs) { + String resourceName = svg.getName(); + String className = uniqueClassName(SVGTranscoder.classNameFor(resourceName), usedClassNames); + usedClassNames.add(className); + File outFile = new File(packageDir, className + ".java"); + if (outFile.exists() && outFile.lastModified() >= svg.lastModified()) { + getLog().debug("SVG transcoder up-to-date for " + svg.getName()); + } else { + getLog().info("Transcoding SVG " + svg.getName() + " -> " + className + ".java"); + try { + SVGTranscoder.transcode(svg, svgPackage, className, outFile); + } catch (IOException ex) { + throw new MojoExecutionException("Failed to transcode " + svg, ex); + } + } + CssHint hint = cssHints.get(resourceName); + int sourceDensity = hint == null ? 0 : hint.sourceDensity; + float widthMm = hint == null ? 0f : hint.widthMm; + float heightMm = hint == null ? 0f : hint.heightMm; + generated.add(new GeneratedClass(svgPackage, className, resourceName, + sourceDensity, widthMm, heightMm)); + } + + emitRegistry(packageDir, generated, registrySrcMtime); + emitPlaceholders(cssHints.keySet()); + registerSourceRoot(); + } + + /** Walks {@link #effectiveSourceDirs} for *.svg files. */ + private List locateSvgs() { + Map byName = new LinkedHashMap(); + for (String dir : effectiveSourceDirs()) { + File d = new File(project.getBasedir(), dir); + if (!d.isDirectory()) continue; + List found = new ArrayList(); + collect(d, found); + for (File f : found) { + // First occurrence wins -- src/main/svg beats src/main/css if a + // name collides, mirroring how Java classpath resolution would + // pick the higher-priority root. + byName.putIfAbsent(f.getName(), f); + } + } + List svgs = new ArrayList(byName.values()); + svgs.sort(new Comparator() { + @Override public int compare(File a, File b) { return a.getName().compareTo(b.getName()); } + }); + return svgs; + } + + private List effectiveSourceDirs() { + if (svgSourceDirs != null && !svgSourceDirs.isEmpty()) { + return svgSourceDirs; + } + return Arrays.asList(DEFAULT_SVG_DIRS); + } + + /** Holds the CSS-declared sizing hints for one SVG. Either / both fields + * may be unset (0 / 0f) -- the generator picks the right constructor + * variant based on which fields actually have values. */ + private static final class CssHint { + int sourceDensity; + float widthMm; + float heightMm; + } + + /** Scans theme CSS files for {@code url(*.svg)} together with the + * enclosing rule's {@code cn1-source-dpi} / {@code cn1-svg-width} / + * {@code cn1-svg-height}. Returns a map of svgFilename -> CssHint. */ + private Map scanCssHints() throws MojoExecutionException { + Map result = new HashMap(); + File cssDir = new File(project.getBasedir(), "src/main/css"); + if (!cssDir.isDirectory()) { + return result; + } + List cssFiles = new ArrayList(); + collectCss(cssDir, cssFiles); + Pattern blockPattern = Pattern.compile("\\{([^}]*)\\}", Pattern.DOTALL); + Pattern svgUrlPattern = Pattern.compile( + "url\\(\\s*['\"]?\\s*([^'\")\\s]+?\\.svg)\\s*['\"]?\\s*\\)", + Pattern.CASE_INSENSITIVE); + Pattern dpiPattern = Pattern.compile( + "cn1-source-dpi\\s*:\\s*([\\w-]+)\\s*;?", + Pattern.CASE_INSENSITIVE); + Pattern widthMmPattern = Pattern.compile( + "cn1-svg-width\\s*:\\s*([\\d.]+)\\s*mm\\s*;?", + Pattern.CASE_INSENSITIVE); + Pattern heightMmPattern = Pattern.compile( + "cn1-svg-height\\s*:\\s*([\\d.]+)\\s*mm\\s*;?", + Pattern.CASE_INSENSITIVE); + for (File css : cssFiles) { + String content; + try { + content = readFile(css); + } catch (IOException ex) { + throw new MojoExecutionException("Failed to read CSS " + css, ex); + } + Matcher blocks = blockPattern.matcher(content); + while (blocks.find()) { + String block = blocks.group(1); + Matcher dpis = dpiPattern.matcher(block); + int dpi = dpis.find() ? densityForCssValue(dpis.group(1)) : 0; + Matcher widths = widthMmPattern.matcher(block); + float wMm = widths.find() ? parsePositiveFloat(widths.group(1)) : 0f; + Matcher heights = heightMmPattern.matcher(block); + float hMm = heights.find() ? parsePositiveFloat(heights.group(1)) : 0f; + Matcher svgUrls = svgUrlPattern.matcher(block); + while (svgUrls.find()) { + String name = trimToFileName(svgUrls.group(1)); + CssHint hint = result.computeIfAbsent(name, k -> new CssHint()); + // A more-specific declaration always wins; otherwise keep + // whatever was set by an earlier rule. + if (dpi != 0) hint.sourceDensity = dpi; + if (wMm > 0f) hint.widthMm = wMm; + if (hMm > 0f) hint.heightMm = hMm; + } + } + } + // If only one of width/height was specified, derive the other from + // the SVG's natural aspect ratio at registry-emit time. For now we + // leave aspect derivation to the runtime by treating a single-axis + // declaration as "use that axis, ignore mm on the other". + return result; + } + + private static float parsePositiveFloat(String s) { + try { + float f = Float.parseFloat(s.trim()); + return f > 0f ? f : 0f; + } catch (NumberFormatException nfe) { + return 0f; + } + } + + /** Drop a 1x1 transparent PNG under each referenced SVG name so the CSS + * compiler's url(...) resolver succeeds. We also put the original + * SVG-named copy alongside in case the compiler insists on the .svg + * extension. */ + private void emitPlaceholders(Set names) throws MojoExecutionException { + if (names.isEmpty()) { + return; + } + if (!svgPlaceholderDir.isDirectory() && !svgPlaceholderDir.mkdirs()) { + getLog().warn("Could not create placeholder dir " + svgPlaceholderDir); + return; + } + for (String name : names) { + File out = new File(svgPlaceholderDir, name); + if (!out.exists() || out.length() != PLACEHOLDER_PNG.length) { + try (FileOutputStream fos = new FileOutputStream(out)) { + fos.write(PLACEHOLDER_PNG); + } catch (IOException ex) { + throw new MojoExecutionException("Failed to write placeholder " + out, ex); + } + } + } + getLog().debug("Wrote " + names.size() + " SVG placeholder PNG(s) to " + svgPlaceholderDir); + } + + private void emitRegistry(File packageDir, List generated, long mtime) throws MojoExecutionException { + File registryFile = new File(packageDir, REGISTRY_CLASS_NAME + ".java"); + if (registryFile.exists() && registryFile.lastModified() >= mtime) { + getLog().debug("SVG registry up-to-date."); + return; + } + try (Writer w = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(registryFile), "UTF-8"))) { + SVGTranscoder.writeRegistry(svgPackage, REGISTRY_CLASS_NAME, generated, w); + } catch (IOException ex) { + throw new MojoExecutionException("Failed to write SVG registry", ex); + } + getLog().info("Wrote SVG registry " + registryFile.getName() + " with " + generated.size() + " image(s)"); + } + + /** Map a {@code cn1-source-dpi} CSS keyword or number to a density code. + * Mirrors the keyword set the CN1 CSS compiler accepts for multi-image + * density buckets. */ + private static int densityForCssValue(String value) { + if (value == null) { + return 0; + } + String v = value.trim().toLowerCase().replace('_', '-'); + switch (v) { + case "very-low": return 10; // CN1Constants.DENSITY_VERY_LOW + case "low": return 20; + case "medium": return 30; + case "high": return 40; + case "very-high": return 50; + case "hd": return 60; + case "560": return 65; + case "2hd": return 70; + case "4k": return 80; + default: + try { + return Integer.parseInt(v); + } catch (NumberFormatException nfe) { + return 0; + } + } + } + + private static String trimToFileName(String url) { + int slash = Math.max(url.lastIndexOf('/'), url.lastIndexOf('\\')); + return slash < 0 ? url : url.substring(slash + 1); + } + + private static String uniqueClassName(String base, Set taken) { + if (!taken.contains(base)) return base; + int n = 2; + while (taken.contains(base + n)) n++; + return base + n; + } + + private void registerSourceRoot() { + String path = svgOutputDir.getAbsolutePath(); + if (!project.getCompileSourceRoots().contains(path)) { + project.addCompileSourceRoot(path); + getLog().debug("Added compile source root " + path); + } + } + + private static void collect(File dir, List out) { + File[] entries = dir.listFiles(); + if (entries == null) { + return; + } + Arrays.sort(entries, new Comparator() { + @Override public int compare(File a, File b) { return a.getName().compareTo(b.getName()); } + }); + for (File f : entries) { + if (f.isDirectory()) { + collect(f, out); + } else if (f.getName().toLowerCase().endsWith(".svg")) { + out.add(f); + } + } + } + + private static void collectCss(File dir, List out) { + File[] entries = dir.listFiles(); + if (entries == null) { + return; + } + for (File f : entries) { + if (f.isDirectory()) { + collectCss(f, out); + } else if (f.getName().toLowerCase().endsWith(".css")) { + out.add(f); + } + } + } + + private static String readFile(File f) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + try (Reader r = new InputStreamReader(new FileInputStream(f), "UTF-8")) { + char[] buf = new char[4096]; + StringBuilder sb = new StringBuilder(); + int n; + while ((n = r.read(buf)) > 0) { + sb.append(buf, 0, n); + } + return sb.toString(); + } + } + + private static long lastModified(List files) { + long max = 0; + for (File f : files) { + if (f.lastModified() > max) { + max = f.lastModified(); + } + } + return max; + } +} diff --git a/maven/core-unittests/src/test/java/com/codename1/ui/GeneratedSVGImageTest.java b/maven/core-unittests/src/test/java/com/codename1/ui/GeneratedSVGImageTest.java new file mode 100644 index 0000000000..eb75d7442f --- /dev/null +++ b/maven/core-unittests/src/test/java/com/codename1/ui/GeneratedSVGImageTest.java @@ -0,0 +1,282 @@ +package com.codename1.ui; + +import com.codename1.junit.FormTest; +import com.codename1.junit.UITestBase; +import com.codename1.ui.animations.AnimationTime; +import com.codename1.ui.geom.GeneralPath; +import org.junit.jupiter.api.AfterEach; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * CI-wired coverage of the {@link GeneratedSVGImage} runtime that the + * build-time SVG transcoder targets. Exercises: + * + *
    + *
  • DPI-aware default sizing -- the constructor scales the SVG-declared + * width/height by the device density relative to DENSITY_MEDIUM.
    • + *
  • {@link GeneratedSVGImage#scaled(int, int)} -- returns a view whose + * {@code getWidth}/{@code getHeight} report the caller-supplied + * dimensions so layout sees the right size.
    • + *
  • {@link AnimationTime}-driven animation time -- with the clock pinned + * the per-instance start timestamp is deterministic and {@code paintSVG} + * observes a known elapsed offset.
    • + *
  • The static SMIL helpers ({@code progress}, {@code lerp}, + * {@code lerpColor}, {@code lerpValues}, {@code svgArc}) consumed by + * generated code.
    • + *
+ */ +public class GeneratedSVGImageTest extends UITestBase { + + @AfterEach + void releaseAnimationClock() { + AnimationTime.reset(); + } + + @FormTest + public void intrinsicSizeIsRecorded() { + RecordingSVG img = new RecordingSVG(24, 24); + assertEquals(24, img.getIntrinsicWidth(), + "constructor preserves the SVG-declared width as intrinsic"); + assertEquals(24, img.getIntrinsicHeight(), + "constructor preserves the SVG-declared height as intrinsic"); + } + + @FormTest + public void defaultSizeScalesWithDensity() { + // At DENSITY_MEDIUM the displayed size equals the intrinsic size. + // On higher-density devices it scales up proportionally. + int density = Display.getInstance().getDeviceDensity(); + RecordingSVG img = new RecordingSVG(24, 24); + int expected = Math.max(1, + (int) Math.floor((24.0 * density) / CN1Constants.DENSITY_MEDIUM + 0.5)); + assertEquals(expected, img.getWidth(), + "getWidth reflects DPI-scaled intrinsic width at density " + density); + assertEquals(expected, img.getHeight(), + "getHeight reflects DPI-scaled intrinsic height at density " + density); + } + + @FormTest + public void scaledReportsRequestedDimensions() { + RecordingSVG img = new RecordingSVG(24, 24); + Image small = img.scaled(8, 12); + assertNotSame(img, small, "scaled() must return a distinct view"); + assertEquals(8, small.getWidth(), "scaled view reports the requested width"); + assertEquals(12, small.getHeight(), "scaled view reports the requested height"); + // The source's own dimensions are not mutated. + assertEquals(img.getWidth(), new RecordingSVG(24, 24).getWidth()); + } + + @FormTest + public void scaledViewDelegatesAnimationFlag() { + RecordingSVG animated = new RecordingSVG(24, 24, true); + Image scaled = animated.scaled(32, 32); + assertTrue(scaled.isAnimation(), "scaled view inherits the animation flag"); + assertTrue(scaled.animate(), "scaled view requests repaints when animated"); + } + + @FormTest + public void explicitPixelDimensionsOverrideDensityHeuristic() { + // The cn1-svg-width / cn1-svg-height -> mm -> pixels path lands on the + // (intrinsic..., int, int) constructor. The reported size is exactly + // what was passed, regardless of intrinsic SVG dimensions or device + // density. + RecordingSVG img = new RecordingSVG(24, 24, false, 64, 48); + assertEquals(64, img.getWidth()); + assertEquals(48, img.getHeight()); + } + + @FormTest + public void mmToPixelsHonorsDeviceDpi() { + // mmToPixels is the helper the generated mm-constructor uses. It + // routes through Display.convertToPixels(float) so the result tracks + // the device's actual DPI. We can't assert exact pixels (depends on + // density) but the result must be >= 1 and grow with mm. + int small = GeneratedSVGImage.mmToPixels(1f); + int large = GeneratedSVGImage.mmToPixels(20f); + assertTrue(small >= 1, "1mm always rounds to at least 1 pixel"); + assertTrue(large > small, "20mm produces more pixels than 1mm"); + } + + @FormTest + public void scaledViewChainsToFreshViewWithoutLeakingDimensions() { + // scaled(a).scaled(b) must report b's dimensions; the intermediate a + // shouldn't haunt the inner view. + RecordingSVG img = new RecordingSVG(24, 24); + Image inner = img.scaled(40, 40).scaled(16, 16); + assertEquals(16, inner.getWidth()); + assertEquals(16, inner.getHeight()); + } + + @FormTest + public void animationClockDrivenByAnimationTime() { + // Pin the clock so the first-paint timestamp is deterministic. + AnimationTime.setTime(5_000L); + RecordingSVG img = new RecordingSVG(10, 10, true); + // currentAnimationOffsetMs() captures the start time on first call, + // mirroring what drawImage() does at the start of every paint. + assertEquals(0L, img.currentAnimationOffsetMs(), + "first paint sees zero elapsed (clock = start time)"); + + AnimationTime.setTime(5_750L); + assertEquals(750L, img.currentAnimationOffsetMs(), + "subsequent paint sees the AnimationTime delta from the first paint"); + + // Rewinding the clock clamps elapsed to zero (no negative time). + AnimationTime.setTime(4_000L); + assertEquals(0L, img.currentAnimationOffsetMs(), + "rewound clock clamps elapsed to zero"); + } + + @FormTest + public void resetAnimationDropsTheFirstPaintTimestamp() { + AnimationTime.setTime(1_000L); + RecordingSVG img = new RecordingSVG(10, 10, true); + img.currentAnimationOffsetMs(); + AnimationTime.setTime(1_500L); + assertEquals(500L, img.currentAnimationOffsetMs()); + + img.resetAnimation(); + // After reset the next call becomes the new t=0. + AnimationTime.setTime(2_000L); + assertEquals(0L, img.currentAnimationOffsetMs()); + + AnimationTime.setTime(2_250L); + assertEquals(250L, img.currentAnimationOffsetMs()); + } + + @FormTest + public void nonAnimatedAlwaysReportsZeroElapsed() { + AnimationTime.setTime(10_000L); + RecordingSVG img = new RecordingSVG(10, 10, false); + assertEquals(0L, img.currentAnimationOffsetMs()); + AnimationTime.setTime(20_000L); + assertEquals(0L, img.currentAnimationOffsetMs(), + "non-animated SVGs ignore the SMIL clock"); + } + + // --------------------------------------------------------------------- + // Static SMIL helpers + // --------------------------------------------------------------------- + + @FormTest + public void progressClampsBeforeBegin() { + assertEquals(0f, GeneratedSVGImage.progress(50L, 200L, 1000L, 1, false)); + } + + @FormTest + public void progressLinearWithinCycle() { + assertEquals(0.5f, GeneratedSVGImage.progress(500L, 0L, 1000L, 1, false), 1e-6f); + } + + @FormTest + public void progressFreezeHoldsLastValueWhenDone() { + assertEquals(1f, GeneratedSVGImage.progress(2000L, 0L, 1000L, 1, true)); + } + + @FormTest + public void progressNoFreezeReturnsZeroPastEnd() { + assertEquals(0f, GeneratedSVGImage.progress(2000L, 0L, 1000L, 1, false)); + } + + @FormTest + public void progressIndefiniteWraps() { + assertEquals(0.25f, GeneratedSVGImage.progress(1250L, 0L, 1000L, + GeneratedSVGImage.REPEAT_INDEFINITE, false), 1e-6f); + } + + @FormTest + public void lerpLinear() { + assertEquals(0f, GeneratedSVGImage.lerp(0f, 100f, 0f)); + assertEquals(100f, GeneratedSVGImage.lerp(0f, 100f, 1f)); + assertEquals(25f, GeneratedSVGImage.lerp(0f, 100f, 0.25f)); + } + + @FormTest + public void lerpColorChannelByChannel() { + int mid = GeneratedSVGImage.lerpColor(0xFF000000, 0xFFFFFFFF, 0.5f); + // Each channel should be ~0x80 + assertEquals(0xFF, (mid >>> 24) & 0xFF); + assertEquals(0x80, (mid >>> 16) & 0xFF); + assertEquals(0x80, (mid >>> 8) & 0xFF); + assertEquals(0x80, mid & 0xFF); + } + + @FormTest + public void lerpValuesEvenlySpaced() { + float[] stops = new float[]{0f, 10f, 20f}; + // t=0 -> first stop, t=1 -> last stop, t=0.5 -> middle stop + assertEquals(0f, GeneratedSVGImage.lerpValues(stops, 0f)); + assertEquals(20f, GeneratedSVGImage.lerpValues(stops, 1f)); + assertEquals(10f, GeneratedSVGImage.lerpValues(stops, 0.5f), 1e-5f); + // Halfway between stop 0 and stop 1 + assertEquals(5f, GeneratedSVGImage.lerpValues(stops, 0.25f), 1e-5f); + } + + @FormTest + public void svgArcAppendsCubicSegments() { + // 90-degree quarter circle in the upper-right quadrant. + GeneralPath path = new GeneralPath(); + path.moveTo(10f, 0f); + GeneratedSVGImage.svgArc(path, + 10f, 0f, // start (current point) + 10f, 10f, // rx, ry + 0f, // x-axis rotation + false, true, // largeArc=0, sweep=1 + 0f, 10f); // end + // We don't have a way to inspect the cubic segments directly without + // a PathIterator round-trip, but the end-point should be at (0, 10). + float[] bounds = new float[4]; + path.getBounds2D(bounds); + // Bounds should at least include the start and end and not extend + // wildly outside the unit circle. + assertTrue(bounds[0] <= 0f + 0.01f, "bounds x reaches the end x"); + assertTrue(bounds[1] <= 0f + 0.01f, "bounds y reaches the start y"); + assertTrue(bounds[0] + bounds[2] >= 10f - 0.01f, "bounds reach the start x"); + assertTrue(bounds[1] + bounds[3] >= 10f - 0.01f, "bounds reach the end y"); + } + + @FormTest + public void svgArcDegeneratesToLineForZeroRadius() { + GeneralPath path = new GeneralPath(); + path.moveTo(0f, 0f); + GeneratedSVGImage.svgArc(path, 0f, 0f, 0f, 0f, 0f, false, false, 10f, 10f); + float[] bounds = new float[4]; + path.getBounds2D(bounds); + assertEquals(0f, bounds[0]); + assertEquals(0f, bounds[1]); + assertEquals(10f, bounds[2], 1e-4f); + assertEquals(10f, bounds[3], 1e-4f); + } + + /** + * Concrete subclass used to inspect what paintSVG sees and how + * dimensions are reported, without needing a real generated class. + */ + static final class RecordingSVG extends GeneratedSVGImage { + long lastElapsedMs = Long.MIN_VALUE; + int paintCalls; + + RecordingSVG(int w, int h) { + this(w, h, false); + } + + RecordingSVG(int w, int h, boolean animated) { + super(w, h, 0f, 0f, w, h, animated); + } + + RecordingSVG(int intrinsicW, int intrinsicH, boolean animated, + int explicitW, int explicitH) { + super(intrinsicW, intrinsicH, 0f, 0f, intrinsicW, intrinsicH, + animated, explicitW, explicitH); + } + + @Override + protected void paintSVG(Graphics g, long elapsedMs) { + this.lastElapsedMs = elapsedMs; + this.paintCalls++; + } + } +} diff --git a/maven/css-compiler/src/main/java/com/codename1/designer/css/CSSTheme.java b/maven/css-compiler/src/main/java/com/codename1/designer/css/CSSTheme.java index fab7593345..c105f365be 100644 --- a/maven/css-compiler/src/main/java/com/codename1/designer/css/CSSTheme.java +++ b/maven/css-compiler/src/main/java/com/codename1/designer/css/CSSTheme.java @@ -2904,6 +2904,35 @@ private boolean isFileURL(URL url) { public Image getBorderImage(Map styles) { return getBackgroundImage(styles, (ScaledUnit)styles.get("border-image")); } + + /// 1x1 transparent PNG (43 bytes) -- used to satisfy the EditableResources + /// image slot when a CSS rule references an SVG by URL. The runtime + /// {@code com.codename1.generated.svg.SVGRegistry} (emitted by the SVG + /// transcoder mojo when the project contains any SVGs) replaces the + /// placeholder with the transcoded image when its {@code installGlobal()} + /// runs at startup. + private static final byte[] SVG_PLACEHOLDER_PNG = new byte[] { + (byte)0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, + 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, (byte)0xC4, + (byte)0x89, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x44, 0x41, + 0x54, 0x78, (byte)0x9C, 0x62, 0x00, 0x01, 0x00, 0x00, + 0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, (byte)0xB4, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, (byte)0xAE, + 0x42, 0x60, (byte)0x82 + }; + + private Image registerSVGPlaceholder(String imageIdStr) { + Image existing = res.getImage(imageIdStr); + if (existing != null) { + return existing; + } + com.codename1.ui.EncodedImage placeholder = + com.codename1.ui.EncodedImage.create(SVG_PLACEHOLDER_PNG); + res.setImage(imageIdStr, placeholder); + return placeholder; + } @@ -2918,11 +2947,27 @@ public Image getBackgroundImage(Map styles, ScaledUnit bgIma if (fileName.indexOf("/") != -1) { fileName = fileName.substring(fileName.lastIndexOf("/")+1); } - + + // SVG references handled by the build-time transcoder land here too. + // We don't rasterize them at CSS compile time: the SVG XML can't go + // through ImageIO and the actual image instance is a Java class + // emitted by codenameone-svg-transcoder. Drop a 1x1 transparent + // EncodedImage placeholder into the resource under the SVG filename + // so the theme references it by name; the runtime + // com.codename1.generated.svg.SVGRegistry (when present) then + // overrides the entry with the transcoded image during init(). + if (fileName.toLowerCase().endsWith(".svg")) { + Image placeholder = registerSVGPlaceholder(fileName); + if (placeholder != null) { + loadedImages.put(url, placeholder); + return placeholder; + } + } + if (loadedImages.containsKey(url)) { return loadedImages.get(url); } - + LexicalUnit imageId = styles.get("cn1-image-id"); String imageIdStr = fileName; @@ -6400,6 +6445,16 @@ public void apply(Element style, String property, LexicalUnit value) { style.put("cn1-source-dpi", value); break; } + + // cn1-svg-* attributes are consumed by the build-time SVG + // transcoder mojo (see TranscodeSVGMojo), not the CSS compiler. + // Acknowledge them here so the parser doesn't log + // "Unsupported CSS property" warnings -- the values themselves + // are irrelevant to the compiled theme.res. + case "cn1-svg-width" : + case "cn1-svg-height" : { + break; + } case "cn1-derive" : { diff --git a/maven/pom.xml b/maven/pom.xml index 0dca49fedd..081e6bf4f5 100644 --- a/maven/pom.xml +++ b/maven/pom.xml @@ -61,6 +61,7 @@ core factory css-compiler + svg-transcoder sqlite-jdbc javase javase-svg @@ -102,6 +103,11 @@ codenameone-css-compiler ${project.version} + + com.codenameone + codenameone-svg-transcoder + ${project.version} + com.codenameone sqlite-jdbc diff --git a/maven/svg-transcoder/pom.xml b/maven/svg-transcoder/pom.xml new file mode 100644 index 0000000000..970563cbd1 --- /dev/null +++ b/maven/svg-transcoder/pom.xml @@ -0,0 +1,55 @@ + + + + + com.codenameone + codenameone + 8.0-SNAPSHOT + + 4.0.0 + + codenameone-svg-transcoder + 8.0-SNAPSHOT + jar + codenameone-svg-transcoder + + Build-time tool that parses SVG files and emits Codename One Image + subclasses that render them via the Graphics API. Supports a useful + subset of the SVG 1.1 static-shape vocabulary and SMIL animations + (animate, animateTransform, set). No Batik dependency: SVG is parsed + with the built-in javax.xml StAX/SAX stack. + + + + UTF-8 + 1.8 + 1.8 + + + + + + maven-compiler-plugin + + 1.8 + 1.8 + + + + + + + + junit + junit + test + + + com.codenameone + codenameone-core + test + + + diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/SVGTranscoder.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/SVGTranscoder.java new file mode 100644 index 0000000000..0f6260a0f5 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/SVGTranscoder.java @@ -0,0 +1,184 @@ +package com.codename1.svg.transcoder; + +import com.codename1.svg.transcoder.codegen.JavaCodeGenerator; +import com.codename1.svg.transcoder.model.SVGDocument; +import com.codename1.svg.transcoder.parser.SVGParser; + +import java.io.*; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Top-level entry point: parse an SVG file and emit a Codename One + * {@code GeneratedSVGImage} subclass. Also generates a small registry class + * that wires the emitted images into a {@code Resources} instance at runtime + * via {@code Resources.registerGeneratedImage(String, Image)}. + */ +public final class SVGTranscoder { + + /** Per-image entry -- used both by the per-file transcode and the registry emitter. */ + public static final class GeneratedClass { + public final String packageName; + public final String className; + /** Logical resource name used at runtime (e.g. "home" for "home.svg"). */ + public final String resourceName; + /** Source density extracted from CSS (`cn1-source-dpi`), or {@code 0} if not specified. */ + public final int sourceDensity; + /** Explicit width from CSS (`cn1-svg-width`), in millimeters; {@code 0} if not specified. */ + public final float widthMm; + /** Explicit height from CSS (`cn1-svg-height`), in millimeters; {@code 0} if not specified. */ + public final float heightMm; + + public GeneratedClass(String packageName, String className, String resourceName) { + this(packageName, className, resourceName, 0, 0f, 0f); + } + + public GeneratedClass(String packageName, String className, String resourceName, int sourceDensity) { + this(packageName, className, resourceName, sourceDensity, 0f, 0f); + } + + public GeneratedClass(String packageName, String className, String resourceName, + int sourceDensity, float widthMm, float heightMm) { + this.packageName = packageName; + this.className = className; + this.resourceName = resourceName; + this.sourceDensity = sourceDensity; + this.widthMm = widthMm; + this.heightMm = heightMm; + } + + public String fullyQualified() { + return packageName == null || packageName.isEmpty() ? className : packageName + "." + className; + } + } + + private SVGTranscoder() { } + + /** Parse {@code svg} and write a Java source file to {@code out}. */ + public static void transcode(InputStream svg, String packageName, String className, Writer out) throws IOException { + SVGDocument doc = new SVGParser().parse(svg); + new JavaCodeGenerator(doc, packageName, className).generate(out); + } + + public static void transcode(File svgFile, String packageName, String className, File outFile) throws IOException { + if (outFile.getParentFile() != null) { + outFile.getParentFile().mkdirs(); + } + InputStream in = new BufferedInputStream(new FileInputStream(svgFile)); + try { + Writer w = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outFile), "UTF-8")); + try { + transcode(in, packageName, className, w); + } finally { + w.close(); + } + } finally { + in.close(); + } + } + + /** + * Emit a {@code SVGRegistry} class with a single public static + * {@code installGlobal()} method that instantiates each generated SVG + * image and registers it in the global {@link com.codename1.ui.util.Resources} + * image table under its source filename. {@code installGlobal} is invoked + * by the per-port wiring (JavaSE port reflectively, iOS / Android Stubs + * emit a direct call) so app code does not call into the registry. + */ + public static void writeRegistry(String packageName, String className, java.util.List classes, Writer out) throws IOException { + // dedupe by resource name; last wins + Map unique = new LinkedHashMap(); + for (GeneratedClass c : classes) { + unique.put(c.resourceName, c); + } + + if (packageName != null && !packageName.isEmpty()) { + out.write("package " + packageName + ";\n\n"); + } + out.write("import com.codename1.ui.Image;\n"); + out.write("import com.codename1.ui.util.Resources;\n\n"); + out.write("/** Generated by codenameone-svg-transcoder. DO NOT EDIT.\n"); + out.write(" * Registers transcoded SVG images so they are returned by\n"); + out.write(" * {@link Resources#getImage(String)}.\n"); + out.write(" */\n"); + out.write("public final class " + className + " {\n\n"); + out.write(" private static volatile boolean __installed;\n\n"); + out.write(" private " + className + "() { }\n\n"); + out.write(" /** Register every transcoded SVG with the global Resources image\n"); + out.write(" * table. App code does not call this directly -- the per-platform\n"); + out.write(" * Stub generated by the cn1 builder (IPhoneBuilder, AndroidGradleBuilder,\n"); + out.write(" * the JavaSE archetype) emits a call here before init(Object), so any\n"); + out.write(" * subsequent Resources.getImage(name) returns the SVG. Idempotent. */\n"); + out.write(" public static void installGlobal() {\n"); + out.write(" if (__installed) return;\n"); + out.write(" synchronized (" + className + ".class) {\n"); + out.write(" if (__installed) return;\n"); + for (GeneratedClass c : unique.values()) { + out.write(" Resources.registerGeneratedImage(\"" + escapeJavaString(c.resourceName) + "\", " + newInstance(c) + ");\n"); + } + out.write(" __installed = true;\n"); + out.write(" }\n"); + out.write(" }\n"); + out.write("}\n"); + } + + private static String newInstance(GeneratedClass c) { + // Explicit millimeter dimensions win over density-based scaling -- + // they yield a deterministic physical size regardless of how the + // SVG itself declares width/height. + if (c.widthMm > 0f && c.heightMm > 0f) { + return "new " + c.fullyQualified() + "(" + floatLit(c.widthMm) + ", " + floatLit(c.heightMm) + ")"; + } + if (c.sourceDensity > 0) { + return "new " + c.fullyQualified() + "(" + c.sourceDensity + ")"; + } + return "new " + c.fullyQualified() + "()"; + } + + private static String floatLit(float f) { + return f + "f"; + } + + /** "home.svg" -> "HomeSvg". Used to derive a class name from a filename. */ + public static String classNameFor(String fileName) { + String stem = fileName; + int dot = stem.lastIndexOf('.'); + if (dot > 0) { + stem = stem.substring(0, dot); + } + StringBuilder sb = new StringBuilder(); + boolean upper = true; + for (int i = 0; i < stem.length(); i++) { + char c = stem.charAt(i); + if (c == '_' || c == '-' || c == ' ' || c == '.') { upper = true; continue; } + if (sb.length() == 0 && Character.isDigit(c)) { + sb.append('_').append(c); + upper = true; + continue; + } + if (!Character.isJavaIdentifierPart(c)) c = '_'; + sb.append(upper ? Character.toUpperCase(c) : c); + upper = false; + } + if (sb.length() == 0) { + sb.append("Svg"); + } + return sb.toString(); + } + + private static String escapeJavaString(String s) { + StringBuilder sb = new StringBuilder(s.length() + 4); + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + switch (c) { + case '\\': sb.append("\\\\"); break; + case '"': sb.append("\\\""); break; + case '\n': sb.append("\\n"); break; + case '\r': sb.append("\\r"); break; + case '\t': sb.append("\\t"); break; + default: sb.append(c); + } + } + return sb.toString(); + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/animation/SMILParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/animation/SMILParser.java new file mode 100644 index 0000000000..ffb6c1aea5 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/animation/SMILParser.java @@ -0,0 +1,86 @@ +package com.codename1.svg.transcoder.animation; + +import com.codename1.svg.transcoder.model.SVGAnimation; + +import java.util.ArrayList; +import java.util.List; + +/** Parses SMIL clock values ("1s", "250ms", "1:30", "indefinite", etc.). */ +public final class SMILParser { + + private SMILParser() { } + + public static long parseClock(String s, long fallback) { + if (s == null) return fallback; + String v = s.trim(); + if (v.isEmpty()) return fallback; + if ("indefinite".equalsIgnoreCase(v)) return SVGAnimation.REPEAT_INDEFINITE; + try { + // h:m:s or m:s + if (v.indexOf(':') >= 0) { + String[] parts = v.split(":"); + double total = 0; + for (String p : parts) total = total * 60 + Double.parseDouble(p.trim()); + return Math.round(total * 1000.0); + } + // unit suffix + if (v.endsWith("ms")) { + return Math.round(Double.parseDouble(v.substring(0, v.length() - 2).trim())); + } + if (v.endsWith("s")) { + return Math.round(Double.parseDouble(v.substring(0, v.length() - 1).trim()) * 1000.0); + } + if (v.endsWith("min")) { + return Math.round(Double.parseDouble(v.substring(0, v.length() - 3).trim()) * 60000.0); + } + if (v.endsWith("h")) { + return Math.round(Double.parseDouble(v.substring(0, v.length() - 1).trim()) * 3600000.0); + } + // raw number = seconds + return Math.round(Double.parseDouble(v) * 1000.0); + } catch (RuntimeException e) { + return fallback; + } + } + + public static int parseRepeatCount(String s) { + if (s == null) return 1; + String v = s.trim(); + if (v.isEmpty()) return 1; + if ("indefinite".equalsIgnoreCase(v)) return SVGAnimation.REPEAT_INDEFINITE; + try { + float f = Float.parseFloat(v); + int i = (int) Math.max(1, Math.round(f)); + return i; + } catch (RuntimeException e) { + return 1; + } + } + + public static SVGAnimation.CalcMode parseCalcMode(String s) { + if (s == null) return SVGAnimation.CalcMode.LINEAR; + String v = s.trim().toLowerCase(); + if ("discrete".equals(v)) return SVGAnimation.CalcMode.DISCRETE; + if ("paced".equals(v)) return SVGAnimation.CalcMode.PACED; + return SVGAnimation.CalcMode.LINEAR; + } + + public static SVGAnimation.TransformType parseTransformType(String s) { + if (s == null) return SVGAnimation.TransformType.TRANSLATE; + String v = s.trim(); + if ("rotate".equals(v)) return SVGAnimation.TransformType.ROTATE; + if ("scale".equals(v)) return SVGAnimation.TransformType.SCALE; + if ("skewX".equals(v)) return SVGAnimation.TransformType.SKEW_X; + if ("skewY".equals(v)) return SVGAnimation.TransformType.SKEW_Y; + return SVGAnimation.TransformType.TRANSLATE; + } + + public static List parseValues(String s) { + if (s == null) return null; + String t = s.trim(); + if (t.isEmpty()) return null; + List out = new ArrayList(); + for (String p : t.split(";")) out.add(p.trim()); + return out; + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/codegen/JavaCodeGenerator.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/codegen/JavaCodeGenerator.java new file mode 100644 index 0000000000..a92c7c7d43 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/codegen/JavaCodeGenerator.java @@ -0,0 +1,850 @@ +package com.codename1.svg.transcoder.codegen; + +import com.codename1.svg.transcoder.model.*; +import com.codename1.svg.transcoder.parser.*; + +import java.io.IOException; +import java.io.Writer; +import java.util.List; +import java.util.Locale; + +/** + * Walks a parsed {@link SVGDocument} and emits a Java source file that + * extends {@code com.codename1.ui.GeneratedSVGImage} and renders the SVG + * using the Codename One {@code Graphics} shape API. SMIL animations on a + * node become inline calls to the animation helpers on the runtime base + * class so the emitted code stays self-contained. + * + *

The generator is intentionally direct -- one shape per inline block, + * no method extraction -- both to keep the emitted code readable and to + * avoid surprising the bytecode translator with large method counts.

+ */ +public final class JavaCodeGenerator { + + private final SVGDocument doc; + private final String packageName; + private final String className; + private final StringBuilder body = new StringBuilder(); + private int indent = 2; + private int idSeq; + + public JavaCodeGenerator(SVGDocument doc, String packageName, String className) { + this.doc = doc; + this.packageName = packageName; + this.className = className; + } + + public void generate(Writer out) throws IOException { + boolean animated = containsAnimation(doc); + emitPaintBody(doc); + + StringBuilder src = new StringBuilder(); + if (packageName != null && !packageName.isEmpty()) { + src.append("package ").append(packageName).append(";\n\n"); + } + src.append("import com.codename1.ui.Font;\n"); + src.append("import com.codename1.ui.GeneratedSVGImage;\n"); + src.append("import com.codename1.ui.Graphics;\n"); + src.append("import com.codename1.ui.LinearGradientPaint;\n"); + src.append("import com.codename1.ui.MultipleGradientPaint;\n"); + src.append("import com.codename1.ui.Stroke;\n"); + src.append("import com.codename1.ui.Transform;\n"); + src.append("import com.codename1.ui.geom.GeneralPath;\n\n"); + src.append("/** Generated by codenameone-svg-transcoder. DO NOT EDIT. */\n"); + src.append("public final class ").append(className).append(" extends GeneratedSVGImage {\n\n"); + String dimensions = intLit((int) Math.ceil(doc.getWidth())) + + ", " + intLit((int) Math.ceil(doc.getHeight())) + + ", " + floatLit(doc.getViewBoxX()) + + ", " + floatLit(doc.getViewBoxY()) + + ", " + floatLit(doc.getViewBoxWidth()) + + ", " + floatLit(doc.getViewBoxHeight()) + + ", " + animated; + src.append(" /** Construct with the default source density (DENSITY_MEDIUM). */\n"); + src.append(" public ").append(className).append("() {\n"); + src.append(" super(").append(dimensions).append(");\n"); + src.append(" }\n\n"); + src.append(" /** Construct with an explicit source density. Used by the\n"); + src.append(" * auto-generated SVGRegistry to honor `cn1-source-dpi` hints from\n"); + src.append(" * the CSS file referencing this SVG. */\n"); + src.append(" public ").append(className).append("(int sourceDensity) {\n"); + src.append(" super(").append(dimensions).append(", sourceDensity);\n"); + src.append(" }\n\n"); + src.append(" /** Construct with explicit dimensions in millimeters; converted to\n"); + src.append(" * device pixels via Display.convertToPixels so the rendered size\n"); + src.append(" * carries across DPIs. Used by the auto-generated SVGRegistry to\n"); + src.append(" * honor `cn1-svg-width` / `cn1-svg-height` CSS hints. */\n"); + src.append(" public ").append(className).append("(float widthMm, float heightMm) {\n"); + src.append(" super(").append(dimensions).append(",\n"); + src.append(" GeneratedSVGImage.mmToPixels(widthMm),\n"); + src.append(" GeneratedSVGImage.mmToPixels(heightMm));\n"); + src.append(" }\n\n"); + src.append(" @Override\n"); + src.append(" protected void paintSVG(Graphics g, long __t) {\n"); + src.append(body); + src.append(" }\n"); + src.append("}\n"); + + out.write(src.toString()); + } + + private void emitPaintBody(SVGGroup root) { + // Shared scratch slots -- reassigned per shape; not redeclared inside + // nested blocks since Java forbids local-variable shadowing. + line("GeneralPath __p = null;"); + line("Stroke __s = null;"); + line("if (__p != null || __s != null) { /* keep javac happy */ }"); + for (SVGNode child : root.getChildren()) { + emitNode(child, null); + } + } + + private void emitNode(SVGNode n, SVGStyle parentStyle) { + SVGStyle inherited = mergedStyle(n, parentStyle); + SVGTransform tr = n.getTransform(); + List anims = n.getAnimations(); + boolean hasTransformAnim = hasTransformAnimation(anims); + boolean needsTransform = tr != null || hasTransformAnim; + + String savedVar = null; + String newVar = null; + if (needsTransform) { + // Fresh names per block so sibling transformed elements compile + // (Java does not allow shadowing of enclosing locals). + int id = idSeq++; + savedVar = "__tsave" + id; + newVar = "__tnew" + id; + line("{"); + indent++; + line("Transform " + savedVar + " = g.getTransform();"); + line("Transform " + newVar + " = " + savedVar + ".copy();"); + if (tr != null) { + emitApplyMatrix(newVar, tr); + } + for (SVGAnimation a : anims) { + if (a.getKind() == SVGAnimation.Kind.ANIMATE_TRANSFORM) { + emitApplyAnimatedTransform(newVar, a); + } + } + line("g.setTransform(" + newVar + ");"); + line("try {"); + indent++; + } + + String clipRef = inherited.getClipPathRef(); + SVGClipPath clip = null; + String clipVar = null; + if (clipRef != null) { + SVGNode def = doc.getDefinitions().get(clipRef); + if (def instanceof SVGClipPath) { + clip = (SVGClipPath) def; + clipVar = "__clip" + (idSeq++); + emitClipShape(clip, clipVar); + line("g.pushClip();"); + line("try {"); + indent++; + line("g.setClip(" + clipVar + ");"); + } + } + + try { + if (n instanceof SVGGroup) { + SVGGroup g = (SVGGroup) n; + for (SVGNode child : g.getChildren()) { + emitNode(child, inherited); + } + } else if (n instanceof SVGRect) { + emitRect((SVGRect) n, inherited, anims); + } else if (n instanceof SVGCircle) { + emitCircle((SVGCircle) n, inherited, anims); + } else if (n instanceof SVGEllipse) { + emitEllipse((SVGEllipse) n, inherited, anims); + } else if (n instanceof SVGLine) { + emitLine((SVGLine) n, inherited, anims); + } else if (n instanceof SVGPolyline) { + emitPolyline((SVGPolyline) n, inherited, anims); + } else if (n instanceof SVGPath) { + emitPath((SVGPath) n, inherited, anims); + } else if (n instanceof SVGText) { + emitText((SVGText) n, inherited, anims); + } + } finally { + if (clip != null) { + indent--; + line("} finally {"); + indent++; + line("g.popClip();"); + indent--; + line("}"); + } + if (needsTransform) { + indent--; + line("} finally {"); + indent++; + line("g.setTransform(" + savedVar + ");"); + indent--; + line("}"); + indent--; + line("}"); + } + } + } + + /// Build a GeneralPath that captures the outline of the first shape child + /// of a ``. The supported subset matches what most icon + /// authoring tools emit -- rect / circle / ellipse / polygon / polyline / + /// path. Multi-shape clipPaths and nested clip refs inside the clipPath + /// are flattened to the first child for simplicity. + private void emitClipShape(SVGClipPath cp, String varName) { + SVGShape shape = null; + for (SVGNode c : cp.getChildren()) { + if (c instanceof SVGShape) { + shape = (SVGShape) c; + break; + } + if (c instanceof SVGGroup) { + for (SVGNode cc : ((SVGGroup) c).getChildren()) { + if (cc instanceof SVGShape) { + shape = (SVGShape) cc; + break; + } + } + if (shape != null) break; + } + } + line("GeneralPath " + varName + " = new GeneralPath();"); + if (shape == null) { + // Empty clipPath -- the spec says elements with a clip-path that + // points at an empty clipPath are not rendered, but our caller + // will still try to fillShape(...). Emit a degenerate path so the + // resulting clip clips everything out. + return; + } + if (shape instanceof SVGRect) { + SVGRect r = (SVGRect) shape; + float rx = r.getRx(); + float ry = r.getRy(); + if (rx == 0 && ry > 0) rx = ry; + if (ry == 0 && rx > 0) ry = rx; + if (rx <= 0f && ry <= 0f) { + line(varName + ".moveTo(" + floatLit(r.getX()) + ", " + floatLit(r.getY()) + ");"); + line(varName + ".lineTo(" + floatLit(r.getX() + r.getWidth()) + ", " + floatLit(r.getY()) + ");"); + line(varName + ".lineTo(" + floatLit(r.getX() + r.getWidth()) + ", " + floatLit(r.getY() + r.getHeight()) + ");"); + line(varName + ".lineTo(" + floatLit(r.getX()) + ", " + floatLit(r.getY() + r.getHeight()) + ");"); + line(varName + ".closePath();"); + } else { + // Rounded rect outline. + String x = floatLit(r.getX()); + String y = floatLit(r.getY()); + String w = floatLit(r.getWidth()); + String h = floatLit(r.getHeight()); + String rxs = floatLit(rx); + String rys = floatLit(ry); + line(varName + ".moveTo(" + r.getX() + "f + " + rxs + ", " + y + ");"); + line(varName + ".lineTo(" + r.getX() + "f + " + w + " - " + rxs + ", " + y + ");"); + line(varName + ".quadTo(" + r.getX() + "f + " + w + ", " + y + ", " + r.getX() + "f + " + w + ", " + r.getY() + "f + " + rys + ");"); + line(varName + ".lineTo(" + r.getX() + "f + " + w + ", " + r.getY() + "f + " + h + " - " + rys + ");"); + line(varName + ".quadTo(" + r.getX() + "f + " + w + ", " + r.getY() + "f + " + h + ", " + r.getX() + "f + " + w + " - " + rxs + ", " + r.getY() + "f + " + h + ");"); + line(varName + ".lineTo(" + r.getX() + "f + " + rxs + ", " + r.getY() + "f + " + h + ");"); + line(varName + ".quadTo(" + x + ", " + r.getY() + "f + " + h + ", " + x + ", " + r.getY() + "f + " + h + " - " + rys + ");"); + line(varName + ".lineTo(" + x + ", " + r.getY() + "f + " + rys + ");"); + line(varName + ".quadTo(" + x + ", " + y + ", " + r.getX() + "f + " + rxs + ", " + y + ");"); + line(varName + ".closePath();"); + } + } else if (shape instanceof SVGCircle) { + SVGCircle c = (SVGCircle) shape; + line(varName + ".arc(" + floatLit(c.getCx() - c.getR()) + ", " + + floatLit(c.getCy() - c.getR()) + ", " + + floatLit(2 * c.getR()) + ", " + floatLit(2 * c.getR()) + + ", 0f, 6.2831855f);"); + } else if (shape instanceof SVGEllipse) { + SVGEllipse e = (SVGEllipse) shape; + line(varName + ".arc(" + floatLit(e.getCx() - e.getRx()) + ", " + + floatLit(e.getCy() - e.getRy()) + ", " + + floatLit(2 * e.getRx()) + ", " + floatLit(2 * e.getRy()) + + ", 0f, 6.2831855f);"); + } else if (shape instanceof SVGPolyline) { + float[] pts = ((SVGPolyline) shape).getPoints(); + if (pts.length >= 4) { + line(varName + ".moveTo(" + floatLit(pts[0]) + ", " + floatLit(pts[1]) + ");"); + for (int i = 2; i + 1 < pts.length; i += 2) { + line(varName + ".lineTo(" + floatLit(pts[i]) + ", " + floatLit(pts[i + 1]) + ");"); + } + if (((SVGPolyline) shape).isClosed()) { + line(varName + ".closePath();"); + } + } + } else if (shape instanceof SVGPath) { + // Re-emit path commands into varName. + for (PathCommand pc : ((SVGPath) shape).getCommands()) { + float[] a = pc.getArgs(); + switch (pc.getType()) { + case MOVE: line(varName + ".moveTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ");"); break; + case LINE: line(varName + ".lineTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ");"); break; + case CUBIC: line(varName + ".curveTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ", " + + floatLit(a[2]) + ", " + floatLit(a[3]) + ", " + + floatLit(a[4]) + ", " + floatLit(a[5]) + ");"); break; + case QUAD: line(varName + ".quadTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ", " + + floatLit(a[2]) + ", " + floatLit(a[3]) + ");"); break; + case ARC: line("GeneratedSVGImage.svgArc(" + varName + ", " + + floatLit(a[0]) + ", " + floatLit(a[1]) + ", " + + floatLit(a[2]) + ", " + floatLit(a[3]) + ", " + + floatLit(a[4]) + ", " + (a[5] != 0f) + ", " + (a[6] != 0f) + ", " + + floatLit(a[7]) + ", " + floatLit(a[8]) + ");"); break; + case CLOSE: line(varName + ".closePath();"); break; + default: break; + } + } + } + } + + // ---- shape emitters ---------------------------------------------------- + + private void emitRect(SVGRect r, SVGStyle style, List anims) { + AnimatedFloat x = animFloat("x", r.getX(), anims); + AnimatedFloat y = animFloat("y", r.getY(), anims); + AnimatedFloat w = animFloat("width", r.getWidth(), anims); + AnimatedFloat h = animFloat("height", r.getHeight(), anims); + float rx = r.getRx(); + float ry = r.getRy(); + if (rx == 0 && ry > 0) rx = ry; + if (ry == 0 && rx > 0) ry = rx; + + line("__p = new GeneralPath();"); + if (rx <= 0f && ry <= 0f) { + line("__p.moveTo(" + x.expr + ", " + y.expr + ");"); + line("__p.lineTo(" + plus(x.expr, w.expr) + ", " + y.expr + ");"); + line("__p.lineTo(" + plus(x.expr, w.expr) + ", " + plus(y.expr, h.expr) + ");"); + line("__p.lineTo(" + x.expr + ", " + plus(y.expr, h.expr) + ");"); + line("__p.closePath();"); + } else { + String xs = x.expr, ys = y.expr, ws = w.expr, hs = h.expr; + String rxs = floatLit(rx), rys = floatLit(ry); + line("__p.moveTo(" + plus(xs, rxs) + ", " + ys + ");"); + line("__p.lineTo(" + plus(xs, w.expr) + " - " + rxs + ", " + ys + ");"); + line("__p.quadTo(" + plus(xs, ws) + ", " + ys + ", " + + plus(xs, ws) + ", " + plus(ys, rys) + ");"); + line("__p.lineTo(" + plus(xs, ws) + ", " + plus(ys, hs) + " - " + rys + ");"); + line("__p.quadTo(" + plus(xs, ws) + ", " + plus(ys, hs) + ", " + + plus(xs, ws) + " - " + rxs + ", " + plus(ys, hs) + ");"); + line("__p.lineTo(" + plus(xs, rxs) + ", " + plus(ys, hs) + ");"); + line("__p.quadTo(" + xs + ", " + plus(ys, hs) + ", " + + xs + ", " + plus(ys, hs) + " - " + rys + ");"); + line("__p.lineTo(" + xs + ", " + plus(ys, rys) + ");"); + line("__p.quadTo(" + xs + ", " + ys + ", " + plus(xs, rxs) + ", " + ys + ");"); + line("__p.closePath();"); + } + emitFillAndStroke(style, anims); + } + + private void emitCircle(SVGCircle c, SVGStyle style, List anims) { + AnimatedFloat cx = animFloat("cx", c.getCx(), anims); + AnimatedFloat cy = animFloat("cy", c.getCy(), anims); + AnimatedFloat rad = animFloat("r", c.getR(), anims); + line("__p = new GeneralPath();"); + line("__p.arc(" + cx.expr + " - " + rad.expr + ", " + + cy.expr + " - " + rad.expr + ", " + + "2f * " + rad.expr + ", 2f * " + rad.expr + + ", 0f, 6.2831855f);"); + emitFillAndStroke(style, anims); + } + + private void emitEllipse(SVGEllipse e, SVGStyle style, List anims) { + AnimatedFloat cx = animFloat("cx", e.getCx(), anims); + AnimatedFloat cy = animFloat("cy", e.getCy(), anims); + AnimatedFloat rx = animFloat("rx", e.getRx(), anims); + AnimatedFloat ry = animFloat("ry", e.getRy(), anims); + line("__p = new GeneralPath();"); + line("__p.arc(" + cx.expr + " - " + rx.expr + ", " + + cy.expr + " - " + ry.expr + ", " + + "2f * " + rx.expr + ", 2f * " + ry.expr + + ", 0f, 6.2831855f);"); + emitFillAndStroke(style, anims); + } + + private void emitLine(SVGLine l, SVGStyle style, List anims) { + AnimatedFloat x1 = animFloat("x1", l.getX1(), anims); + AnimatedFloat y1 = animFloat("y1", l.getY1(), anims); + AnimatedFloat x2 = animFloat("x2", l.getX2(), anims); + AnimatedFloat y2 = animFloat("y2", l.getY2(), anims); + line("__p = new GeneralPath();"); + line("__p.moveTo(" + x1.expr + ", " + y1.expr + ");"); + line("__p.lineTo(" + x2.expr + ", " + y2.expr + ");"); + emitFillAndStroke(style, anims); + } + + private void emitPolyline(SVGPolyline pl, SVGStyle style, List anims) { + float[] pts = pl.getPoints(); + if (pts.length < 4) return; + line("__p = new GeneralPath();"); + line("__p.moveTo(" + floatLit(pts[0]) + ", " + floatLit(pts[1]) + ");"); + for (int i = 2; i + 1 < pts.length; i += 2) { + line("__p.lineTo(" + floatLit(pts[i]) + ", " + floatLit(pts[i + 1]) + ");"); + } + if (pl.isClosed()) line("__p.closePath();"); + emitFillAndStroke(style, anims); + } + + private void emitPath(SVGPath path, SVGStyle style, List anims) { + if (path.getCommands() == null || path.getCommands().isEmpty()) return; + line("__p = new GeneralPath();"); + float curX = 0, curY = 0; + for (PathCommand pc : path.getCommands()) { + float[] a = pc.getArgs(); + switch (pc.getType()) { + case MOVE: + line("__p.moveTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ");"); + curX = a[0]; curY = a[1]; + break; + case LINE: + line("__p.lineTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ");"); + curX = a[0]; curY = a[1]; + break; + case CUBIC: + line("__p.curveTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ", " + + floatLit(a[2]) + ", " + floatLit(a[3]) + ", " + + floatLit(a[4]) + ", " + floatLit(a[5]) + ");"); + curX = a[4]; curY = a[5]; + break; + case QUAD: + line("__p.quadTo(" + floatLit(a[0]) + ", " + floatLit(a[1]) + ", " + + floatLit(a[2]) + ", " + floatLit(a[3]) + ");"); + curX = a[2]; curY = a[3]; + break; + case ARC: + // args = curX, curY, rx, ry, xRot, largeArc, sweep, x, y + line("GeneratedSVGImage.svgArc(__p, " + + floatLit(a[0]) + ", " + floatLit(a[1]) + ", " + + floatLit(a[2]) + ", " + floatLit(a[3]) + ", " + + floatLit(a[4]) + ", " + (a[5] != 0f) + ", " + (a[6] != 0f) + ", " + + floatLit(a[7]) + ", " + floatLit(a[8]) + ");"); + curX = a[7]; curY = a[8]; + break; + case CLOSE: + line("__p.closePath();"); + break; + } + } + emitFillAndStroke(style, anims); + } + + private void emitText(SVGText text, SVGStyle style, List anims) { + if (text.getContent() == null || text.getContent().isEmpty()) { + return; + } + SVGPaint fill = style.getFill() != null ? style.getFill() : SVGPaint.BLACK; + if (fill.isNone()) { + return; + } + AnimatedFloat fillOpacity = animFloat("fill-opacity", + style.getFillOpacity() == null ? 1f : style.getFillOpacity(), anims); + AnimatedFloat elementOpacity = animFloat("opacity", + style.getOpacity() == null ? 1f : style.getOpacity(), anims); + + float size = text.getFontSize() > 0 ? text.getFontSize() : 12f; + int styleConst = (text.isBold() ? 1 : 0) | (text.isItalic() ? 2 : 0); + // Font.STYLE_PLAIN = 0, STYLE_BOLD = 1, STYLE_ITALIC = 2 + + // Text on iOS Metal currently misrenders: drawString does not pick + // up the active Graphics transform reliably, so the text either + // disappears or lands at the wrong screen position. That is being + // tracked as a Metal port bug -- the transcoder emits the simple + // recipe (set font, drawString) here and the screenshot goldens + // capture the platform-current behavior. + line("{"); + indent++; + line("Font __font = GeneratedSVGImage.svgTextFont(" + floatLit(size) + ", " + styleConst + ");"); + line("Font __oldFont = g.getFont();"); + line("g.setFont(__font);"); + emitPaintSet(fill, fillOpacity, elementOpacity); + String content = "\"" + escapeJavaString(text.getContent()) + "\""; + switch (text.getAnchor()) { + case MIDDLE: + line("int __tx = (int)" + floatLit(text.getX()) + " - __font.stringWidth(" + content + ") / 2;"); + break; + case END: + line("int __tx = (int)" + floatLit(text.getX()) + " - __font.stringWidth(" + content + ");"); + break; + case START: + default: + line("int __tx = (int)" + floatLit(text.getX()) + ";"); + break; + } + line("int __ascent = __font.getAscent();"); + line("if (__ascent <= 0) { __ascent = __font.getHeight(); }"); + line("g.drawString(" + content + ", __tx, (int)" + floatLit(text.getY()) + " - __ascent);"); + line("g.setFont(__oldFont);"); + indent--; + line("}"); + } + + private static String escapeJavaString(String s) { + StringBuilder out = new StringBuilder(s.length() + 4); + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + switch (c) { + case '\\': out.append("\\\\"); break; + case '"': out.append("\\\""); break; + case '\n': out.append("\\n"); break; + case '\r': out.append("\\r"); break; + case '\t': out.append("\\t"); break; + default: + if (c < 0x20 || c > 0x7E) { + out.append(String.format("\\u%04X", (int) c)); + } else { + out.append(c); + } + } + } + return out.toString(); + } + + // ---- fill / stroke ----------------------------------------------------- + + private void emitFillAndStroke(SVGStyle style, List anims) { + SVGPaint fill = style.getFill(); + SVGPaint stroke = style.getStroke(); + // default: fill black unless explicitly set + if (fill == null) fill = SVGPaint.BLACK; + // Element opacity is animatable (``) + // and applies to both fill and stroke; resolve it once. + AnimatedFloat elementOpacity = animFloat("opacity", + style.getOpacity() == null ? 1f : style.getOpacity(), anims); + + if (!fill.isNone()) { + AnimatedFloat fillOpacity = animFloat("fill-opacity", + style.getFillOpacity() == null ? 1f : style.getFillOpacity(), anims); + if (fill.isReference()) { + emitGradientFill(fill, fillOpacity, elementOpacity); + } else { + emitPaintSet(fill, fillOpacity, elementOpacity); + line("g.fillShape(__p);"); + } + } + if (stroke != null && !stroke.isNone()) { + Float sw = style.getStrokeWidth(); + float widthVal = sw == null ? 1f : sw; + int cap = style.getStrokeLineCap() == null ? SVGStyle.LINECAP_BUTT : style.getStrokeLineCap(); + int join = style.getStrokeLineJoin() == null ? SVGStyle.LINEJOIN_MITER : style.getStrokeLineJoin(); + float miter = style.getStrokeMiterLimit() == null ? 4f : style.getStrokeMiterLimit(); + emitPaintSet(stroke, animFloat("stroke-opacity", + style.getStrokeOpacity() == null ? 1f : style.getStrokeOpacity(), anims), + elementOpacity); + line("__s = new Stroke(" + floatLit(widthVal) + + ", " + capConst(cap) + ", " + joinConst(join) + + ", " + floatLit(miter) + ");"); + line("g.drawShape(__p, __s);"); + } + } + + private void emitPaintSet(SVGPaint paint, AnimatedFloat opacity, AnimatedFloat elementOpacity) { + // element opacity multiplies attribute opacity (both animatable) + String alphaExpr = alphaExpression(opacity, elementOpacity, 0xFF); + if (paint.isReference()) { + // Gradient paths are handled by emitGradientFill; this is for the + // solid-color stroke path or the radial-fallback case. + SVGNode def = doc.getDefinitions().get(paint.getReference()); + int color = 0xFF000000; + if (def instanceof SVGRadialGradient) { + SVGRadialGradient g = (SVGRadialGradient) def; + if (!g.getStops().isEmpty()) { + color = g.getStops().get(0).getColor(); + } + } + line("g.setColor(0x" + hex(color & 0xFFFFFF) + ");"); + line("g.setAlpha(" + alphaExpr + ");"); + return; + } + int argb = paint.getColor(); + line("g.setColor(0x" + hex(argb & 0xFFFFFF) + ");"); + int colorAlpha = (argb >>> 24) & 0xFF; + line("g.setAlpha(" + alphaExpression(opacity, elementOpacity, colorAlpha) + ");"); + } + + private static String alphaExpression(AnimatedFloat opacity, AnimatedFloat elementOpacity, int baseAlpha) { + String mult = "Math.max(0f, Math.min(1f, " + opacity.expr + " * " + elementOpacity.expr + "))"; + if (baseAlpha >= 0xFF) { + return "(int)(255f * " + mult + ")"; + } + return "(int)(" + baseAlpha + " * " + mult + " + 0.5f)"; + } + + /// Gradient fills require shape clipping: CN1's [LinearGradientPaint#paint] + /// fills its bounding rectangle, not the path -- a `fillShape(p)` after + /// `setColor(paint)` ends up painting the gradient through any space inside + /// the shape's bounding box on some ports. Push the path as the clip *and* + /// call setColor(paint)+fillShape so platforms that respect the paint on + /// fillShape (which produces a higher-quality result than clip+paint.paint) + /// still get the proper outline, while the clip is a safety net for the + /// ports that don't. + private void emitGradientFill(SVGPaint fill, AnimatedFloat opacity, AnimatedFloat elementOpacity) { + SVGNode def = doc.getDefinitions().get(fill.getReference()); + if (!(def instanceof SVGLinearGradient)) { + // Radial / unresolved: fall back to first stop or black via the + // solid-color path so we always render something. + emitPaintSet(fill, opacity, elementOpacity); + line("g.fillShape(__p);"); + return; + } + SVGLinearGradient lg = (SVGLinearGradient) def; + SVGLinearGradient effective = lg; + if (lg.getStops().isEmpty() && lg.getHref() != null) { + SVGNode ref = doc.getDefinitions().get(lg.getHref()); + if (ref instanceof SVGLinearGradient) { + effective = (SVGLinearGradient) ref; + } + } + List stops = effective.getStops(); + if (stops.isEmpty()) { + emitPaintSet(SVGPaint.BLACK, opacity, elementOpacity); + line("g.fillShape(__p);"); + return; + } + + StringBuilder fracs = new StringBuilder("new float[]{"); + StringBuilder cols = new StringBuilder("new int[]{"); + for (int i = 0; i < stops.size(); i++) { + if (i > 0) { fracs.append(", "); cols.append(", "); } + float off = Math.max(0f, Math.min(1f, stops.get(i).getOffset())); + int color = stops.get(i).getColor() & 0xFFFFFF; + int sAlpha = Math.round(255f * stops.get(i).getOpacity()); + fracs.append(floatLit(off)); + cols.append("0x").append(Integer.toHexString((sAlpha << 24) | color).toUpperCase(Locale.ROOT)); + } + fracs.append("}"); + cols.append("}"); + + // Gradient fills on iOS Metal currently misrender because + // setClip(non-rect Shape) substitutes a degenerate polygon for + // arc-decomposed paths -- the gradient ends up shaped like a + // triangle. That is being tracked as a Metal port bug; the + // transcoder emits the simple setClip + LinearGradientPaint.paint + // recipe and the screenshot goldens capture the current behavior. + line("{"); + indent++; + line("float[] __b = new float[4];"); + line("__p.getBounds2D(__b);"); + line("float __bx = __b[0], __by = __b[1];"); + line("float __bw = __b[2], __bh = __b[3];"); + String startX, startY, endX, endY; + if (lg.isUserSpace()) { + startX = floatLit(lg.getX1()); + startY = floatLit(lg.getY1()); + endX = floatLit(lg.getX2()); + endY = floatLit(lg.getY2()); + } else { + startX = "__bx + " + floatLit(lg.getX1()) + " * __bw"; + startY = "__by + " + floatLit(lg.getY1()) + " * __bh"; + endX = "__bx + " + floatLit(lg.getX2()) + " * __bw"; + endY = "__by + " + floatLit(lg.getY2()) + " * __bh"; + } + line("LinearGradientPaint __paint = new LinearGradientPaint(" + + startX + ", " + startY + ", " + endX + ", " + endY + ", " + + fracs + ", " + cols + ", " + + "MultipleGradientPaint.CycleMethod.NO_CYCLE, " + + "MultipleGradientPaint.ColorSpaceType.SRGB, " + + "Transform.makeIdentity());"); + line("g.setAlpha(" + alphaExpression(opacity, elementOpacity, 0xFF) + ");"); + line("g.pushClip();"); + line("try {"); + indent++; + line("g.setClip(__p);"); + line("__paint.paint(g, __bx, __by, __bw, __bh);"); + indent--; + line("} finally {"); + indent++; + line("g.popClip();"); + indent--; + line("}"); + indent--; + line("}"); + } + + // ---- transforms -------------------------------------------------------- + + private void emitApplyMatrix(String varName, SVGTransform t) { + // Emit as a setAffine on a fresh transform then concatenate. + // Simpler: emit translate + multiply by matrix using direct field writes. + line(varName + ".concatenate(Transform.makeAffine(" + + floatLit(t.a) + ", " + floatLit(t.b) + ", " + + floatLit(t.c) + ", " + floatLit(t.d) + ", " + + floatLit(t.e) + ", " + floatLit(t.f) + "));"); + } + + private void emitApplyAnimatedTransform(String varName, SVGAnimation a) { + SVGAnimation.TransformType type = a.getTransformType(); + String pExpr = "GeneratedSVGImage.progress(__t, " + a.getBeginMs() + "L, " + + a.getDurMs() + "L, " + a.getRepeatCount() + ", " + a.isFreeze() + ")"; + // values | from/to + float[] from = parseFloatList(a.getFrom()); + float[] to = parseFloatList(a.getTo()); + List vals = a.getValues(); + if (vals != null && vals.size() >= 2) { + from = parseFloatList(vals.get(0)); + to = parseFloatList(vals.get(vals.size() - 1)); + } + if (from == null) from = new float[]{0f}; + if (to == null) to = from; + + switch (type) { + case TRANSLATE: { + float fx = from.length > 0 ? from[0] : 0f; + float fy = from.length > 1 ? from[1] : 0f; + float tx = to.length > 0 ? to[0] : 0f; + float ty = to.length > 1 ? to[1] : 0f; + line(varName + ".translate(" + + "GeneratedSVGImage.lerp(" + floatLit(fx) + ", " + floatLit(tx) + ", " + pExpr + "), " + + "GeneratedSVGImage.lerp(" + floatLit(fy) + ", " + floatLit(ty) + ", " + pExpr + "));"); + break; + } + case SCALE: { + float fx = from.length > 0 ? from[0] : 1f; + float fy = from.length > 1 ? from[1] : fx; + float tx = to.length > 0 ? to[0] : 1f; + float ty = to.length > 1 ? to[1] : tx; + line(varName + ".scale(" + + "GeneratedSVGImage.lerp(" + floatLit(fx) + ", " + floatLit(tx) + ", " + pExpr + "), " + + "GeneratedSVGImage.lerp(" + floatLit(fy) + ", " + floatLit(ty) + ", " + pExpr + "));"); + break; + } + case ROTATE: { + float fAng = from.length > 0 ? from[0] : 0f; + float fCx = from.length > 1 ? from[1] : 0f; + float fCy = from.length > 2 ? from[2] : 0f; + float tAng = to.length > 0 ? to[0] : 0f; + float tCx = to.length > 1 ? to[1] : fCx; + float tCy = to.length > 2 ? to[2] : fCy; + line(varName + ".rotate(" + + "(float) Math.toRadians(GeneratedSVGImage.lerp(" + + floatLit(fAng) + ", " + floatLit(tAng) + ", " + pExpr + ")), " + + "GeneratedSVGImage.lerp(" + floatLit(fCx) + ", " + floatLit(tCx) + ", " + pExpr + "), " + + "GeneratedSVGImage.lerp(" + floatLit(fCy) + ", " + floatLit(tCy) + ", " + pExpr + "));"); + break; + } + case SKEW_X: + case SKEW_Y: + // skewing via Transform isn't a primitive op; bake into matrix concatenation + break; + } + } + + // ---- animated attribute resolution ------------------------------------- + + /** Look for an `` on this attribute and return either a constant + * or an expression that interpolates the value at runtime. */ + private AnimatedFloat animFloat(String attr, float fallback, List anims) { + if (anims != null) { + for (SVGAnimation a : anims) { + if (a.getKind() == SVGAnimation.Kind.ANIMATE + && attr.equals(a.getAttributeName())) { + float from = parseSingleFloat(a.getFrom(), fallback); + float to = parseSingleFloat(a.getTo(), from); + List vals = a.getValues(); + if (vals != null && vals.size() >= 2) { + from = parseSingleFloat(vals.get(0), from); + to = parseSingleFloat(vals.get(vals.size() - 1), to); + } + String pExpr = "GeneratedSVGImage.progress(__t, " + a.getBeginMs() + "L, " + + a.getDurMs() + "L, " + a.getRepeatCount() + ", " + a.isFreeze() + ")"; + return new AnimatedFloat("GeneratedSVGImage.lerp(" + + floatLit(from) + ", " + floatLit(to) + ", " + pExpr + ")"); + } + if (a.getKind() == SVGAnimation.Kind.SET + && attr.equals(a.getAttributeName())) { + float to = parseSingleFloat(a.getTo(), fallback); + String pExpr = "(__t >= " + a.getBeginMs() + "L)"; + return new AnimatedFloat("(" + pExpr + " ? " + floatLit(to) + " : " + + floatLit(fallback) + ")"); + } + } + } + return new AnimatedFloat(floatLit(fallback)); + } + + private boolean hasTransformAnimation(List anims) { + if (anims == null) return false; + for (SVGAnimation a : anims) { + if (a.getKind() == SVGAnimation.Kind.ANIMATE_TRANSFORM) return true; + } + return false; + } + + private SVGStyle mergedStyle(SVGNode n, SVGStyle parent) { + SVGStyle s = n.getStyle(); + if (s == null) { + SVGStyle empty = new SVGStyle(); + return empty.inherit(parent); + } + return s.inherit(parent); + } + + private boolean containsAnimation(SVGGroup g) { + if (!g.getAnimations().isEmpty()) return true; + for (SVGNode c : g.getChildren()) { + if (!c.getAnimations().isEmpty()) return true; + if (c instanceof SVGGroup && containsAnimation((SVGGroup) c)) return true; + } + return false; + } + + // ---- helpers ----------------------------------------------------------- + + private static final class AnimatedFloat { + final String expr; + AnimatedFloat(String expr) { this.expr = expr; } + } + + private static float[] parseFloatList(String s) { + if (s == null) return null; + NumberParser np = new NumberParser(s); + java.util.ArrayList list = new java.util.ArrayList(); + while (np.hasMore()) { + try { list.add(np.nextFloat()); } catch (RuntimeException e) { break; } + } + if (list.isEmpty()) return null; + float[] r = new float[list.size()]; + for (int i = 0; i < r.length; i++) r[i] = list.get(i); + return r; + } + + private static float parseSingleFloat(String s, float fallback) { + if (s == null) return fallback; + try { return NumberParser.parseFloat(s); } catch (RuntimeException e) { return fallback; } + } + + private static String floatLit(float f) { + if (Float.isNaN(f) || Float.isInfinite(f)) f = 0f; + // f suffix to make Java treat it as float + return f + "f"; + } + + private static String intLit(int i) { return Integer.toString(i); } + + private static String hex(int v) { + return Integer.toHexString(v & 0xFFFFFF).toUpperCase(Locale.ROOT); + } + + private static String plus(String a, String b) { + return "(" + a + " + " + b + ")"; + } + + private static String capConst(int cap) { + switch (cap) { + case SVGStyle.LINECAP_ROUND: return "Stroke.CAP_ROUND"; + case SVGStyle.LINECAP_SQUARE: return "Stroke.CAP_SQUARE"; + default: return "Stroke.CAP_BUTT"; + } + } + + private static String joinConst(int join) { + switch (join) { + case SVGStyle.LINEJOIN_ROUND: return "Stroke.JOIN_ROUND"; + case SVGStyle.LINEJOIN_BEVEL: return "Stroke.JOIN_BEVEL"; + default: return "Stroke.JOIN_MITER"; + } + } + + private void line(String s) { + for (int i = 0; i < indent; i++) body.append(" "); + body.append(s).append("\n"); + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGAnimation.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGAnimation.java new file mode 100644 index 0000000000..5beb0f5b63 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGAnimation.java @@ -0,0 +1,70 @@ +package com.codename1.svg.transcoder.model; + +import java.util.List; + +/** + * SMIL animation: <animate>, <animateTransform>, <set>. + * + * Stored as data so the code generator can emit a runtime descriptor. + * Time values are pre-parsed into milliseconds; "indefinite" repeat is + * represented by {@link #REPEAT_INDEFINITE}. + */ +public final class SVGAnimation { + + public static final int REPEAT_INDEFINITE = -1; + + public enum Kind { ANIMATE, ANIMATE_TRANSFORM, SET } + + public enum TransformType { TRANSLATE, ROTATE, SCALE, SKEW_X, SKEW_Y } + + public enum CalcMode { LINEAR, DISCRETE, PACED } + + private Kind kind = Kind.ANIMATE; + private String attributeName; + private TransformType transformType; + private CalcMode calcMode = CalcMode.LINEAR; + private List values; // raw value strings (already trimmed) + private String from; + private String to; + private String by; + private long beginMs; + private long durMs; + private int repeatCount = 1; + private boolean freeze; + + public Kind getKind() { return kind; } + public void setKind(Kind kind) { this.kind = kind; } + + public String getAttributeName() { return attributeName; } + public void setAttributeName(String attributeName) { this.attributeName = attributeName; } + + public TransformType getTransformType() { return transformType; } + public void setTransformType(TransformType transformType) { this.transformType = transformType; } + + public CalcMode getCalcMode() { return calcMode; } + public void setCalcMode(CalcMode calcMode) { this.calcMode = calcMode; } + + public List getValues() { return values; } + public void setValues(List values) { this.values = values; } + + public String getFrom() { return from; } + public void setFrom(String from) { this.from = from; } + + public String getTo() { return to; } + public void setTo(String to) { this.to = to; } + + public String getBy() { return by; } + public void setBy(String by) { this.by = by; } + + public long getBeginMs() { return beginMs; } + public void setBeginMs(long beginMs) { this.beginMs = beginMs; } + + public long getDurMs() { return durMs; } + public void setDurMs(long durMs) { this.durMs = durMs; } + + public int getRepeatCount() { return repeatCount; } + public void setRepeatCount(int repeatCount) { this.repeatCount = repeatCount; } + + public boolean isFreeze() { return freeze; } + public void setFreeze(boolean freeze) { this.freeze = freeze; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGCircle.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGCircle.java new file mode 100644 index 0000000000..f7ff22ddce --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGCircle.java @@ -0,0 +1,12 @@ +package com.codename1.svg.transcoder.model; + +public final class SVGCircle extends SVGShape { + private float cx, cy, r; + + public float getCx() { return cx; } + public void setCx(float cx) { this.cx = cx; } + public float getCy() { return cy; } + public void setCy(float cy) { this.cy = cy; } + public float getR() { return r; } + public void setR(float r) { this.r = r; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGClipPath.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGClipPath.java new file mode 100644 index 0000000000..fd569934f2 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGClipPath.java @@ -0,0 +1,9 @@ +package com.codename1.svg.transcoder.model; + +/// Definition node holding the children of a <clipPath> element. The +/// transcoder takes the first shape child (rect, circle, ellipse, path, ...) +/// and emits it as the clip outline. Multi-shape and nested +/// `clip-path-on-clipPath-child` forms are not supported in this +/// implementation -- they are silently flattened to the first child shape. +public final class SVGClipPath extends SVGGroup { +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGDocument.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGDocument.java new file mode 100644 index 0000000000..f8b520c53b --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGDocument.java @@ -0,0 +1,35 @@ +package com.codename1.svg.transcoder.model; + +import java.util.HashMap; +import java.util.Map; + +/** Top-level <svg> document. */ +public final class SVGDocument extends SVGGroup { + private float viewBoxX; + private float viewBoxY; + private float viewBoxWidth; + private float viewBoxHeight; + private float width; + private float height; + private final Map definitions = new HashMap(); + + public float getViewBoxX() { return viewBoxX; } + public void setViewBoxX(float v) { this.viewBoxX = v; } + + public float getViewBoxY() { return viewBoxY; } + public void setViewBoxY(float v) { this.viewBoxY = v; } + + public float getViewBoxWidth() { return viewBoxWidth; } + public void setViewBoxWidth(float v) { this.viewBoxWidth = v; } + + public float getViewBoxHeight() { return viewBoxHeight; } + public void setViewBoxHeight(float v) { this.viewBoxHeight = v; } + + public float getWidth() { return width; } + public void setWidth(float w) { this.width = w; } + + public float getHeight() { return height; } + public void setHeight(float h) { this.height = h; } + + public Map getDefinitions() { return definitions; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGEllipse.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGEllipse.java new file mode 100644 index 0000000000..1ebb5bfcce --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGEllipse.java @@ -0,0 +1,14 @@ +package com.codename1.svg.transcoder.model; + +public final class SVGEllipse extends SVGShape { + private float cx, cy, rx, ry; + + public float getCx() { return cx; } + public void setCx(float cx) { this.cx = cx; } + public float getCy() { return cy; } + public void setCy(float cy) { this.cy = cy; } + public float getRx() { return rx; } + public void setRx(float rx) { this.rx = rx; } + public float getRy() { return ry; } + public void setRy(float ry) { this.ry = ry; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGGradientStop.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGGradientStop.java new file mode 100644 index 0000000000..209d6dcc5f --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGGradientStop.java @@ -0,0 +1,14 @@ +package com.codename1.svg.transcoder.model; + +public final class SVGGradientStop { + private float offset; + private int color; + private float opacity = 1f; + + public float getOffset() { return offset; } + public void setOffset(float offset) { this.offset = offset; } + public int getColor() { return color; } + public void setColor(int color) { this.color = color; } + public float getOpacity() { return opacity; } + public void setOpacity(float opacity) { this.opacity = opacity; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGGroup.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGGroup.java new file mode 100644 index 0000000000..325483d9d9 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGGroup.java @@ -0,0 +1,12 @@ +package com.codename1.svg.transcoder.model; + +import java.util.ArrayList; +import java.util.List; + +/** <g> or <svg> container. */ +public class SVGGroup extends SVGNode { + private final List children = new ArrayList(); + + public List getChildren() { return children; } + public void addChild(SVGNode n) { children.add(n); } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGLine.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGLine.java new file mode 100644 index 0000000000..66ec1535d4 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGLine.java @@ -0,0 +1,14 @@ +package com.codename1.svg.transcoder.model; + +public final class SVGLine extends SVGShape { + private float x1, y1, x2, y2; + + public float getX1() { return x1; } + public void setX1(float v) { this.x1 = v; } + public float getY1() { return y1; } + public void setY1(float v) { this.y1 = v; } + public float getX2() { return x2; } + public void setX2(float v) { this.x2 = v; } + public float getY2() { return y2; } + public void setY2(float v) { this.y2 = v; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGLinearGradient.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGLinearGradient.java new file mode 100644 index 0000000000..652e760c45 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGLinearGradient.java @@ -0,0 +1,28 @@ +package com.codename1.svg.transcoder.model; + +import java.util.ArrayList; +import java.util.List; + +public final class SVGLinearGradient extends SVGNode { + private float x1 = 0f, y1 = 0f, x2 = 1f, y2 = 0f; + private boolean userSpace; + private String href; + private final List stops = new ArrayList(); + + public float getX1() { return x1; } + public void setX1(float v) { this.x1 = v; } + public float getY1() { return y1; } + public void setY1(float v) { this.y1 = v; } + public float getX2() { return x2; } + public void setX2(float v) { this.x2 = v; } + public float getY2() { return y2; } + public void setY2(float v) { this.y2 = v; } + + public boolean isUserSpace() { return userSpace; } + public void setUserSpace(boolean userSpace) { this.userSpace = userSpace; } + + public String getHref() { return href; } + public void setHref(String href) { this.href = href; } + + public List getStops() { return stops; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGNode.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGNode.java new file mode 100644 index 0000000000..8c328e9d53 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGNode.java @@ -0,0 +1,27 @@ +package com.codename1.svg.transcoder.model; + +import com.codename1.svg.transcoder.parser.SVGStyle; +import com.codename1.svg.transcoder.parser.SVGTransform; + +import java.util.ArrayList; +import java.util.List; + +/** Base class for every parsed SVG element. */ +public abstract class SVGNode { + private String id; + private SVGStyle style = new SVGStyle(); + private SVGTransform transform; + private final List animations = new ArrayList(); + + public String getId() { return id; } + public void setId(String id) { this.id = id; } + + public SVGStyle getStyle() { return style; } + public void setStyle(SVGStyle style) { this.style = style; } + + public SVGTransform getTransform() { return transform; } + public void setTransform(SVGTransform transform) { this.transform = transform; } + + public List getAnimations() { return animations; } + public void addAnimation(SVGAnimation a) { animations.add(a); } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPath.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPath.java new file mode 100644 index 0000000000..eddac7f4d1 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPath.java @@ -0,0 +1,12 @@ +package com.codename1.svg.transcoder.model; + +import com.codename1.svg.transcoder.parser.PathCommand; + +import java.util.List; + +public final class SVGPath extends SVGShape { + private List commands; + + public List getCommands() { return commands; } + public void setCommands(List commands) { this.commands = commands; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPolygon.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPolygon.java new file mode 100644 index 0000000000..81da68fb42 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPolygon.java @@ -0,0 +1,6 @@ +package com.codename1.svg.transcoder.model; + +public final class SVGPolygon extends SVGPolyline { + @Override + public boolean isClosed() { return true; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPolyline.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPolyline.java new file mode 100644 index 0000000000..de70283ddd --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGPolyline.java @@ -0,0 +1,12 @@ +package com.codename1.svg.transcoder.model; + +/** <polyline> -- an open polyline. */ +public class SVGPolyline extends SVGShape { + private float[] points = new float[0]; + + public float[] getPoints() { return points; } + public void setPoints(float[] points) { this.points = points == null ? new float[0] : points; } + + /** True when the figure should be closed (polygon). */ + public boolean isClosed() { return false; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGRadialGradient.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGRadialGradient.java new file mode 100644 index 0000000000..04db143c0f --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGRadialGradient.java @@ -0,0 +1,26 @@ +package com.codename1.svg.transcoder.model; + +import java.util.ArrayList; +import java.util.List; + +public final class SVGRadialGradient extends SVGNode { + private float cx = 0.5f, cy = 0.5f, r = 0.5f; + private boolean userSpace; + private String href; + private final List stops = new ArrayList(); + + public float getCx() { return cx; } + public void setCx(float cx) { this.cx = cx; } + public float getCy() { return cy; } + public void setCy(float cy) { this.cy = cy; } + public float getR() { return r; } + public void setR(float r) { this.r = r; } + + public boolean isUserSpace() { return userSpace; } + public void setUserSpace(boolean userSpace) { this.userSpace = userSpace; } + + public String getHref() { return href; } + public void setHref(String href) { this.href = href; } + + public List getStops() { return stops; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGRect.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGRect.java new file mode 100644 index 0000000000..61638f04a7 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGRect.java @@ -0,0 +1,18 @@ +package com.codename1.svg.transcoder.model; + +public final class SVGRect extends SVGShape { + private float x, y, width, height, rx, ry; + + public float getX() { return x; } + public void setX(float x) { this.x = x; } + public float getY() { return y; } + public void setY(float y) { this.y = y; } + public float getWidth() { return width; } + public void setWidth(float w) { this.width = w; } + public float getHeight() { return height; } + public void setHeight(float h) { this.height = h; } + public float getRx() { return rx; } + public void setRx(float rx) { this.rx = rx; } + public float getRy() { return ry; } + public void setRy(float ry) { this.ry = ry; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGShape.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGShape.java new file mode 100644 index 0000000000..23ec8b40a5 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGShape.java @@ -0,0 +1,5 @@ +package com.codename1.svg.transcoder.model; + +/** Base for shape elements: rect, circle, ellipse, line, path, polyline, polygon. */ +public abstract class SVGShape extends SVGNode { +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGText.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGText.java new file mode 100644 index 0000000000..fbcd8deb70 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/model/SVGText.java @@ -0,0 +1,46 @@ +package com.codename1.svg.transcoder.model; + +/** + * <text> element. Treated as a single styled run -- <tspan> + * children inherit the parent text's style but are flattened into the + * combined content string. Supports SVG's start / middle / end anchor + * positioning and a single (x, y) baseline; per-character coordinate + * lists are not implemented. + */ +public final class SVGText extends SVGShape { + + public enum Anchor { START, MIDDLE, END } + + private float x; + private float y; + private String content = ""; + private String fontFamily; + private float fontSize; + private boolean bold; + private boolean italic; + private Anchor anchor = Anchor.START; + + public float getX() { return x; } + public void setX(float x) { this.x = x; } + + public float getY() { return y; } + public void setY(float y) { this.y = y; } + + public String getContent() { return content; } + public void setContent(String content) { this.content = content == null ? "" : content; } + + public String getFontFamily() { return fontFamily; } + public void setFontFamily(String fontFamily) { this.fontFamily = fontFamily; } + + public float getFontSize() { return fontSize; } + public void setFontSize(float fontSize) { this.fontSize = fontSize; } + + public boolean isBold() { return bold; } + public void setBold(boolean bold) { this.bold = bold; } + + public boolean isItalic() { return italic; } + public void setItalic(boolean italic) { this.italic = italic; } + + public Anchor getAnchor() { return anchor; } + public void setAnchor(Anchor anchor) { this.anchor = anchor == null ? Anchor.START : anchor; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/package-info.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/package-info.java new file mode 100644 index 0000000000..944bf960db --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/package-info.java @@ -0,0 +1,6 @@ +/** + * Build-time SVG -> Java transcoder. See {@link com.codename1.svg.transcoder.SVGTranscoder} + * for the entry point. Generated classes extend + * {@code com.codename1.svg.GeneratedSVGImage} from the core runtime. + */ +package com.codename1.svg.transcoder; diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/ColorParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/ColorParser.java new file mode 100644 index 0000000000..a569aac6c6 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/ColorParser.java @@ -0,0 +1,276 @@ +package com.codename1.svg.transcoder.parser; + +import java.util.HashMap; +import java.util.Map; + +/** + * Parses CSS-style color values used by SVG: #RGB, #RRGGBB, rgb(r,g,b), + * rgba(r,g,b,a), or one of the named CSS colors. Returns an ARGB int. + * + * "none" and "currentColor" do not return a color -- callers must check for + * them up front via {@link #isNone(String)} and {@link #isCurrentColor(String)}. + */ +public final class ColorParser { + + public static final int TRANSPARENT = 0x00000000; + public static final int BLACK = 0xFF000000; + + private static final Map NAMED = new HashMap(); + + static { + // CSS color names (subset of the SVG 1.1 named-color list, covers the common ones) + NAMED.put("aliceblue", 0xFFF0F8FF); + NAMED.put("antiquewhite", 0xFFFAEBD7); + NAMED.put("aqua", 0xFF00FFFF); + NAMED.put("aquamarine", 0xFF7FFFD4); + NAMED.put("azure", 0xFFF0FFFF); + NAMED.put("beige", 0xFFF5F5DC); + NAMED.put("bisque", 0xFFFFE4C4); + NAMED.put("black", 0xFF000000); + NAMED.put("blanchedalmond", 0xFFFFEBCD); + NAMED.put("blue", 0xFF0000FF); + NAMED.put("blueviolet", 0xFF8A2BE2); + NAMED.put("brown", 0xFFA52A2A); + NAMED.put("burlywood", 0xFFDEB887); + NAMED.put("cadetblue", 0xFF5F9EA0); + NAMED.put("chartreuse", 0xFF7FFF00); + NAMED.put("chocolate", 0xFFD2691E); + NAMED.put("coral", 0xFFFF7F50); + NAMED.put("cornflowerblue", 0xFF6495ED); + NAMED.put("cornsilk", 0xFFFFF8DC); + NAMED.put("crimson", 0xFFDC143C); + NAMED.put("cyan", 0xFF00FFFF); + NAMED.put("darkblue", 0xFF00008B); + NAMED.put("darkcyan", 0xFF008B8B); + NAMED.put("darkgoldenrod", 0xFFB8860B); + NAMED.put("darkgray", 0xFFA9A9A9); + NAMED.put("darkgrey", 0xFFA9A9A9); + NAMED.put("darkgreen", 0xFF006400); + NAMED.put("darkkhaki", 0xFFBDB76B); + NAMED.put("darkmagenta", 0xFF8B008B); + NAMED.put("darkolivegreen", 0xFF556B2F); + NAMED.put("darkorange", 0xFFFF8C00); + NAMED.put("darkorchid", 0xFF9932CC); + NAMED.put("darkred", 0xFF8B0000); + NAMED.put("darksalmon", 0xFFE9967A); + NAMED.put("darkseagreen", 0xFF8FBC8F); + NAMED.put("darkslateblue", 0xFF483D8B); + NAMED.put("darkslategray", 0xFF2F4F4F); + NAMED.put("darkslategrey", 0xFF2F4F4F); + NAMED.put("darkturquoise", 0xFF00CED1); + NAMED.put("darkviolet", 0xFF9400D3); + NAMED.put("deeppink", 0xFFFF1493); + NAMED.put("deepskyblue", 0xFF00BFFF); + NAMED.put("dimgray", 0xFF696969); + NAMED.put("dimgrey", 0xFF696969); + NAMED.put("dodgerblue", 0xFF1E90FF); + NAMED.put("firebrick", 0xFFB22222); + NAMED.put("floralwhite", 0xFFFFFAF0); + NAMED.put("forestgreen", 0xFF228B22); + NAMED.put("fuchsia", 0xFFFF00FF); + NAMED.put("gainsboro", 0xFFDCDCDC); + NAMED.put("ghostwhite", 0xFFF8F8FF); + NAMED.put("gold", 0xFFFFD700); + NAMED.put("goldenrod", 0xFFDAA520); + NAMED.put("gray", 0xFF808080); + NAMED.put("grey", 0xFF808080); + NAMED.put("green", 0xFF008000); + NAMED.put("greenyellow", 0xFFADFF2F); + NAMED.put("honeydew", 0xFFF0FFF0); + NAMED.put("hotpink", 0xFFFF69B4); + NAMED.put("indianred", 0xFFCD5C5C); + NAMED.put("indigo", 0xFF4B0082); + NAMED.put("ivory", 0xFFFFFFF0); + NAMED.put("khaki", 0xFFF0E68C); + NAMED.put("lavender", 0xFFE6E6FA); + NAMED.put("lavenderblush", 0xFFFFF0F5); + NAMED.put("lawngreen", 0xFF7CFC00); + NAMED.put("lemonchiffon", 0xFFFFFACD); + NAMED.put("lightblue", 0xFFADD8E6); + NAMED.put("lightcoral", 0xFFF08080); + NAMED.put("lightcyan", 0xFFE0FFFF); + NAMED.put("lightgoldenrodyellow", 0xFFFAFAD2); + NAMED.put("lightgray", 0xFFD3D3D3); + NAMED.put("lightgrey", 0xFFD3D3D3); + NAMED.put("lightgreen", 0xFF90EE90); + NAMED.put("lightpink", 0xFFFFB6C1); + NAMED.put("lightsalmon", 0xFFFFA07A); + NAMED.put("lightseagreen", 0xFF20B2AA); + NAMED.put("lightskyblue", 0xFF87CEFA); + NAMED.put("lightslategray", 0xFF778899); + NAMED.put("lightslategrey", 0xFF778899); + NAMED.put("lightsteelblue", 0xFFB0C4DE); + NAMED.put("lightyellow", 0xFFFFFFE0); + NAMED.put("lime", 0xFF00FF00); + NAMED.put("limegreen", 0xFF32CD32); + NAMED.put("linen", 0xFFFAF0E6); + NAMED.put("magenta", 0xFFFF00FF); + NAMED.put("maroon", 0xFF800000); + NAMED.put("mediumaquamarine", 0xFF66CDAA); + NAMED.put("mediumblue", 0xFF0000CD); + NAMED.put("mediumorchid", 0xFFBA55D3); + NAMED.put("mediumpurple", 0xFF9370DB); + NAMED.put("mediumseagreen", 0xFF3CB371); + NAMED.put("mediumslateblue", 0xFF7B68EE); + NAMED.put("mediumspringgreen", 0xFF00FA9A); + NAMED.put("mediumturquoise", 0xFF48D1CC); + NAMED.put("mediumvioletred", 0xFFC71585); + NAMED.put("midnightblue", 0xFF191970); + NAMED.put("mintcream", 0xFFF5FFFA); + NAMED.put("mistyrose", 0xFFFFE4E1); + NAMED.put("moccasin", 0xFFFFE4B5); + NAMED.put("navajowhite", 0xFFFFDEAD); + NAMED.put("navy", 0xFF000080); + NAMED.put("oldlace", 0xFFFDF5E6); + NAMED.put("olive", 0xFF808000); + NAMED.put("olivedrab", 0xFF6B8E23); + NAMED.put("orange", 0xFFFFA500); + NAMED.put("orangered", 0xFFFF4500); + NAMED.put("orchid", 0xFFDA70D6); + NAMED.put("palegoldenrod", 0xFFEEE8AA); + NAMED.put("palegreen", 0xFF98FB98); + NAMED.put("paleturquoise", 0xFFAFEEEE); + NAMED.put("palevioletred", 0xFFDB7093); + NAMED.put("papayawhip", 0xFFFFEFD5); + NAMED.put("peachpuff", 0xFFFFDAB9); + NAMED.put("peru", 0xFFCD853F); + NAMED.put("pink", 0xFFFFC0CB); + NAMED.put("plum", 0xFFDDA0DD); + NAMED.put("powderblue", 0xFFB0E0E6); + NAMED.put("purple", 0xFF800080); + NAMED.put("rebeccapurple", 0xFF663399); + NAMED.put("red", 0xFFFF0000); + NAMED.put("rosybrown", 0xFFBC8F8F); + NAMED.put("royalblue", 0xFF4169E1); + NAMED.put("saddlebrown", 0xFF8B4513); + NAMED.put("salmon", 0xFFFA8072); + NAMED.put("sandybrown", 0xFFF4A460); + NAMED.put("seagreen", 0xFF2E8B57); + NAMED.put("seashell", 0xFFFFF5EE); + NAMED.put("sienna", 0xFFA0522D); + NAMED.put("silver", 0xFFC0C0C0); + NAMED.put("skyblue", 0xFF87CEEB); + NAMED.put("slateblue", 0xFF6A5ACD); + NAMED.put("slategray", 0xFF708090); + NAMED.put("slategrey", 0xFF708090); + NAMED.put("snow", 0xFFFFFAFA); + NAMED.put("springgreen", 0xFF00FF7F); + NAMED.put("steelblue", 0xFF4682B4); + NAMED.put("tan", 0xFFD2B48C); + NAMED.put("teal", 0xFF008080); + NAMED.put("thistle", 0xFFD8BFD8); + NAMED.put("tomato", 0xFFFF6347); + NAMED.put("transparent", 0x00000000); + NAMED.put("turquoise", 0xFF40E0D0); + NAMED.put("violet", 0xFFEE82EE); + NAMED.put("wheat", 0xFFF5DEB3); + NAMED.put("white", 0xFFFFFFFF); + NAMED.put("whitesmoke", 0xFFF5F5F5); + NAMED.put("yellow", 0xFFFFFF00); + NAMED.put("yellowgreen", 0xFF9ACD32); + } + + private ColorParser() { } + + public static boolean isNone(String value) { + return value != null && "none".equalsIgnoreCase(value.trim()); + } + + public static boolean isCurrentColor(String value) { + return value != null && "currentColor".equalsIgnoreCase(value.trim()); + } + + /** + * Parse a color value. Returns ARGB int with alpha set to 0xFF for opaque + * formats. Throws IllegalArgumentException for unknown values. + */ + public static int parse(String value) { + if (value == null) throw new IllegalArgumentException("null color"); + String v = value.trim(); + if (v.isEmpty()) throw new IllegalArgumentException("empty color"); + if (v.charAt(0) == '#') return parseHex(v); + if (v.startsWith("rgb")) return parseRgb(v); + Integer named = NAMED.get(v.toLowerCase()); + if (named != null) return named; + throw new IllegalArgumentException("Unrecognized color: " + value); + } + + /** Same as {@link #parse} but returns {@code fallback} on unknown input. */ + public static int parseOrDefault(String value, int fallback) { + try { + return parse(value); + } catch (RuntimeException e) { + return fallback; + } + } + + private static int parseHex(String v) { + String hex = v.substring(1); + int r, g, b, a = 0xFF; + if (hex.length() == 3) { + r = nib(hex.charAt(0)); r |= r << 4; + g = nib(hex.charAt(1)); g |= g << 4; + b = nib(hex.charAt(2)); b |= b << 4; + } else if (hex.length() == 4) { + r = nib(hex.charAt(0)); r |= r << 4; + g = nib(hex.charAt(1)); g |= g << 4; + b = nib(hex.charAt(2)); b |= b << 4; + a = nib(hex.charAt(3)); a |= a << 4; + } else if (hex.length() == 6) { + r = (nib(hex.charAt(0)) << 4) | nib(hex.charAt(1)); + g = (nib(hex.charAt(2)) << 4) | nib(hex.charAt(3)); + b = (nib(hex.charAt(4)) << 4) | nib(hex.charAt(5)); + } else if (hex.length() == 8) { + r = (nib(hex.charAt(0)) << 4) | nib(hex.charAt(1)); + g = (nib(hex.charAt(2)) << 4) | nib(hex.charAt(3)); + b = (nib(hex.charAt(4)) << 4) | nib(hex.charAt(5)); + a = (nib(hex.charAt(6)) << 4) | nib(hex.charAt(7)); + } else { + throw new IllegalArgumentException("Bad hex color: " + v); + } + return ((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF); + } + + private static int nib(char c) { + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'a' && c <= 'f') return c - 'a' + 10; + if (c >= 'A' && c <= 'F') return c - 'A' + 10; + throw new IllegalArgumentException("Bad hex digit: " + c); + } + + private static int parseRgb(String v) { + boolean hasAlpha = v.startsWith("rgba"); + int open = v.indexOf('('); + int close = v.lastIndexOf(')'); + if (open < 0 || close < 0 || close <= open) { + throw new IllegalArgumentException("Bad rgb color: " + v); + } + String inside = v.substring(open + 1, close); + String[] parts = inside.split(","); + if (parts.length < 3) throw new IllegalArgumentException("Bad rgb color: " + v); + int r = component(parts[0]); + int g = component(parts[1]); + int b = component(parts[2]); + int a = 0xFF; + if (hasAlpha && parts.length >= 4) { + float af = Float.parseFloat(parts[3].trim()); + a = Math.round(af * 255f) & 0xFF; + } + return ((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF); + } + + private static int component(String s) { + String t = s.trim(); + if (t.endsWith("%")) { + float p = Float.parseFloat(t.substring(0, t.length() - 1).trim()); + return clamp(Math.round(p * 255f / 100f)); + } + return clamp((int) Math.round(Double.parseDouble(t))); + } + + private static int clamp(int v) { + if (v < 0) return 0; + if (v > 255) return 255; + return v; + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/NumberParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/NumberParser.java new file mode 100644 index 0000000000..b3eb9dc5dd --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/NumberParser.java @@ -0,0 +1,82 @@ +package com.codename1.svg.transcoder.parser; + +/** Shared scanner state for SVG numeric lists. Trims units like px, pt, %. */ +public final class NumberParser { + + private final String s; + private int pos; + + public NumberParser(String s) { + this.s = s == null ? "" : s; + } + + public boolean hasMore() { + skipWsAndCommas(); + return pos < s.length(); + } + + public float nextFloat() { + skipWsAndCommas(); + int start = pos; + int len = s.length(); + if (pos < len && (s.charAt(pos) == '+' || s.charAt(pos) == '-')) pos++; + boolean sawDigit = false; + while (pos < len && Character.isDigit(s.charAt(pos))) { pos++; sawDigit = true; } + if (pos < len && s.charAt(pos) == '.') { + pos++; + while (pos < len && Character.isDigit(s.charAt(pos))) { pos++; sawDigit = true; } + } + if (pos < len && (s.charAt(pos) == 'e' || s.charAt(pos) == 'E')) { + pos++; + if (pos < len && (s.charAt(pos) == '+' || s.charAt(pos) == '-')) pos++; + while (pos < len && Character.isDigit(s.charAt(pos))) pos++; + } + if (!sawDigit) { + throw new IllegalArgumentException("Expected number at " + start + " in '" + s + "'"); + } + String tok = s.substring(start, pos); + // tolerate trailing unit + while (pos < len) { + char c = s.charAt(pos); + if (Character.isLetter(c) || c == '%') pos++; + else break; + } + return Float.parseFloat(tok); + } + + /** Read a binary flag (0 or 1) -- used by SVG arc commands. */ + public int nextFlag() { + skipWsAndCommas(); + if (pos >= s.length()) { + throw new IllegalArgumentException("Expected flag in '" + s + "'"); + } + char c = s.charAt(pos++); + if (c != '0' && c != '1') { + throw new IllegalArgumentException("Expected flag (0 or 1) at " + (pos - 1) + " in '" + s + "'"); + } + return c - '0'; + } + + private void skipWsAndCommas() { + int len = s.length(); + while (pos < len) { + char c = s.charAt(pos); + if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ',') pos++; + else break; + } + } + + /** Parse a single float possibly suffixed with a unit. */ + public static float parseFloat(String value) { + if (value == null) return 0f; + String v = value.trim(); + if (v.isEmpty()) return 0f; + int end = v.length(); + while (end > 0) { + char c = v.charAt(end - 1); + if (Character.isLetter(c) || c == '%') end--; + else break; + } + return Float.parseFloat(v.substring(0, end)); + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/PathCommand.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/PathCommand.java new file mode 100644 index 0000000000..ccf9cd3a80 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/PathCommand.java @@ -0,0 +1,25 @@ +package com.codename1.svg.transcoder.parser; + +/** + * One absolute-coordinate command from an SVG path's d="..." attribute. + * + * The parser collapses relative commands to absolute, S/T smooth curves to + * the equivalent C/Q with the implicit control point already resolved, and + * H/V to L. Arc commands are kept as ARC so the generator can decompose + * them into cubic Bezier segments at codegen time. + */ +public final class PathCommand { + + public enum Type { MOVE, LINE, CUBIC, QUAD, ARC, CLOSE } + + private final Type type; + private final float[] args; + + public PathCommand(Type type, float[] args) { + this.type = type; + this.args = args; + } + + public Type getType() { return type; } + public float[] getArgs() { return args; } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/PathDataParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/PathDataParser.java new file mode 100644 index 0000000000..c889760c89 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/PathDataParser.java @@ -0,0 +1,238 @@ +package com.codename1.svg.transcoder.parser; + +import java.util.ArrayList; +import java.util.List; + +/** + * Parses the SVG path d="..." mini-language to a flat list of absolute-coordinate + * {@link PathCommand}s. Implicit repeats, relative coordinates and smooth-curve + * control-point reflection are resolved here so the code generator stays simple. + */ +public final class PathDataParser { + + private PathDataParser() { } + + public static List parse(String d) { + List out = new ArrayList(); + if (d == null || d.trim().isEmpty()) return out; + + // We scan the string by splitting on command letters but preserving them as separators. + // It is easier to walk character-by-character. + char[] cs = d.toCharArray(); + int i = 0; + int len = cs.length; + + float curX = 0, curY = 0; // current point + float startX = 0, startY = 0; // subpath start point (for Z) + char lastCmd = 0; + float prevCubicCtrlX = 0, prevCubicCtrlY = 0; + float prevQuadCtrlX = 0, prevQuadCtrlY = 0; + boolean haveCubic = false; + boolean haveQuad = false; + + while (i < len) { + // skip whitespace and commas + while (i < len && (isWs(cs[i]) || cs[i] == ',')) i++; + if (i >= len) break; + + char c = cs[i]; + char cmd; + if (isCmdLetter(c)) { + cmd = c; + i++; + lastCmd = cmd; + } else { + // Implicit repeat: re-use last cmd (M repeats become L, m become l). + if (lastCmd == 0) { + throw new IllegalArgumentException("Path data starts with a number: '" + d + "'"); + } + if (lastCmd == 'M') cmd = 'L'; + else if (lastCmd == 'm') cmd = 'l'; + else cmd = lastCmd; + } + + // Find the end of this command's numeric arguments -- the next command letter. + int argStart = i; + while (i < len && !isCmdLetter(cs[i])) i++; + String argStr = new String(cs, argStart, i - argStart); + NumberParser np = new NumberParser(argStr); + + switch (cmd) { + case 'M': + case 'm': { + boolean rel = cmd == 'm'; + boolean first = true; + while (np.hasMore()) { + float x = np.nextFloat(); + float y = np.nextFloat(); + if (rel) { x += curX; y += curY; } + if (first) { + out.add(new PathCommand(PathCommand.Type.MOVE, new float[]{x, y})); + startX = x; startY = y; + first = false; + } else { + out.add(new PathCommand(PathCommand.Type.LINE, new float[]{x, y})); + } + curX = x; curY = y; + } + haveCubic = haveQuad = false; + break; + } + case 'L': + case 'l': { + boolean rel = cmd == 'l'; + while (np.hasMore()) { + float x = np.nextFloat(); + float y = np.nextFloat(); + if (rel) { x += curX; y += curY; } + out.add(new PathCommand(PathCommand.Type.LINE, new float[]{x, y})); + curX = x; curY = y; + } + haveCubic = haveQuad = false; + break; + } + case 'H': + case 'h': { + boolean rel = cmd == 'h'; + while (np.hasMore()) { + float x = np.nextFloat(); + if (rel) x += curX; + out.add(new PathCommand(PathCommand.Type.LINE, new float[]{x, curY})); + curX = x; + } + haveCubic = haveQuad = false; + break; + } + case 'V': + case 'v': { + boolean rel = cmd == 'v'; + while (np.hasMore()) { + float y = np.nextFloat(); + if (rel) y += curY; + out.add(new PathCommand(PathCommand.Type.LINE, new float[]{curX, y})); + curY = y; + } + haveCubic = haveQuad = false; + break; + } + case 'C': + case 'c': { + boolean rel = cmd == 'c'; + while (np.hasMore()) { + float x1 = np.nextFloat(), y1 = np.nextFloat(); + float x2 = np.nextFloat(), y2 = np.nextFloat(); + float x = np.nextFloat(), y = np.nextFloat(); + if (rel) { x1 += curX; y1 += curY; x2 += curX; y2 += curY; x += curX; y += curY; } + out.add(new PathCommand(PathCommand.Type.CUBIC, new float[]{x1, y1, x2, y2, x, y})); + prevCubicCtrlX = x2; prevCubicCtrlY = y2; + curX = x; curY = y; + haveCubic = true; haveQuad = false; + } + break; + } + case 'S': + case 's': { + boolean rel = cmd == 's'; + while (np.hasMore()) { + float x1, y1; + if (haveCubic) { + x1 = 2 * curX - prevCubicCtrlX; + y1 = 2 * curY - prevCubicCtrlY; + } else { + x1 = curX; y1 = curY; + } + float x2 = np.nextFloat(), y2 = np.nextFloat(); + float x = np.nextFloat(), y = np.nextFloat(); + if (rel) { x2 += curX; y2 += curY; x += curX; y += curY; } + out.add(new PathCommand(PathCommand.Type.CUBIC, new float[]{x1, y1, x2, y2, x, y})); + prevCubicCtrlX = x2; prevCubicCtrlY = y2; + curX = x; curY = y; + haveCubic = true; haveQuad = false; + } + break; + } + case 'Q': + case 'q': { + boolean rel = cmd == 'q'; + while (np.hasMore()) { + float x1 = np.nextFloat(), y1 = np.nextFloat(); + float x = np.nextFloat(), y = np.nextFloat(); + if (rel) { x1 += curX; y1 += curY; x += curX; y += curY; } + out.add(new PathCommand(PathCommand.Type.QUAD, new float[]{x1, y1, x, y})); + prevQuadCtrlX = x1; prevQuadCtrlY = y1; + curX = x; curY = y; + haveQuad = true; haveCubic = false; + } + break; + } + case 'T': + case 't': { + boolean rel = cmd == 't'; + while (np.hasMore()) { + float x1, y1; + if (haveQuad) { + x1 = 2 * curX - prevQuadCtrlX; + y1 = 2 * curY - prevQuadCtrlY; + } else { + x1 = curX; y1 = curY; + } + float x = np.nextFloat(), y = np.nextFloat(); + if (rel) { x += curX; y += curY; } + out.add(new PathCommand(PathCommand.Type.QUAD, new float[]{x1, y1, x, y})); + prevQuadCtrlX = x1; prevQuadCtrlY = y1; + curX = x; curY = y; + haveQuad = true; haveCubic = false; + } + break; + } + case 'A': + case 'a': { + boolean rel = cmd == 'a'; + while (np.hasMore()) { + float rx = np.nextFloat(); + float ry = np.nextFloat(); + float xRot = np.nextFloat(); + int largeArc = np.nextFlag(); + int sweep = np.nextFlag(); + float x = np.nextFloat(); + float y = np.nextFloat(); + if (rel) { x += curX; y += curY; } + out.add(new PathCommand(PathCommand.Type.ARC, + new float[]{curX, curY, rx, ry, xRot, largeArc, sweep, x, y})); + curX = x; curY = y; + haveCubic = haveQuad = false; + } + break; + } + case 'Z': + case 'z': { + out.add(new PathCommand(PathCommand.Type.CLOSE, new float[0])); + curX = startX; curY = startY; + haveCubic = haveQuad = false; + break; + } + default: + throw new IllegalArgumentException("Unknown path command '" + cmd + "' in '" + d + "'"); + } + } + return out; + } + + private static boolean isCmdLetter(char c) { + switch (c) { + case 'M': case 'm': case 'L': case 'l': + case 'H': case 'h': case 'V': case 'v': + case 'C': case 'c': case 'S': case 's': + case 'Q': case 'q': case 'T': case 't': + case 'A': case 'a': + case 'Z': case 'z': + return true; + default: + return false; + } + } + + private static boolean isWs(char c) { + return c == ' ' || c == '\t' || c == '\n' || c == '\r'; + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGPaint.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGPaint.java new file mode 100644 index 0000000000..8783935825 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGPaint.java @@ -0,0 +1,51 @@ +package com.codename1.svg.transcoder.parser; + +/** + * A paint value: either a solid ARGB color, a reference to a gradient + * definition by id (set via {@link #setReference}), or "none". + */ +public final class SVGPaint { + + public static final SVGPaint NONE = new SVGPaint(true, 0, null); + public static final SVGPaint BLACK = new SVGPaint(false, 0xFF000000, null); + + private final boolean none; + private final int color; + private final String reference; + + private SVGPaint(boolean none, int color, String reference) { + this.none = none; + this.color = color; + this.reference = reference; + } + + public static SVGPaint ofColor(int argb) { + return new SVGPaint(false, argb, null); + } + + public static SVGPaint ofReference(String id) { + return new SVGPaint(false, 0, id); + } + + public boolean isNone() { return none; } + public int getColor() { return color; } + public String getReference() { return reference; } + public boolean isReference() { return reference != null; } + + public static SVGPaint setReference(String value) { + String r = stripUrl(value); + return r == null ? null : ofReference(r); + } + + /** "url(#foo)" -> "foo"; returns null otherwise. */ + public static String stripUrl(String s) { + if (s == null) return null; + String t = s.trim(); + if (!t.startsWith("url(")) return null; + int close = t.indexOf(')', 4); + if (close < 0) return null; + String inside = t.substring(4, close).trim(); + if (inside.startsWith("#")) inside = inside.substring(1); + return inside; + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGParser.java new file mode 100644 index 0000000000..d0197c841d --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGParser.java @@ -0,0 +1,498 @@ +package com.codename1.svg.transcoder.parser; + +import com.codename1.svg.transcoder.animation.SMILParser; +import com.codename1.svg.transcoder.model.*; + +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Walks an SVG XML document with StAX and builds a {@link SVGDocument} tree. + * + * Element coverage: + * svg, g, defs + * rect, circle, ellipse, line, polyline, polygon, path + * linearGradient, radialGradient, stop + * animate, animateTransform, set, title, desc (last two ignored). + * + * Anything else is skipped silently so an unfamiliar element won't fail the + * whole build -- the transcoder errs on the side of "render what we can". + */ +public final class SVGParser { + + public SVGDocument parse(InputStream in) throws IOException { + XMLInputFactory f = XMLInputFactory.newInstance(); + // harden against XXE + f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE); + f.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE); + try { + XMLStreamReader r = f.createXMLStreamReader(in); + try { + return parseDocument(r); + } finally { + r.close(); + } + } catch (XMLStreamException e) { + throw new IOException(e); + } + } + + private SVGDocument parseDocument(XMLStreamReader r) throws XMLStreamException { + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.START_ELEMENT && "svg".equals(r.getLocalName())) { + SVGDocument doc = new SVGDocument(); + readSVGRoot(r, doc); + readChildren(r, doc, doc); + return doc; + } + } + throw new XMLStreamException("No root found"); + } + + private void readSVGRoot(XMLStreamReader r, SVGDocument doc) { + Map a = attrs(r); + applyCommon(doc, a); + doc.setWidth(NumberParser.parseFloat(a.get("width"))); + doc.setHeight(NumberParser.parseFloat(a.get("height"))); + String vb = a.get("viewBox"); + if (vb != null) { + NumberParser np = new NumberParser(vb); + try { + doc.setViewBoxX(np.nextFloat()); + doc.setViewBoxY(np.nextFloat()); + doc.setViewBoxWidth(np.nextFloat()); + doc.setViewBoxHeight(np.nextFloat()); + } catch (RuntimeException e) { + // leave defaults + } + } + if (doc.getViewBoxWidth() == 0) doc.setViewBoxWidth(doc.getWidth()); + if (doc.getViewBoxHeight() == 0) doc.setViewBoxHeight(doc.getHeight()); + if (doc.getWidth() == 0) doc.setWidth(doc.getViewBoxWidth()); + if (doc.getHeight() == 0) doc.setHeight(doc.getViewBoxHeight()); + } + + private void readChildren(XMLStreamReader r, SVGGroup parent, SVGDocument doc) throws XMLStreamException { + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.END_ELEMENT) return; + if (ev != XMLStreamConstants.START_ELEMENT) continue; + + String name = r.getLocalName(); + if ("g".equals(name)) { + SVGGroup g = new SVGGroup(); + applyCommon(g, attrs(r)); + parent.addChild(g); + readChildren(r, g, doc); + } else if ("defs".equals(name)) { + readDefs(r, doc); + } else if ("rect".equals(name)) { + SVGRect rect = readRect(r); + parent.addChild(rect); + readNestedAnimations(r, rect); + } else if ("circle".equals(name)) { + SVGCircle circle = readCircle(r); + parent.addChild(circle); + readNestedAnimations(r, circle); + } else if ("ellipse".equals(name)) { + SVGEllipse el = readEllipse(r); + parent.addChild(el); + readNestedAnimations(r, el); + } else if ("line".equals(name)) { + SVGLine ln = readLine(r); + parent.addChild(ln); + readNestedAnimations(r, ln); + } else if ("polyline".equals(name)) { + SVGPolyline pl = readPolyline(r, false); + parent.addChild(pl); + readNestedAnimations(r, pl); + } else if ("polygon".equals(name)) { + SVGPolyline pg = readPolyline(r, true); + parent.addChild(pg); + readNestedAnimations(r, pg); + } else if ("path".equals(name)) { + SVGPath path = readPath(r); + parent.addChild(path); + readNestedAnimations(r, path); + } else if ("text".equals(name)) { + SVGText text = readText(r); + parent.addChild(text); + } else if ("linearGradient".equals(name)) { + SVGLinearGradient lg = readLinearGradient(r); + if (lg.getId() != null) doc.getDefinitions().put(lg.getId(), lg); + } else if ("radialGradient".equals(name)) { + SVGRadialGradient rg = readRadialGradient(r); + if (rg.getId() != null) doc.getDefinitions().put(rg.getId(), rg); + } else if ("clipPath".equals(name) || "mask".equals(name)) { + // Many SVGs declare clipPath outside . Accept both -- + // we don't render the clipPath inline, just register it as + // a definition for later clip-path="url(#id)" lookup. + SVGClipPath cp = readClipPath(r, doc); + if (cp.getId() != null) doc.getDefinitions().put(cp.getId(), cp); + } else if ("animate".equals(name) || "animateTransform".equals(name) || "set".equals(name)) { + SVGAnimation an = readAnimation(r, name); + // SVG semantics: as a sibling of shapes inside a + // animates the group itself (typically its transform). The + // shape-nested case ( inside , , etc.) + // is handled separately by readNestedAnimations. + parent.addAnimation(an); + consumeUntilEnd(r); + } else { + skip(r); + } + } + } + + private void readDefs(XMLStreamReader r, SVGDocument doc) throws XMLStreamException { + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.END_ELEMENT) return; + if (ev != XMLStreamConstants.START_ELEMENT) continue; + String name = r.getLocalName(); + if ("linearGradient".equals(name)) { + SVGLinearGradient lg = readLinearGradient(r); + if (lg.getId() != null) doc.getDefinitions().put(lg.getId(), lg); + } else if ("radialGradient".equals(name)) { + SVGRadialGradient rg = readRadialGradient(r); + if (rg.getId() != null) doc.getDefinitions().put(rg.getId(), rg); + } else if ("clipPath".equals(name) || "mask".equals(name)) { + // Mask treated as clip -- alpha masking falls back to opaque. + SVGClipPath cp = readClipPath(r, doc); + if (cp.getId() != null) doc.getDefinitions().put(cp.getId(), cp); + } else { + skip(r); + } + } + } + + private SVGClipPath readClipPath(XMLStreamReader r, SVGDocument doc) throws XMLStreamException { + SVGClipPath cp = new SVGClipPath(); + Map a = attrs(r); + cp.setId(a.get("id")); + readChildren(r, cp, doc); + return cp; + } + + private SVGRect readRect(XMLStreamReader r) { + SVGRect s = new SVGRect(); + Map a = attrs(r); + applyCommon(s, a); + s.setX(NumberParser.parseFloat(a.get("x"))); + s.setY(NumberParser.parseFloat(a.get("y"))); + s.setWidth(NumberParser.parseFloat(a.get("width"))); + s.setHeight(NumberParser.parseFloat(a.get("height"))); + s.setRx(NumberParser.parseFloat(a.get("rx"))); + s.setRy(NumberParser.parseFloat(a.get("ry"))); + return s; + } + + private SVGCircle readCircle(XMLStreamReader r) { + SVGCircle s = new SVGCircle(); + Map a = attrs(r); + applyCommon(s, a); + s.setCx(NumberParser.parseFloat(a.get("cx"))); + s.setCy(NumberParser.parseFloat(a.get("cy"))); + s.setR(NumberParser.parseFloat(a.get("r"))); + return s; + } + + private SVGEllipse readEllipse(XMLStreamReader r) { + SVGEllipse s = new SVGEllipse(); + Map a = attrs(r); + applyCommon(s, a); + s.setCx(NumberParser.parseFloat(a.get("cx"))); + s.setCy(NumberParser.parseFloat(a.get("cy"))); + s.setRx(NumberParser.parseFloat(a.get("rx"))); + s.setRy(NumberParser.parseFloat(a.get("ry"))); + return s; + } + + private SVGLine readLine(XMLStreamReader r) { + SVGLine s = new SVGLine(); + Map a = attrs(r); + applyCommon(s, a); + s.setX1(NumberParser.parseFloat(a.get("x1"))); + s.setY1(NumberParser.parseFloat(a.get("y1"))); + s.setX2(NumberParser.parseFloat(a.get("x2"))); + s.setY2(NumberParser.parseFloat(a.get("y2"))); + return s; + } + + private SVGPolyline readPolyline(XMLStreamReader r, boolean closed) { + SVGPolyline s = closed ? new SVGPolygon() : new SVGPolyline(); + Map a = attrs(r); + applyCommon(s, a); + String pts = a.get("points"); + if (pts != null) { + NumberParser np = new NumberParser(pts); + List list = new ArrayList(); + while (np.hasMore()) list.add(np.nextFloat()); + float[] arr = new float[list.size()]; + for (int i = 0; i < arr.length; i++) arr[i] = list.get(i); + s.setPoints(arr); + } + return s; + } + + private SVGText readText(XMLStreamReader r) throws XMLStreamException { + SVGText t = new SVGText(); + Map a = attrs(r); + applyCommon(t, a); + t.setX(NumberParser.parseFloat(a.get("x"))); + t.setY(NumberParser.parseFloat(a.get("y"))); + String anchor = mergedValue(a, "text-anchor"); + if (anchor != null) { + String norm = anchor.trim().toLowerCase(); + if ("middle".equals(norm)) t.setAnchor(SVGText.Anchor.MIDDLE); + else if ("end".equals(norm)) t.setAnchor(SVGText.Anchor.END); + } + String family = mergedValue(a, "font-family"); + if (family != null) { + t.setFontFamily(family.trim()); + } + String size = mergedValue(a, "font-size"); + if (size != null) { + try { t.setFontSize(NumberParser.parseFloat(size)); } catch (RuntimeException ignored) { /* default 0 */ } + } + String weight = mergedValue(a, "font-weight"); + if (weight != null) { + String w = weight.trim().toLowerCase(); + t.setBold("bold".equals(w) || "bolder".equals(w) || isNumericGte(w, 600)); + } + String style = mergedValue(a, "font-style"); + if (style != null) { + String s = style.trim().toLowerCase(); + t.setItalic("italic".equals(s) || "oblique".equals(s)); + } + // Collect character data; flatten any by recursing into its text. + StringBuilder content = new StringBuilder(); + readTextContent(r, content); + t.setContent(content.toString()); + return t; + } + + private void readTextContent(XMLStreamReader r, StringBuilder out) throws XMLStreamException { + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + return; + } + if (ev == XMLStreamConstants.CHARACTERS || ev == XMLStreamConstants.CDATA) { + out.append(r.getText()); + } else if (ev == XMLStreamConstants.START_ELEMENT) { + // tspan / textPath / etc. -- flatten the textual content. + readTextContent(r, out); + } + } + } + + private static boolean isNumericGte(String s, int threshold) { + try { + return Integer.parseInt(s) >= threshold; + } catch (NumberFormatException nfe) { + return false; + } + } + + private SVGPath readPath(XMLStreamReader r) { + SVGPath p = new SVGPath(); + Map a = attrs(r); + applyCommon(p, a); + p.setCommands(PathDataParser.parse(a.get("d"))); + return p; + } + + private SVGLinearGradient readLinearGradient(XMLStreamReader r) throws XMLStreamException { + SVGLinearGradient g = new SVGLinearGradient(); + Map a = attrs(r); + g.setId(a.get("id")); + if (a.containsKey("x1")) g.setX1(parseGradCoord(a.get("x1"))); + if (a.containsKey("y1")) g.setY1(parseGradCoord(a.get("y1"))); + if (a.containsKey("x2")) g.setX2(parseGradCoord(a.get("x2"))); + if (a.containsKey("y2")) g.setY2(parseGradCoord(a.get("y2"))); + if ("userSpaceOnUse".equals(a.get("gradientUnits"))) g.setUserSpace(true); + String href = a.get("href"); + if (href == null) href = a.get("xlink:href"); + if (href != null && href.startsWith("#")) g.setHref(href.substring(1)); + readGradientStops(r, g.getStops()); + return g; + } + + private SVGRadialGradient readRadialGradient(XMLStreamReader r) throws XMLStreamException { + SVGRadialGradient g = new SVGRadialGradient(); + Map a = attrs(r); + g.setId(a.get("id")); + if (a.containsKey("cx")) g.setCx(parseGradCoord(a.get("cx"))); + if (a.containsKey("cy")) g.setCy(parseGradCoord(a.get("cy"))); + if (a.containsKey("r")) g.setR(parseGradCoord(a.get("r"))); + if ("userSpaceOnUse".equals(a.get("gradientUnits"))) g.setUserSpace(true); + String href = a.get("href"); + if (href == null) href = a.get("xlink:href"); + if (href != null && href.startsWith("#")) g.setHref(href.substring(1)); + readGradientStops(r, g.getStops()); + return g; + } + + private float parseGradCoord(String s) { + if (s == null) return 0f; + String v = s.trim(); + if (v.endsWith("%")) { + return Float.parseFloat(v.substring(0, v.length() - 1)) / 100f; + } + return NumberParser.parseFloat(v); + } + + private void readGradientStops(XMLStreamReader r, List stops) throws XMLStreamException { + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.END_ELEMENT) return; + if (ev != XMLStreamConstants.START_ELEMENT) continue; + if (!"stop".equals(r.getLocalName())) { skip(r); continue; } + Map a = attrs(r); + SVGGradientStop stop = new SVGGradientStop(); + stop.setOffset(parseGradCoord(a.get("offset"))); + SVGStyle s = StyleParser.parse(presentationFor(a, "stop-color", "stop-opacity"), a.get("style")); + // stop-color is held as fill in our merged map. Use directly: + String sc = mergedValue(a, "stop-color"); + if (sc != null && !ColorParser.isNone(sc)) { + try { + stop.setColor(ColorParser.parse(sc)); + } catch (RuntimeException e) { + stop.setColor(ColorParser.BLACK); + } + } else if (s.getFill() != null && !s.getFill().isNone() && !s.getFill().isReference()) { + stop.setColor(s.getFill().getColor()); + } else { + stop.setColor(ColorParser.BLACK); + } + String so = mergedValue(a, "stop-opacity"); + if (so != null) { + try { stop.setOpacity(NumberParser.parseFloat(so)); } catch (RuntimeException e) { /* keep default */ } + } else if (s.getFillOpacity() != null) { + stop.setOpacity(s.getFillOpacity()); + } + stops.add(stop); + consumeUntilEnd(r); + } + } + + private String mergedValue(Map attrs, String key) { + if (attrs.containsKey(key)) return attrs.get(key); + String style = attrs.get("style"); + if (style == null) return null; + for (String decl : style.split(";")) { + int colon = decl.indexOf(':'); + if (colon <= 0) continue; + if (decl.substring(0, colon).trim().equals(key)) { + return decl.substring(colon + 1).trim(); + } + } + return null; + } + + private Map presentationFor(Map attrs, String... keys) { + Map out = new HashMap(); + for (String k : keys) { + if (attrs.containsKey(k)) out.put(k.startsWith("stop-") ? "fill" : k, attrs.get(k)); + } + // map stop-color -> fill, stop-opacity -> fill-opacity for reuse with StyleParser + if (attrs.containsKey("stop-color")) out.put("fill", attrs.get("stop-color")); + if (attrs.containsKey("stop-opacity")) out.put("fill-opacity", attrs.get("stop-opacity")); + return out; + } + + private SVGAnimation readAnimation(XMLStreamReader r, String elementName) { + SVGAnimation an = new SVGAnimation(); + Map a = attrs(r); + if ("animateTransform".equals(elementName)) { + an.setKind(SVGAnimation.Kind.ANIMATE_TRANSFORM); + an.setTransformType(SMILParser.parseTransformType(a.get("type"))); + } else if ("set".equals(elementName)) { + an.setKind(SVGAnimation.Kind.SET); + } else { + an.setKind(SVGAnimation.Kind.ANIMATE); + } + an.setAttributeName(a.get("attributeName")); + an.setFrom(a.get("from")); + an.setTo(a.get("to")); + an.setBy(a.get("by")); + an.setValues(SMILParser.parseValues(a.get("values"))); + an.setBeginMs(SMILParser.parseClock(a.get("begin"), 0)); + an.setDurMs(SMILParser.parseClock(a.get("dur"), 0)); + an.setRepeatCount(SMILParser.parseRepeatCount(a.get("repeatCount"))); + an.setCalcMode(SMILParser.parseCalcMode(a.get("calcMode"))); + an.setFreeze("freeze".equalsIgnoreCase(a.get("fill"))); + return an; + } + + private void applyCommon(SVGNode n, Map a) { + n.setId(a.get("id")); + String tr = a.get("transform"); + if (tr != null) { + SVGTransform t = TransformParser.parse(tr); + if (t != null) n.setTransform(t); + } + Map pres = new HashMap(); + for (Map.Entry e : a.entrySet()) { + String k = e.getKey(); + if ("fill".equals(k) || "stroke".equals(k) || "fill-opacity".equals(k) || "stroke-opacity".equals(k) + || "opacity".equals(k) || "stroke-width".equals(k) || "stroke-linecap".equals(k) + || "stroke-linejoin".equals(k) || "stroke-miterlimit".equals(k)) { + pres.put(k, e.getValue()); + } + } + n.setStyle(StyleParser.parse(pres, a.get("style"))); + } + + private Map attrs(XMLStreamReader r) { + Map m = new HashMap(); + int n = r.getAttributeCount(); + for (int i = 0; i < n; i++) { + String prefix = r.getAttributePrefix(i); + String name = r.getAttributeLocalName(i); + String key = (prefix == null || prefix.isEmpty()) ? name : prefix + ":" + name; + m.put(key, r.getAttributeValue(i)); + // also stash bare local name so callers can ignore namespace prefixes + m.put(name, r.getAttributeValue(i)); + } + return m; + } + + /** Read child elements of a shape -- currently only animation children matter. */ + private void readNestedAnimations(XMLStreamReader r, SVGNode shape) throws XMLStreamException { + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.END_ELEMENT) return; + if (ev != XMLStreamConstants.START_ELEMENT) continue; + String name = r.getLocalName(); + if ("animate".equals(name) || "animateTransform".equals(name) || "set".equals(name)) { + shape.addAnimation(readAnimation(r, name)); + consumeUntilEnd(r); + } else { + skip(r); + } + } + } + + private void consumeUntilEnd(XMLStreamReader r) throws XMLStreamException { + int depth = 1; + while (r.hasNext() && depth > 0) { + int ev = r.next(); + if (ev == XMLStreamConstants.START_ELEMENT) depth++; + else if (ev == XMLStreamConstants.END_ELEMENT) depth--; + } + } + + private void skip(XMLStreamReader r) throws XMLStreamException { + consumeUntilEnd(r); + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGStyle.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGStyle.java new file mode 100644 index 0000000000..52f3efba5c --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGStyle.java @@ -0,0 +1,67 @@ +package com.codename1.svg.transcoder.parser; + +/** + * Resolved style block for a node -- everything the renderer needs to fill / + * stroke this shape. Field "null" means "inherit from parent / leave unchanged". + */ +public final class SVGStyle { + + public static final int LINECAP_BUTT = 0; + public static final int LINECAP_ROUND = 1; + public static final int LINECAP_SQUARE = 2; + + public static final int LINEJOIN_MITER = 0; + public static final int LINEJOIN_ROUND = 1; + public static final int LINEJOIN_BEVEL = 2; + + private SVGPaint fill; + private SVGPaint stroke; + private Float fillOpacity; + private Float strokeOpacity; + private Float opacity; + private Float strokeWidth; + private Integer strokeLineCap; + private Integer strokeLineJoin; + private Float strokeMiterLimit; + /** Element id referenced by `clip-path: url(#id)`, or {@code null} when + * no clip is set. The id resolves to an [com.codename1.svg.transcoder.model.SVGClipPath] + * registered in the document's definitions map. */ + private String clipPathRef; + + public SVGPaint getFill() { return fill; } + public void setFill(SVGPaint fill) { this.fill = fill; } + public SVGPaint getStroke() { return stroke; } + public void setStroke(SVGPaint stroke) { this.stroke = stroke; } + public Float getFillOpacity() { return fillOpacity; } + public void setFillOpacity(Float v) { this.fillOpacity = v; } + public Float getStrokeOpacity() { return strokeOpacity; } + public void setStrokeOpacity(Float v) { this.strokeOpacity = v; } + public Float getOpacity() { return opacity; } + public void setOpacity(Float v) { this.opacity = v; } + public Float getStrokeWidth() { return strokeWidth; } + public void setStrokeWidth(Float v) { this.strokeWidth = v; } + public Integer getStrokeLineCap() { return strokeLineCap; } + public void setStrokeLineCap(Integer v) { this.strokeLineCap = v; } + public Integer getStrokeLineJoin() { return strokeLineJoin; } + public void setStrokeLineJoin(Integer v) { this.strokeLineJoin = v; } + public Float getStrokeMiterLimit() { return strokeMiterLimit; } + public void setStrokeMiterLimit(Float v) { this.strokeMiterLimit = v; } + public String getClipPathRef() { return clipPathRef; } + public void setClipPathRef(String clipPathRef) { this.clipPathRef = clipPathRef; } + + /** Overlay other's set fields on top of this. */ + public SVGStyle inherit(SVGStyle parent) { + if (parent == null) return this; + if (fill == null) fill = parent.fill; + if (stroke == null) stroke = parent.stroke; + if (fillOpacity == null) fillOpacity = parent.fillOpacity; + if (strokeOpacity == null) strokeOpacity = parent.strokeOpacity; + // opacity does NOT inherit per SVG spec -- leave alone. + if (strokeWidth == null) strokeWidth = parent.strokeWidth; + if (strokeLineCap == null) strokeLineCap = parent.strokeLineCap; + if (strokeLineJoin == null) strokeLineJoin = parent.strokeLineJoin; + if (strokeMiterLimit == null) strokeMiterLimit = parent.strokeMiterLimit; + // clip-path does NOT inherit per SVG spec. + return this; + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGTransform.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGTransform.java new file mode 100644 index 0000000000..04fa0c82e4 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/SVGTransform.java @@ -0,0 +1,65 @@ +package com.codename1.svg.transcoder.parser; + +/** + * Holds a fully-resolved 2D affine matrix: + * 
+ *   [ a c e ]
+ *   [ b d f ]
+ *   [ 0 0 1 ]
+ *
+ */ +public final class SVGTransform { + public final float a, b, c, d, e, f; + + public SVGTransform(float a, float b, float c, float d, float e, float f) { + this.a = a; this.b = b; this.c = c; this.d = d; this.e = e; this.f = f; + } + + public static SVGTransform identity() { + return new SVGTransform(1, 0, 0, 1, 0, 0); + } + + public static SVGTransform translate(float tx, float ty) { + return new SVGTransform(1, 0, 0, 1, tx, ty); + } + + public static SVGTransform scale(float sx, float sy) { + return new SVGTransform(sx, 0, 0, sy, 0, 0); + } + + public static SVGTransform rotate(float angleDeg, float cx, float cy) { + double r = Math.toRadians(angleDeg); + float cos = (float) Math.cos(r); + float sin = (float) Math.sin(r); + // Translate(cx,cy) * Rotate(angle) * Translate(-cx,-cy) + float a = cos, b = sin, c = -sin, d = cos; + float e = cx - cos * cx + sin * cy; + float f = cy - sin * cx - cos * cy; + return new SVGTransform(a, b, c, d, e, f); + } + + public static SVGTransform skewX(float angleDeg) { + float t = (float) Math.tan(Math.toRadians(angleDeg)); + return new SVGTransform(1, 0, t, 1, 0, 0); + } + + public static SVGTransform skewY(float angleDeg) { + float t = (float) Math.tan(Math.toRadians(angleDeg)); + return new SVGTransform(1, t, 0, 1, 0, 0); + } + + /** Returns this * o (this applied first conceptually under SVG's column-vector convention). */ + public SVGTransform multiply(SVGTransform o) { + return new SVGTransform( + a * o.a + c * o.b, + b * o.a + d * o.b, + a * o.c + c * o.d, + b * o.c + d * o.d, + a * o.e + c * o.f + e, + b * o.e + d * o.f + f); + } + + public boolean isIdentity() { + return a == 1f && b == 0f && c == 0f && d == 1f && e == 0f && f == 0f; + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/StyleParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/StyleParser.java new file mode 100644 index 0000000000..f51974f0f9 --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/StyleParser.java @@ -0,0 +1,90 @@ +package com.codename1.svg.transcoder.parser; + +import java.util.HashMap; +import java.util.Map; + +/** + * Parses the SVG style="..." attribute and the equivalent presentation + * attributes (fill, stroke, ...). The two sources are merged with inline + * style winning, matching the SVG cascade rules. + */ +public final class StyleParser { + + private StyleParser() { } + + public static SVGStyle parse(Map presentationAttrs, String styleAttr) { + Map merged = new HashMap(); + if (presentationAttrs != null) { + for (Map.Entry e : presentationAttrs.entrySet()) { + merged.put(e.getKey(), e.getValue()); + } + } + if (styleAttr != null && !styleAttr.trim().isEmpty()) { + for (String decl : styleAttr.split(";")) { + int colon = decl.indexOf(':'); + if (colon <= 0) continue; + String k = decl.substring(0, colon).trim(); + String v = decl.substring(colon + 1).trim(); + if (!k.isEmpty()) merged.put(k, v); + } + } + + SVGStyle out = new SVGStyle(); + out.setFill(toPaint(merged.get("fill"))); + out.setStroke(toPaint(merged.get("stroke"))); + out.setFillOpacity(toFloat(merged.get("fill-opacity"))); + out.setStrokeOpacity(toFloat(merged.get("stroke-opacity"))); + out.setOpacity(toFloat(merged.get("opacity"))); + out.setStrokeWidth(toFloat(merged.get("stroke-width"))); + + String cap = merged.get("stroke-linecap"); + if (cap != null) { + cap = cap.trim().toLowerCase(); + if ("round".equals(cap)) out.setStrokeLineCap(SVGStyle.LINECAP_ROUND); + else if ("square".equals(cap)) out.setStrokeLineCap(SVGStyle.LINECAP_SQUARE); + else out.setStrokeLineCap(SVGStyle.LINECAP_BUTT); + } + String join = merged.get("stroke-linejoin"); + if (join != null) { + join = join.trim().toLowerCase(); + if ("round".equals(join)) out.setStrokeLineJoin(SVGStyle.LINEJOIN_ROUND); + else if ("bevel".equals(join)) out.setStrokeLineJoin(SVGStyle.LINEJOIN_BEVEL); + else out.setStrokeLineJoin(SVGStyle.LINEJOIN_MITER); + } + out.setStrokeMiterLimit(toFloat(merged.get("stroke-miterlimit"))); + String clipPath = merged.get("clip-path"); + if (clipPath != null) { + String ref = SVGPaint.stripUrl(clipPath); + if (ref != null) { + out.setClipPathRef(ref); + } + } + return out; + } + + private static SVGPaint toPaint(String value) { + if (value == null) return null; + String v = value.trim(); + if (v.isEmpty()) return null; + if (ColorParser.isNone(v)) return SVGPaint.NONE; + if (ColorParser.isCurrentColor(v)) return null; // treat as inherit; renderer defaults to black + SVGPaint ref = SVGPaint.setReference(v); + if (ref != null) return ref; + try { + return SVGPaint.ofColor(ColorParser.parse(v)); + } catch (RuntimeException e) { + return null; + } + } + + private static Float toFloat(String s) { + if (s == null) return null; + String t = s.trim(); + if (t.isEmpty()) return null; + try { + return NumberParser.parseFloat(t); + } catch (RuntimeException e) { + return null; + } + } +} diff --git a/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/TransformParser.java b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/TransformParser.java new file mode 100644 index 0000000000..400330542c --- /dev/null +++ b/maven/svg-transcoder/src/main/java/com/codename1/svg/transcoder/parser/TransformParser.java @@ -0,0 +1,79 @@ +package com.codename1.svg.transcoder.parser; + +/** + * Parses an SVG transform attribute: a sequence of translate / rotate / scale + * / skewX / skewY / matrix functions applied left-to-right. + */ +public final class TransformParser { + + private TransformParser() { } + + public static SVGTransform parse(String s) { + if (s == null) return null; + String t = s.trim(); + if (t.isEmpty()) return null; + + SVGTransform result = SVGTransform.identity(); + int i = 0; + int len = t.length(); + while (i < len) { + while (i < len && (t.charAt(i) == ' ' || t.charAt(i) == ',')) i++; + if (i >= len) break; + + int nameStart = i; + while (i < len && (Character.isLetter(t.charAt(i)))) i++; + String name = t.substring(nameStart, i).trim(); + while (i < len && t.charAt(i) != '(') i++; + if (i >= len) throw new IllegalArgumentException("Expected '(' after " + name); + i++; + int close = t.indexOf(')', i); + if (close < 0) throw new IllegalArgumentException("Unclosed transform " + name); + String inside = t.substring(i, close); + i = close + 1; + + float[] args = parseArgs(inside); + SVGTransform op = build(name, args); + result = result.multiply(op); + } + return result.isIdentity() ? null : result; + } + + private static float[] parseArgs(String s) { + NumberParser np = new NumberParser(s); + java.util.ArrayList list = new java.util.ArrayList(); + while (np.hasMore()) list.add(np.nextFloat()); + float[] r = new float[list.size()]; + for (int i = 0; i < r.length; i++) r[i] = list.get(i); + return r; + } + + private static SVGTransform build(String name, float[] args) { + if ("translate".equals(name)) { + float tx = args.length > 0 ? args[0] : 0; + float ty = args.length > 1 ? args[1] : 0; + return SVGTransform.translate(tx, ty); + } + if ("scale".equals(name)) { + float sx = args.length > 0 ? args[0] : 1; + float sy = args.length > 1 ? args[1] : sx; + return SVGTransform.scale(sx, sy); + } + if ("rotate".equals(name)) { + float ang = args.length > 0 ? args[0] : 0; + float cx = args.length > 1 ? args[1] : 0; + float cy = args.length > 2 ? args[2] : 0; + return SVGTransform.rotate(ang, cx, cy); + } + if ("skewX".equals(name)) { + return SVGTransform.skewX(args.length > 0 ? args[0] : 0); + } + if ("skewY".equals(name)) { + return SVGTransform.skewY(args.length > 0 ? args[0] : 0); + } + if ("matrix".equals(name)) { + if (args.length < 6) throw new IllegalArgumentException("matrix() needs 6 args"); + return new SVGTransform(args[0], args[1], args[2], args[3], args[4], args[5]); + } + throw new IllegalArgumentException("Unknown transform: " + name); + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/animation/SMILParserTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/animation/SMILParserTest.java new file mode 100644 index 0000000000..bb5a6676f2 --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/animation/SMILParserTest.java @@ -0,0 +1,61 @@ +package com.codename1.svg.transcoder.animation; + +import com.codename1.svg.transcoder.model.SVGAnimation; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class SMILParserTest { + + @Test + public void plainSeconds() { + assertEquals(1000L, SMILParser.parseClock("1s", -1L)); + assertEquals(500L, SMILParser.parseClock("0.5s", -1L)); + } + + @Test + public void milliseconds() { + assertEquals(250L, SMILParser.parseClock("250ms", -1L)); + } + + @Test + public void minutes() { + assertEquals(60000L, SMILParser.parseClock("1min", -1L)); + } + + @Test + public void hours() { + assertEquals(3600000L, SMILParser.parseClock("1h", -1L)); + } + + @Test + public void rawNumberIsSeconds() { + assertEquals(2000L, SMILParser.parseClock("2", -1L)); + } + + @Test + public void clockColonForm() { + // 1:30 = 1 minute 30 seconds = 90000 ms + assertEquals(90000L, SMILParser.parseClock("1:30", -1L)); + } + + @Test + public void indefiniteRepeats() { + assertEquals(SVGAnimation.REPEAT_INDEFINITE, SMILParser.parseRepeatCount("indefinite")); + } + + @Test + public void integerRepeats() { + assertEquals(3, SMILParser.parseRepeatCount("3")); + assertEquals(1, SMILParser.parseRepeatCount(null)); + assertEquals(1, SMILParser.parseRepeatCount("notanumber")); + } + + @Test + public void transformTypes() { + assertEquals(SVGAnimation.TransformType.ROTATE, SMILParser.parseTransformType("rotate")); + assertEquals(SVGAnimation.TransformType.SCALE, SMILParser.parseTransformType("scale")); + assertEquals(SVGAnimation.TransformType.TRANSLATE, SMILParser.parseTransformType("translate")); + assertEquals(SVGAnimation.TransformType.TRANSLATE, SMILParser.parseTransformType(null)); + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/codegen/CompileGeneratedSourceTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/codegen/CompileGeneratedSourceTest.java new file mode 100644 index 0000000000..2dd9ca1f31 --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/codegen/CompileGeneratedSourceTest.java @@ -0,0 +1,214 @@ +package com.codename1.svg.transcoder.codegen; + +import com.codename1.svg.transcoder.SVGTranscoder; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import javax.tools.JavaCompiler; +import javax.tools.JavaFileObject; +import javax.tools.SimpleJavaFileObject; +import javax.tools.StandardJavaFileManager; +import javax.tools.StandardLocation; +import javax.tools.ToolProvider; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.IOException; +import java.io.StringWriter; +import java.net.URI; +import java.util.Arrays; +import java.util.Collections; + +import static org.junit.Assert.*; + +/** + * Hands-on end-to-end test: transcode each fixture SVG, hand the resulting + * Java source to the in-process JDK compiler, and fail if the result doesn't + * compile against the real {@code com.codename1.ui.GeneratedSVGImage} + + * graphics API. This is the test that catches sloppy code emission in the + * generator, where a syntactic check would not be enough. + */ +public class CompileGeneratedSourceTest { + + @Rule + public TemporaryFolder tmp = new TemporaryFolder(); + + private JavaCompiler compiler; + + @Before + public void setUp() { + compiler = ToolProvider.getSystemJavaCompiler(); + org.junit.Assume.assumeNotNull("JDK compiler available", compiler); + } + + @Test + public void shapesCompile() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "" + + "" + + "" + + "", "Shapes"); + } + + @Test + public void pathCompiles() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "", "Pathy"); + } + + @Test + public void transformsCompile() throws Exception { + compileSvg("" + + "" + + "" + + "", "Transformed"); + } + + @Test + public void linearGradientCompiles() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "" + + "" + + "", "Gradient"); + } + + @Test + public void multiStopGradientCompiles() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "", "MultiStopGradient"); + } + + @Test + public void deeplyNestedGroupsCompile() throws Exception { + // Five-deep nesting with transforms at each level; each transform + // block introduces fresh local vars so Java's no-shadowing rule + // doesn't trip the compile. + compileSvg("" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "", "Nested"); + } + + @Test + public void skewTransformsCompile() throws Exception { + compileSvg("" + + "" + + "" + + "", "Skewed"); + } + + @Test + public void valuesAnimationCompiles() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "", "ValuesAnim"); + } + + @Test + public void clipPathCompiles() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "" + + "", "Clipped"); + } + + @Test + public void textCompiles() throws Exception { + compileSvg("" + + "Hello" + + "Logo" + + "v1.0" + + "", "Texty"); + } + + @Test + public void animationCompiles() throws Exception { + compileSvg("" + + "" + + "" + + "" + + "" + + "" + + "" + + "", "Animated"); + } + + @Test + public void registryCompiles() throws Exception { + StringWriter sw = new StringWriter(); + SVGTranscoder.writeRegistry("com.test.gen", "SVGRegistry", + Arrays.asList( + new SVGTranscoder.GeneratedClass("com.test.gen", "FooSvg", "foo.svg"), + new SVGTranscoder.GeneratedClass("com.test.gen", "BarSvg", "bar.svg") + ), sw); + // We can't compile the registry without the actual generated classes, so + // just sanity-check the source contents. + String src = sw.toString(); + assertTrue(src.contains("package com.test.gen;")); + assertTrue(src.contains("public static void installGlobal()")); + assertTrue(src.contains("new com.test.gen.FooSvg()")); + assertTrue(src.contains("Resources.registerGeneratedImage(\"foo.svg\"")); + } + + private void compileSvg(String svg, String className) throws Exception { + StringWriter sw = new StringWriter(); + SVGTranscoder.transcode(new ByteArrayInputStream(svg.getBytes("UTF-8")), + "gen", className, sw); + String source = sw.toString(); + File outDir = tmp.newFolder("classes"); + + StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); + try { + fileManager.setLocation(StandardLocation.CLASS_OUTPUT, Collections.singleton(outDir)); + JavaFileObject src = new InMemorySource("gen." + className, source); + JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, + Arrays.asList("-Xlint:none", "-proc:none"), null, Collections.singleton(src)); + boolean ok = task.call(); + if (!ok) { + fail("Generated source failed to compile:\n" + source); + } + } finally { + fileManager.close(); + } + } + + private static final class InMemorySource extends SimpleJavaFileObject { + private final String content; + InMemorySource(String fqn, String content) { + super(URI.create("mem:///" + fqn.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE); + this.content = content; + } + @Override + public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException { + return content; + } + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/codegen/JavaCodeGeneratorTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/codegen/JavaCodeGeneratorTest.java new file mode 100644 index 0000000000..1b53a28cea --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/codegen/JavaCodeGeneratorTest.java @@ -0,0 +1,170 @@ +package com.codename1.svg.transcoder.codegen; + +import com.codename1.svg.transcoder.SVGTranscoder; +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.StringWriter; + +import static org.junit.Assert.*; + +public class JavaCodeGeneratorTest { + + private static String transcode(String svg) throws Exception { + StringWriter sw = new StringWriter(); + SVGTranscoder.transcode(new ByteArrayInputStream(svg.getBytes("UTF-8")), + "com.example", "TestIcon", sw); + return sw.toString(); + } + + @Test + public void classBoilerplateEmitted() throws Exception { + String out = transcode(""); + assertTrue(out.contains("package com.example;")); + assertTrue(out.contains("public final class TestIcon extends GeneratedSVGImage")); + assertTrue(out.contains("import com.codename1.ui.GeneratedSVGImage;")); + assertTrue(out.contains("import com.codename1.ui.geom.GeneralPath;")); + assertTrue(out.contains("protected void paintSVG(Graphics g, long __t)")); + } + + @Test + public void rectGeneratesPath() throws Exception { + String out = transcode("" + + ""); + assertTrue(out.contains("new GeneralPath()")); + assertTrue(out.contains("moveTo")); + assertTrue(out.contains("lineTo")); + assertTrue(out.contains("closePath")); + assertTrue(out.contains("g.fillShape(__p)")); + // fill="red" -> 0xFF0000 + assertTrue(out.contains("g.setColor(0xFF0000)")); + } + + @Test + public void circleUsesArc() throws Exception { + String out = transcode("" + + ""); + assertTrue(out.contains("__p.arc(")); + assertTrue(out.contains("g.setColor(0x")); + } + + @Test + public void strokeEmitsStroke() throws Exception { + String out = transcode("" + + ""); + assertTrue(out.contains("g.drawShape(__p, __s)")); + assertTrue(out.contains("new Stroke(")); + } + + @Test + public void animationIsReportedAtConstruction() throws Exception { + String out = transcode("" + + "" + + "" + + ""); + assertTrue("animated flag should be true", + out.contains("super(10, 10, 0.0f, 0.0f, 10.0f, 10.0f, true);")); + // r animation should reach into runtime helper + assertTrue(out.contains("GeneratedSVGImage.progress(__t,")); + assertTrue(out.contains("GeneratedSVGImage.lerp(3.0f, 5.0f")); + } + + @Test + public void groupTransformEmitsConcatenate() throws Exception { + String out = transcode("" + + "" + + ""); + // Each transform block declares a unique pair of locals (__tsaveN / __tnewN) + // so sibling transforms compile without local-variable shadowing. + assertTrue("expected makeAffine call", + out.contains(".concatenate(Transform.makeAffine(")); + assertTrue("expected setTransform on the fresh transform", + out.matches("(?s).*g\\.setTransform\\(__tnew\\d+\\);.*")); + assertTrue("expected setTransform on the saved transform in finally", + out.matches("(?s).*g\\.setTransform\\(__tsave\\d+\\);.*")); + } + + @Test + public void siblingTransformedRectsUseFreshVariableNames() throws Exception { + // Regression: a group with multiple transformed siblings used to + // emit two `Transform __new = ...` declarations in the same scope, + // which doesn't compile under Java's no-shadowing rule for locals. + String out = transcode("" + + "" + + "" + + "" + + ""); + java.util.regex.Matcher m = java.util.regex.Pattern.compile("__tnew(\\d+)").matcher(out); + java.util.Set ids = new java.util.HashSet(); + while (m.find()) ids.add(m.group(1)); + assertTrue("expected multiple distinct transform-block IDs but found " + ids, ids.size() >= 3); + } + + @Test + public void pathArcCallsRuntimeHelper() throws Exception { + String out = transcode("" + + ""); + assertTrue(out.contains("GeneratedSVGImage.svgArc(__p")); + } + + @Test + public void linearGradientEmitsPaint() throws Exception { + String out = transcode("" + + "" + + "" + + "" + + "" + + ""); + // Gradient fills use the setClip(path) + LinearGradientPaint.paint + // recipe. iOS Metal currently misrenders these (substitutes a + // degenerate polygon clip) -- see SVG-Transcoder.asciidoc; the + // Metal port bug is being tracked separately and the screenshot + // goldens capture the platform-current behavior. + assertTrue(out.contains("new LinearGradientPaint(")); + assertTrue(out.contains("CycleMethod.NO_CYCLE")); + } + + @Test + public void generatedClassHasAllThreeConstructors() throws Exception { + // The codegen must emit the no-arg, source-density, and mm-dimensions + // constructors so SVGRegistry can pick the right one based on whether + // the CSS rule declared cn1-source-dpi / cn1-svg-width / nothing. + String out = transcode("" + + ""); + assertTrue("no-arg constructor required for code-driven instantiation", + out.contains("public TestIcon() {")); + assertTrue("sourceDensity constructor required for cn1-source-dpi hints", + out.contains("public TestIcon(int sourceDensity) {")); + assertTrue("millimeter constructor required for cn1-svg-width/height hints", + out.contains("public TestIcon(float widthMm, float heightMm) {")); + assertTrue("mm constructor must convert through GeneratedSVGImage.mmToPixels", + out.contains("GeneratedSVGImage.mmToPixels(widthMm)")); + } + + @Test + public void registryHonorsMillimeterDimensions() throws Exception { + java.io.StringWriter sw = new java.io.StringWriter(); + SVGTranscoder.writeRegistry("gen", "SVGRegistry", + java.util.Arrays.asList( + new SVGTranscoder.GeneratedClass("gen", "MmIcon", "icon.svg", 0, 6f, 6f), + new SVGTranscoder.GeneratedClass("gen", "DpiIcon", "dpi.svg", 50), + new SVGTranscoder.GeneratedClass("gen", "PlainIcon", "plain.svg") + ), sw); + String src = sw.toString(); + // mm > density > default precedence: + assertTrue("expected mm constructor for cn1-svg-width hint: " + src, + src.contains("new gen.MmIcon(6.0f, 6.0f)")); + assertTrue("expected sourceDensity constructor for cn1-source-dpi hint", + src.contains("new gen.DpiIcon(50)")); + assertTrue("expected no-arg constructor when no CSS hint was given", + src.contains("new gen.PlainIcon()")); + } + + @Test + public void classNameFor() { + assertEquals("HomeIcon", SVGTranscoder.classNameFor("home-icon.svg")); + assertEquals("Foo", SVGTranscoder.classNameFor("foo")); + assertEquals("_1Item", SVGTranscoder.classNameFor("1item.svg")); + assertEquals("MyWeirdName", SVGTranscoder.classNameFor("my.weird name.svg")); + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/ColorParserTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/ColorParserTest.java new file mode 100644 index 0000000000..d61c92b3a6 --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/ColorParserTest.java @@ -0,0 +1,76 @@ +package com.codename1.svg.transcoder.parser; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class ColorParserTest { + + @Test + public void hex3() { + assertEquals(0xFFAABBCC, ColorParser.parse("#abc")); + } + + @Test + public void hex6() { + assertEquals(0xFF112233, ColorParser.parse("#112233")); + } + + @Test + public void hex8WithAlpha() { + // SVG-style #RRGGBBAA -- alpha is last + int v = ColorParser.parse("#11223380"); + assertEquals(0x80, (v >>> 24) & 0xFF); + assertEquals(0x11, (v >>> 16) & 0xFF); + } + + @Test + public void namedColor() { + assertEquals(0xFFFF0000, ColorParser.parse("red")); + assertEquals(0xFF000000, ColorParser.parse("black")); + assertEquals(0xFFFFFFFF, ColorParser.parse("WHITE")); + } + + @Test + public void rgbFunction() { + assertEquals(0xFF80A0C0, ColorParser.parse("rgb(128,160,192)")); + } + + @Test + public void rgbaFunction() { + int v = ColorParser.parse("rgba(255,128,0,0.5)"); + // alpha is round(0.5 * 255) == 128 + assertEquals(128, (v >>> 24) & 0xFF); + assertEquals(255, (v >>> 16) & 0xFF); + } + + @Test + public void rgbWithPercent() { + int v = ColorParser.parse("rgb(100%,0%,0%)"); + assertEquals(0xFF, (v >>> 16) & 0xFF); + assertEquals(0x00, (v >>> 8) & 0xFF); + } + + @Test + public void noneRecognized() { + assertTrue(ColorParser.isNone("none")); + assertTrue(ColorParser.isNone(" NONE ")); + assertFalse(ColorParser.isNone("red")); + } + + @Test + public void currentColorRecognized() { + assertTrue(ColorParser.isCurrentColor("currentColor")); + assertFalse(ColorParser.isCurrentColor("red")); + } + + @Test(expected = IllegalArgumentException.class) + public void unknownColorThrows() { + ColorParser.parse("definitely-not-a-color"); + } + + @Test + public void parseOrDefaultReturnsFallback() { + assertEquals(0xDEADBEEF, ColorParser.parseOrDefault("nope", 0xDEADBEEF)); + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/PathDataParserTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/PathDataParserTest.java new file mode 100644 index 0000000000..dc724a7bfd --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/PathDataParserTest.java @@ -0,0 +1,143 @@ +package com.codename1.svg.transcoder.parser; + +import org.junit.Test; + +import java.util.List; + +import static org.junit.Assert.*; + +public class PathDataParserTest { + + @Test + public void emptyReturnsEmpty() { + assertTrue(PathDataParser.parse("").isEmpty()); + assertTrue(PathDataParser.parse(null).isEmpty()); + } + + @Test + public void moveAndLine() { + List cmds = PathDataParser.parse("M 10 20 L 30 40"); + assertEquals(2, cmds.size()); + assertEquals(PathCommand.Type.MOVE, cmds.get(0).getType()); + assertArrayEquals(new float[]{10f, 20f}, cmds.get(0).getArgs(), 0f); + assertEquals(PathCommand.Type.LINE, cmds.get(1).getType()); + assertArrayEquals(new float[]{30f, 40f}, cmds.get(1).getArgs(), 0f); + } + + @Test + public void relativeMoveBecomesAbsolute() { + List cmds = PathDataParser.parse("M 10 10 m 5 5"); + // M absolute then m relative produces second MOVE at (15, 15) + assertEquals(2, cmds.size()); + assertArrayEquals(new float[]{15f, 15f}, cmds.get(1).getArgs(), 0f); + } + + @Test + public void implicitLineAfterMove() { + List cmds = PathDataParser.parse("M 0 0 10 10 20 20"); + // After M, subsequent coordinate pairs are implicit L + assertEquals(3, cmds.size()); + assertEquals(PathCommand.Type.MOVE, cmds.get(0).getType()); + assertEquals(PathCommand.Type.LINE, cmds.get(1).getType()); + assertEquals(PathCommand.Type.LINE, cmds.get(2).getType()); + } + + @Test + public void horizontalVerticalLines() { + List cmds = PathDataParser.parse("M 0 0 H 50 V 60 h 10 v 10"); + assertEquals(5, cmds.size()); + // H 50 -> LINE (50, 0) + assertArrayEquals(new float[]{50f, 0f}, cmds.get(1).getArgs(), 0f); + // V 60 -> LINE (50, 60) + assertArrayEquals(new float[]{50f, 60f}, cmds.get(2).getArgs(), 0f); + // h 10 -> LINE (60, 60) + assertArrayEquals(new float[]{60f, 60f}, cmds.get(3).getArgs(), 0f); + // v 10 -> LINE (60, 70) + assertArrayEquals(new float[]{60f, 70f}, cmds.get(4).getArgs(), 0f); + } + + @Test + public void cubicBezier() { + List cmds = PathDataParser.parse("M 0 0 C 1 2 3 4 5 6"); + assertEquals(2, cmds.size()); + assertEquals(PathCommand.Type.CUBIC, cmds.get(1).getType()); + assertArrayEquals(new float[]{1, 2, 3, 4, 5, 6}, cmds.get(1).getArgs(), 0f); + } + + @Test + public void smoothCubicReflectsControlPoint() { + // After C 1,1 3,3 5,5 the implicit S control = 2*(5,5) - (3,3) = (7, 7) + List cmds = PathDataParser.parse("M 0 0 C 1 1 3 3 5 5 S 8 8 10 10"); + assertEquals(3, cmds.size()); + PathCommand smooth = cmds.get(2); + assertEquals(PathCommand.Type.CUBIC, smooth.getType()); + assertEquals(7f, smooth.getArgs()[0], 1e-6f); + assertEquals(7f, smooth.getArgs()[1], 1e-6f); + } + + @Test + public void closePath() { + List cmds = PathDataParser.parse("M 0 0 L 10 0 L 10 10 Z"); + assertEquals(4, cmds.size()); + assertEquals(PathCommand.Type.CLOSE, cmds.get(3).getType()); + } + + @Test + public void arcCommand() { + List cmds = PathDataParser.parse("M 0 0 A 5 5 0 0 1 10 0"); + assertEquals(2, cmds.size()); + assertEquals(PathCommand.Type.ARC, cmds.get(1).getType()); + float[] a = cmds.get(1).getArgs(); + // expected: curX, curY, rx, ry, xRot, largeArc, sweep, x, y + assertEquals(0f, a[0], 0f); + assertEquals(0f, a[1], 0f); + assertEquals(5f, a[2], 0f); + assertEquals(5f, a[3], 0f); + assertEquals(0f, a[5], 0f); + assertEquals(1f, a[6], 0f); + assertEquals(10f, a[7], 0f); + } + + @Test + public void smoothQuadraticReflectsControlPoint() { + // After Q 1,1 5,5 the implicit T control = 2*(5,5) - (1,1) = (9, 9) + List cmds = PathDataParser.parse("M 0 0 Q 1 1 5 5 T 10 10"); + assertEquals(3, cmds.size()); + PathCommand smooth = cmds.get(2); + assertEquals(PathCommand.Type.QUAD, smooth.getType()); + assertEquals(9f, smooth.getArgs()[0], 1e-6f); + assertEquals(9f, smooth.getArgs()[1], 1e-6f); + } + + @Test + public void smoothCurveFallsBackToCurrentPoint() { + // S immediately after M (no prior cubic) uses current point as + // the implicit first control. The control should equal the current + // point (0, 0) after the M. + List cmds = PathDataParser.parse("M 0 0 S 5 5 10 10"); + assertEquals(2, cmds.size()); + PathCommand smooth = cmds.get(1); + assertEquals(PathCommand.Type.CUBIC, smooth.getType()); + assertEquals(0f, smooth.getArgs()[0], 0f); + assertEquals(0f, smooth.getArgs()[1], 0f); + } + + @Test + public void closeFollowedByImplicitMoveRebasesStart() { + // After Z the current point returns to the subpath start. A + // subsequent relative M (m) is relative to that subpath start. + List cmds = PathDataParser.parse("M 10 10 L 20 20 Z m 5 5"); + assertEquals(4, cmds.size()); + // The m moves to (10+5, 10+5) = (15, 15) + assertEquals(PathCommand.Type.MOVE, cmds.get(3).getType()); + assertArrayEquals(new float[]{15f, 15f}, cmds.get(3).getArgs(), 0f); + } + + @Test + public void implicitSignSeparator() { + // "10-20" should parse as two numbers 10 and -20 + List cmds = PathDataParser.parse("M0 0L10-20"); + assertEquals(2, cmds.size()); + assertArrayEquals(new float[]{10f, -20f}, cmds.get(1).getArgs(), 0f); + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/SVGParserTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/SVGParserTest.java new file mode 100644 index 0000000000..7612535a7b --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/SVGParserTest.java @@ -0,0 +1,136 @@ +package com.codename1.svg.transcoder.parser; + +import com.codename1.svg.transcoder.model.*; +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.List; + +import static org.junit.Assert.*; + +public class SVGParserTest { + + private static SVGDocument parse(String svg) throws IOException { + return new SVGParser().parse(new ByteArrayInputStream(svg.getBytes("UTF-8"))); + } + + @Test + public void viewBoxParsed() throws Exception { + SVGDocument d = parse(""); + assertEquals(100f, d.getWidth(), 0f); + assertEquals(200f, d.getHeight(), 0f); + assertEquals(100f, d.getViewBoxWidth(), 0f); + assertEquals(200f, d.getViewBoxHeight(), 0f); + } + + @Test + public void rectShape() throws Exception { + SVGDocument d = parse("" + + ""); + assertEquals(1, d.getChildren().size()); + SVGRect r = (SVGRect) d.getChildren().get(0); + assertEquals(1f, r.getX(), 0f); + assertEquals(3f, r.getWidth(), 0f); + assertEquals(0xFFFF0000, r.getStyle().getFill().getColor()); + } + + @Test + public void groupAndCircle() throws Exception { + SVGDocument d = parse("" + + "" + + "" + + ""); + assertEquals(1, d.getChildren().size()); + SVGGroup g = (SVGGroup) d.getChildren().get(0); + assertNotNull(g.getTransform()); + assertEquals(5f, g.getTransform().e, 0f); + SVGCircle c = (SVGCircle) g.getChildren().get(0); + assertEquals(2f, c.getR(), 0f); + assertEquals(0xFF00FF00, c.getStyle().getFill().getColor()); + } + + @Test + public void linearGradientStored() throws Exception { + SVGDocument d = parse("" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""); + SVGLinearGradient lg = (SVGLinearGradient) d.getDefinitions().get("g1"); + assertNotNull(lg); + assertEquals(2, lg.getStops().size()); + assertEquals(0xFF000000, lg.getStops().get(0).getColor()); + assertEquals(0xFFFFFFFF, lg.getStops().get(1).getColor()); + + SVGRect r = (SVGRect) d.getChildren().get(0); + assertTrue(r.getStyle().getFill().isReference()); + assertEquals("g1", r.getStyle().getFill().getReference()); + } + + @Test + public void pathParsed() throws Exception { + SVGDocument d = parse("" + + ""); + SVGPath p = (SVGPath) d.getChildren().get(0); + assertEquals(4, p.getCommands().size()); + } + + @Test + public void smilAnimationParsed() throws Exception { + SVGDocument d = parse("" + + "" + + "" + + ""); + SVGCircle c = (SVGCircle) d.getChildren().get(0); + List anims = c.getAnimations(); + assertEquals(1, anims.size()); + SVGAnimation a = anims.get(0); + assertEquals("r", a.getAttributeName()); + assertEquals("2", a.getFrom()); + assertEquals("5", a.getTo()); + assertEquals(1000L, a.getDurMs()); + assertEquals(SVGAnimation.REPEAT_INDEFINITE, a.getRepeatCount()); + } + + @Test + public void textElementParsed() throws Exception { + SVGDocument d = parse("" + + "Hi world" + + ""); + assertEquals(1, d.getChildren().size()); + SVGText t = (SVGText) d.getChildren().get(0); + assertEquals(10f, t.getX(), 0f); + assertEquals(40f, t.getY(), 0f); + assertEquals(24f, t.getFontSize(), 0f); + assertEquals(SVGText.Anchor.MIDDLE, t.getAnchor()); + assertTrue("font-weight=bold should set bold", t.isBold()); + assertEquals("Arial", t.getFontFamily()); + assertEquals("tspan content is flattened into parent text", "Hi world", t.getContent()); + assertEquals(0xFF0000FF, t.getStyle().getFill().getColor()); + } + + @Test + public void textWithNumericFontWeight() throws Exception { + SVGDocument d = parse("" + + "x"); + SVGText t = (SVGText) d.getChildren().get(0); + assertTrue("font-weight=700 is bold", t.isBold()); + } + + @Test + public void styleAttributeParsed() throws Exception { + SVGDocument d = parse("" + + ""); + SVGRect r = (SVGRect) d.getChildren().get(0); + assertEquals(0xFFABCDEF, r.getStyle().getFill().getColor()); + assertTrue(r.getStyle().getStroke().isNone()); + assertEquals(0.5f, r.getStyle().getOpacity(), 1e-5f); + } +} diff --git a/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/TransformParserTest.java b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/TransformParserTest.java new file mode 100644 index 0000000000..7951b61225 --- /dev/null +++ b/maven/svg-transcoder/src/test/java/com/codename1/svg/transcoder/parser/TransformParserTest.java @@ -0,0 +1,73 @@ +package com.codename1.svg.transcoder.parser; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class TransformParserTest { + + @Test + public void emptyOrNull() { + assertNull(TransformParser.parse(null)); + assertNull(TransformParser.parse("")); + assertNull(TransformParser.parse(" ")); + } + + @Test + public void singleTranslate() { + SVGTransform t = TransformParser.parse("translate(10, 20)"); + assertNotNull(t); + assertEquals(10f, t.e, 0f); + assertEquals(20f, t.f, 0f); + assertEquals(1f, t.a, 0f); + assertEquals(1f, t.d, 0f); + } + + @Test + public void singleScale() { + SVGTransform t = TransformParser.parse("scale(2, 3)"); + assertNotNull(t); + assertEquals(2f, t.a, 0f); + assertEquals(3f, t.d, 0f); + } + + @Test + public void scaleUniform() { + SVGTransform t = TransformParser.parse("scale(2)"); + assertEquals(2f, t.a, 0f); + assertEquals(2f, t.d, 0f); + } + + @Test + public void rotateAt90Degrees() { + SVGTransform t = TransformParser.parse("rotate(90)"); + // cos(90) ~ 0, sin(90) = 1 + assertEquals(0f, t.a, 1e-5f); + assertEquals(1f, t.b, 1e-5f); + assertEquals(-1f, t.c, 1e-5f); + assertEquals(0f, t.d, 1e-5f); + } + + @Test + public void translateThenScaleAccumulates() { + SVGTransform t = TransformParser.parse("translate(5, 5) scale(2)"); + // translate then scale: T = translate * scale + // For a point P at (1,1): scale -> (2,2), then translate -> (7,7) + // Matrix form: a=2 b=0 c=0 d=2 e=5 f=5 + assertEquals(2f, t.a, 0f); + assertEquals(2f, t.d, 0f); + assertEquals(5f, t.e, 0f); + assertEquals(5f, t.f, 0f); + } + + @Test + public void matrixFunction() { + SVGTransform t = TransformParser.parse("matrix(1 2 3 4 5 6)"); + assertEquals(1f, t.a, 0f); + assertEquals(2f, t.b, 0f); + assertEquals(3f, t.c, 0f); + assertEquals(4f, t.d, 0f); + assertEquals(5f, t.e, 0f); + assertEquals(6f, t.f, 0f); + } +} diff --git a/scripts/android/screenshots/SVGAnimatedScreenshotTest.png b/scripts/android/screenshots/SVGAnimatedScreenshotTest.png new file mode 100644 index 0000000000..97d08c8d25 Binary files /dev/null and b/scripts/android/screenshots/SVGAnimatedScreenshotTest.png differ diff --git a/scripts/android/screenshots/SVGStatic.png b/scripts/android/screenshots/SVGStatic.png new file mode 100644 index 0000000000..ad49a2366c Binary files /dev/null and b/scripts/android/screenshots/SVGStatic.png differ diff --git a/scripts/hellocodenameone/common/pom.xml b/scripts/hellocodenameone/common/pom.xml index 142ce7943d..9067bc1352 100644 --- a/scripts/hellocodenameone/common/pom.xml +++ b/scripts/hellocodenameone/common/pom.xml @@ -339,6 +339,13 @@ codenameone-maven-plugin + + transcode-svg + generate-sources + + transcode-svg + + generate-gui-sources process-sources diff --git a/scripts/hellocodenameone/common/src/main/css/clipped_badge.svg b/scripts/hellocodenameone/common/src/main/css/clipped_badge.svg new file mode 100644 index 0000000000..681e39f480 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/clipped_badge.svg @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + PRO + diff --git a/scripts/hellocodenameone/common/src/main/css/color_morph.svg b/scripts/hellocodenameone/common/src/main/css/color_morph.svg new file mode 100644 index 0000000000..0a21939546 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/color_morph.svg @@ -0,0 +1,18 @@ + + + + + + + + + + + diff --git a/scripts/hellocodenameone/common/src/main/css/gradient_circle.svg b/scripts/hellocodenameone/common/src/main/css/gradient_circle.svg new file mode 100644 index 0000000000..4a27db2365 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/gradient_circle.svg @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/scripts/hellocodenameone/common/src/main/css/logo_text.svg b/scripts/hellocodenameone/common/src/main/css/logo_text.svg new file mode 100644 index 0000000000..d0cbcb5e94 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/logo_text.svg @@ -0,0 +1,9 @@ + + + + Codename One + build-time SVG + diff --git a/scripts/hellocodenameone/common/src/main/css/path_arrow.svg b/scripts/hellocodenameone/common/src/main/css/path_arrow.svg new file mode 100644 index 0000000000..073232b2ea --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/path_arrow.svg @@ -0,0 +1,6 @@ + + + + diff --git a/scripts/hellocodenameone/common/src/main/css/pulsing_circle.svg b/scripts/hellocodenameone/common/src/main/css/pulsing_circle.svg new file mode 100644 index 0000000000..9b11b9d6e5 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/pulsing_circle.svg @@ -0,0 +1,9 @@ + + + + + + + diff --git a/scripts/hellocodenameone/common/src/main/css/spinner_animated.svg b/scripts/hellocodenameone/common/src/main/css/spinner_animated.svg new file mode 100644 index 0000000000..4bf8d1941e --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/spinner_animated.svg @@ -0,0 +1,14 @@ + + + + + + + + + + diff --git a/scripts/hellocodenameone/common/src/main/css/star.svg b/scripts/hellocodenameone/common/src/main/css/star.svg new file mode 100644 index 0000000000..9dd76cee9c --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/star.svg @@ -0,0 +1,5 @@ + + + + diff --git a/scripts/hellocodenameone/common/src/main/css/theme.css b/scripts/hellocodenameone/common/src/main/css/theme.css index 5fb64c852f..5e6fc687ca 100644 --- a/scripts/hellocodenameone/common/src/main/css/theme.css +++ b/scripts/hellocodenameone/common/src/main/css/theme.css @@ -209,3 +209,86 @@ CssFilterChain { background: linear-gradient(45deg, #ff0080, #40e0d0); filter: brightness(1.2) contrast(0.9) saturate(1.3); } + +/* Build-time SVG transcoder: each SVG referenced via url() is picked up by + * codenameone-maven-plugin:transcode-svg, transcoded to a GeneratedSVGImage + * subclass, and registered with the theme under its source filename. The + * cn1-source-dpi hint here is the same one multi-images use: it tells the + * transcoder which CN1 density bucket the SVG was authored for so the + * runtime size scales to the device. */ +SVGStarStyle { + background: url(star.svg); + cn1-source-dpi: very-high; + bg-type: image_scaled_fit; + padding: 4mm; +} + +SVGGradientCircleStyle { + background: url(gradient_circle.svg); + cn1-source-dpi: very-high; + bg-type: image_scaled_fit; + padding: 4mm; +} + +SVGPathArrowStyle { + background: url(path_arrow.svg); + cn1-source-dpi: very-high; + bg-type: image_scaled_fit; + padding: 4mm; +} + +SVGSpinnerStyle { + background: url(spinner_animated.svg); + /* Explicit millimeter dimensions carry across DPIs the same way + * font-size: 3mm does -- 12mm by 12mm on every device, regardless + * of the SVG's declared or device density. */ + cn1-svg-width: 12mm; + cn1-svg-height: 12mm; + bg-type: image_scaled_fit; + padding: 4mm; +} + +SVGPulsingCircleStyle { + background: url(pulsing_circle.svg); + cn1-svg-width: 12mm; + cn1-svg-height: 12mm; + bg-type: image_scaled_fit; + padding: 4mm; +} + +/* Exercises rendering with fill colors, anchor, font-weight, + * font-style + a rounded-rect frame underneath. */ +SVGLogoTextStyle { + background: url(logo_text.svg); + cn1-svg-width: 30mm; + cn1-svg-height: 12mm; + bg-type: image_scaled_fit; + padding: 2mm; +} + +/* Exercises complex path commands -- S/T smooth curves, dashed strokes. */ +SVGWavePathStyle { + background: url(wave_path.svg); + cn1-svg-width: 30mm; + cn1-svg-height: 8mm; + bg-type: image_scaled_fit; + padding: 2mm; +} + +/* Multiple parallel animations on one element -- rotate + rx/ry. */ +SVGColorMorphStyle { + background: url(color_morph.svg); + cn1-svg-width: 18mm; + cn1-svg-height: 18mm; + bg-type: image_scaled_fit; + padding: 2mm; +} + +/* Exercises + gradient fill + clipped text. */ +SVGClippedBadgeStyle { + background: url(clipped_badge.svg); + cn1-svg-width: 16mm; + cn1-svg-height: 16mm; + bg-type: image_scaled_fit; + padding: 2mm; +} diff --git a/scripts/hellocodenameone/common/src/main/css/wave_path.svg b/scripts/hellocodenameone/common/src/main/css/wave_path.svg new file mode 100644 index 0000000000..17f4947ce5 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/css/wave_path.svg @@ -0,0 +1,9 @@ + + + + + diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java index 19f1201f14..49f0d34928 100644 --- a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java +++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java @@ -204,6 +204,11 @@ private static int testTimeoutMs() { new PaletteOverrideThemeScreenshotTest(), new CssGradientsScreenshotTest(), new CssFilterBlurScreenshotTest(), + // Build-time SVG transcoder coverage: the static test renders + // shapes / gradients / paths, the animated test pins + // AnimationTime so the captured frame is deterministic. + new SVGStaticScreenshotTest(), + new SVGAnimatedScreenshotTest(), // Keep this as the last screenshot test; orientation changes can leak into subsequent screenshots. new OrientationLockScreenshotTest(), new InPlaceEditViewTest(), @@ -364,6 +369,11 @@ private static boolean isJsSkippedScreenshotTest(String testName) { // reliably. The validation stays on iOS/Android so dropped chunks // still surface as failures there. return "KotlinUiTest".equals(testName) + // The SVG screenshot tests need iOS/Android/JavaSE coverage but + // overflow the JS port's ~150s browser-lifetime budget when added + // on top of the current suite; revisit when that budget is bumped. + || "SVGStaticScreenshotTest".equals(testName) + || "SVGAnimatedScreenshotTest".equals(testName) || "MainScreenScreenshotTest".equals(testName) || "SheetScreenshotTest".equals(testName) || "StatusBarTapDiagnosticScreenshotTest".equals(testName) diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/SVGAnimatedScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/SVGAnimatedScreenshotTest.java new file mode 100644 index 0000000000..ff53b86f44 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/SVGAnimatedScreenshotTest.java @@ -0,0 +1,87 @@ +package com.codenameone.examples.hellocodenameone.tests; + +import com.codename1.ui.Display; +import com.codename1.ui.Graphics; +import com.codename1.ui.Image; +import com.codename1.ui.util.Resources; + +/// Animated SVG end-to-end test. Like {@link SVGStaticScreenshotTest} this +/// uses only the developer-facing APIs: +/// +/// 1. SVGs land in `src/main/css/` and are referenced from `theme.css` -- +/// no Java-side hardcoding. +/// 2. The per-port wiring (`JavaSEPort.init`, `IPhoneBuilder` and +/// `AndroidGradleBuilder` injecting the call into their generated Stub) +/// runs `SVGRegistry.installGlobal()` automatically so the theme's +/// placeholder entries are replaced with the transcoded SVGs before +/// this test runs. +/// 3. {@link Resources#getImage(String)} returns the animated SVG, which is +/// painted into each cell of the standard +/// {@link AbstractAnimationScreenshotTest} grid. Because both SVGs read +/// from {@code AnimationTime.now()}, the base class's per-frame clock +/// pinning produces a deterministic capture. +public class SVGAnimatedScreenshotTest extends AbstractAnimationScreenshotTest { + + private static final int ANIM_DURATION_MS = 1000; + + private Image spinner; + private Image pulse; + private Image colorMorph; + + @Override + public boolean shouldTakeScreenshot() { + // The JS port hangs on the chunk-emission path for this test under + // the suite's 150s browser-lifetime budget. Skip explicitly here + // because the runner's shouldForceTimeoutInHtml5 path is not + // reliable on JS. See SVGStaticScreenshotTest for the same skip. + return !"HTML5".equals(Display.getInstance().getPlatformName()); + } + + @Override + public boolean runTest() throws Exception { + if ("HTML5".equals(Display.getInstance().getPlatformName())) { + done(); + return true; + } + return super.runTest(); + } + + @Override + protected int getAnimationDurationMillis() { + return ANIM_DURATION_MS; + } + + @Override + protected void prepareCapture(int frameWidth, int frameHeight) { + super.prepareCapture(frameWidth, frameHeight); + Resources res = SVGStaticScreenshotTest.resolveGlobalResources(); + spinner = res == null ? null : res.getImage("spinner_animated.svg"); + pulse = res == null ? null : res.getImage("pulsing_circle.svg"); + colorMorph = res == null ? null : res.getImage("color_morph.svg"); + } + + @Override + protected void renderFrame(Graphics g, int width, int height, + double progress, int frameIndex) { + g.setColor(0xFFFFFF); + g.fillRect(0, 0, width, height); + + if (spinner == null || pulse == null || colorMorph == null) { + g.setColor(0xFF0000); + g.drawString("SVGRegistry not installed", 10, 20); + return; + } + + // Three animated SVGs in a row so the grid covers + // animateTransform (spinner), on a numeric attribute + // (pulse radius / opacity), and combined animateTransform + + // multi-attribute on the same element (colorMorph). + int third = width / 3; + Image scaledSpinner = spinner.scaled(third, height); + Image scaledPulse = pulse.scaled(third, height); + Image scaledMorph = colorMorph.scaled(width - 2 * third, height); + g.drawImage(scaledSpinner, 0, 0); + g.drawImage(scaledPulse, third, 0); + g.drawImage(scaledMorph, 2 * third, 0); + } +} diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/SVGStaticScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/SVGStaticScreenshotTest.java new file mode 100644 index 0000000000..3c97322cf0 --- /dev/null +++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/SVGStaticScreenshotTest.java @@ -0,0 +1,129 @@ +package com.codenameone.examples.hellocodenameone.tests; + +import com.codename1.io.Log; +import com.codename1.ui.Display; +import com.codename1.ui.Form; +import com.codename1.ui.Image; +import com.codename1.ui.Label; +import com.codename1.ui.layouts.GridLayout; +import com.codename1.ui.plaf.Style; +import com.codename1.ui.util.Resources; + +import java.io.InputStream; + +/** + * End-to-end test for the build-time SVG transcoder. + * + *

Renders the six SVGs declared in {@code theme.css} via + * {@code Resources.getGlobalResources().getImage(name)} -- exactly the + * call any user app would make. The CSS compiler stored a 1×1 PNG + * placeholder under each name, and the per-port wiring (JavaSE port, + * IPhoneBuilder, AndroidGradleBuilder) ran the auto-generated + * {@code com.codename1.generated.svg.SVGRegistry.installGlobal()} on + * startup, replacing every placeholder with the transcoded + * {@code GeneratedSVGImage}. No glue code in app land.

+ * + *

Known port-side rendering bugs the goldens encode

+ * + *

The screenshot baselines record the current per-port behavior so + * regressions in the rendering pipeline show up as diffs. These items + * are tracked separately and a follow-up port-side PR will refresh the + * goldens once the underlying bugs are fixed:

+ *
    + *
  • iOS (legacy + Metal): {@code gradient_circle.svg} and + * {@code clipped_badge.svg} render as triangles because the + * iOS port's {@code setClip(GeneralPath)} substitutes a + * degenerate polygon for arc-decomposed paths.
    • + *
  • iOS (legacy + Metal): {@code } on {@code fill} + * colors doesn't tick. {@code color_morph.svg} freezes on the + * start color (white on legacy, the first palette stop on + * Metal); Android animates it as expected.
    • + *
  • Android: {@code gradient_circle.svg} draws both the filled + * circle and an outline of the same circle stacked, rather than + * a single filled circle with a darker stroke.
    • + *
+ * + *

If this test calls {@code SVGRegistry.install(...)} explicitly it + * has failed the point of the test: the registry is supposed to be + * seamless to the developer.

+ */ +public class SVGStaticScreenshotTest extends BaseTest { + + @Override + public boolean shouldTakeScreenshot() { + // The JS port is in this test's HTML5_SKIP set, but the global + // shouldForceTimeoutInHtml5 path is not reliable (it never logs the + // "forced timeout (HTML5 fallback)" marker in CI output), so opt + // out at the per-test level too. Suite stays under the 150s + // browser-lifetime budget on JS without truncating the iOS / + // Android coverage this test exists to provide. + return !"HTML5".equals(Display.getInstance().getPlatformName()); + } + + @Override + public boolean runTest() throws Exception { + if ("HTML5".equals(Display.getInstance().getPlatformName())) { + // Skip on JS per shouldTakeScreenshot above. Mark done immediately + // so the runner doesn't spin its per-test 10s deadline. + done(); + return true; + } + Resources res = resolveGlobalResources(); + + // 2x3 grid so every transcoded SVG fits in a single screenshot + // capture -- a BoxLayout.y stacked the entries off the bottom of + // the iOS / Android viewport and the user only saw the first three. + Form form = createForm("Static SVG (theme.getImage)", new GridLayout(3, 2), "SVGStatic"); + form.add(label("star.svg", res == null ? null : res.getImage("star.svg"))); + form.add(label("gradient_circle.svg", res == null ? null : res.getImage("gradient_circle.svg"))); + form.add(label("path_arrow.svg", res == null ? null : res.getImage("path_arrow.svg"))); + // end-to-end -- font-weight + anchor + multi-color fills: + form.add(label("logo_text.svg", res == null ? null : res.getImage("logo_text.svg"))); + // S/T smooth curves + dashed strokes: + form.add(label("wave_path.svg", res == null ? null : res.getImage("wave_path.svg"))); + // clip-path: rounded-rect outline gating a gradient-filled rect + text: + form.add(label("clipped_badge.svg", res == null ? null : res.getImage("clipped_badge.svg"))); + form.show(); + return true; + } + + private Label label(String text, Image img) { + if (img == null) { + Label l = new Label(text + " "); + l.getAllStyles().setFgColor(0xFF0000); + return l; + } + Label l = new Label(text, img); + Style s = l.getAllStyles(); + s.setMargin(8, 8, 8, 8); + return l; + } + + /** Locate the project's global Resources bundle. The framework normally + * loads the default theme into the global slot at app init; if it + * hasn't (or this test is run in isolation), open the bundled + * theme.res by class-relative path and remember it. */ + static Resources resolveGlobalResources() { + Resources r = Resources.getGlobalResources(); + if (r != null) { + return r; + } + InputStream in = null; + try { + in = SVGStaticScreenshotTest.class.getResourceAsStream("/theme"); + if (in == null) { + in = SVGStaticScreenshotTest.class.getResourceAsStream("/theme.res"); + } + if (in != null) { + Resources opened = Resources.open(in); + Resources.setGlobalResources(opened); + return opened; + } + } catch (Throwable t) { + Log.e(t); + } finally { + try { if (in != null) in.close(); } catch (Throwable ignored) { /* no-op */ } + } + return null; + } +} diff --git a/scripts/initializr/common/src/main/resources/skill/references/css.md b/scripts/initializr/common/src/main/resources/skill/references/css.md index 4c75f2c3c3..3212364959 100644 --- a/scripts/initializr/common/src/main/resources/skill/references/css.md +++ b/scripts/initializr/common/src/main/resources/skill/references/css.md @@ -284,6 +284,35 @@ Use multi-images for everything that ships with the app (icons, decorative graph See `references/java-api-subset.md` *Multi-images* for the full density table. +### SVG icons — build-time transcoder + +Drop an `.svg` file into `common/src/main/css/` and reference it from CSS the same way you would a PNG: + +```css +HomeIcon { + background: url(home.svg); + cn1-svg-width: 6mm; /* recommended: pin physical size */ + cn1-svg-height: 6mm; + bg-type: image_scaled_fit; +} +``` + +The build-time SVG transcoder parses each referenced `.svg` and emits a Java `com.codename1.ui.GeneratedSVGImage` subclass that renders the vector through the standard `Graphics` shape API. A generated `SVGRegistry` is installed automatically into every `Resources` opened in the VM — no glue code in app land. Fetching is identical to multi-images: + +```java +Image home = Resources.getGlobalResources().getImage("home.svg"); +``` + +**Sizing keys** (mirror the multi-image conventions): + +- `cn1-svg-width` / `cn1-svg-height` in **mm** — recommended; the value is routed through `Display.convertToPixels()` so the icon comes out at the same physical size on every device. Use this for any SVG with non-standard intrinsic dimensions (most third-party SVGs). +- `cn1-source-dpi: ` — declares which density bucket the SVG was authored for; runtime scales by `deviceDensity / sourceDensity`. Use the same keywords multi-images do (`medium`, `high`, `very-high`, `hd`, `2hd`, `4k`, etc.). +- No hint — the SVG's declared pixel dimensions are treated as `DENSITY_MEDIUM` design pixels and scaled to the device. + +**SVG coverage**: rect / circle / ellipse / line / polyline / polygon / path (full mini-language including arcs), affine transforms (translate / rotate / scale / skew / matrix), linear gradients (shape-clipped), opacity / fill-opacity / stroke-opacity (animatable), `` with anchor / font-size / font-weight / font-style, SMIL animations (`` of numeric attrs, `` translate / scale / rotate, ``). Not (yet) supported: `` primitives, alpha ``. Radial gradients fall back to first-stop color. + +For the full feature matrix and troubleshooting, point users to `docs/developer-guide/SVG-Transcoder.asciidoc`. + ### Custom TTF fonts Drop a `.ttf` (or `.otf`) under `common/src/main/css/fonts/`, then reference its **font name (not file name)** in `font-family`: diff --git a/scripts/ios/screenshots-metal/SVGAnimatedScreenshotTest.png b/scripts/ios/screenshots-metal/SVGAnimatedScreenshotTest.png new file mode 100644 index 0000000000..e2cad74b18 Binary files /dev/null and b/scripts/ios/screenshots-metal/SVGAnimatedScreenshotTest.png differ diff --git a/scripts/ios/screenshots-metal/SVGStatic.png b/scripts/ios/screenshots-metal/SVGStatic.png new file mode 100644 index 0000000000..77922dcd34 Binary files /dev/null and b/scripts/ios/screenshots-metal/SVGStatic.png differ diff --git a/scripts/ios/screenshots/SVGAnimatedScreenshotTest.png b/scripts/ios/screenshots/SVGAnimatedScreenshotTest.png new file mode 100644 index 0000000000..2d51679188 Binary files /dev/null and b/scripts/ios/screenshots/SVGAnimatedScreenshotTest.png differ diff --git a/scripts/ios/screenshots/SVGStatic.png b/scripts/ios/screenshots/SVGStatic.png new file mode 100644 index 0000000000..b06cc1ca47 Binary files /dev/null and b/scripts/ios/screenshots/SVGStatic.png differ