Skip to content

Lightpanda: the headless browser designed for AI and automation

svg: make live collection mutations transactional

Madison Steiner29109a2dea43
diff --git a/src/browser/tests/element/svg/collections.html b/src/browser/tests/element/svg/collections.html
index f3dcadc3d..43de72eeb 100644
--- a/src/browser/tests/element/svg/collections.html
+++ b/src/browser/tests/element/svg/collections.html
@@ -7,6 +7,8 @@
<polyline id=many></polyline>
<g id=group transform="translate(10 20) rotate(45 1 2)"
requiredExtensions="urn:one urn:two" systemLanguage="en, fr"></g>
+ <g id=matrixGroup transform="translate(1 2)"></g>
+ <g id=replaceGroup transform="scale(1) translate(0 0)"></g>
</svg>
<script id=pointLists>
@@ -147,6 +149,79 @@
}
</script>
+<script id=transformMatrixReflection>
+{
+ const root = $('#root');
+ const group = $('#matrixGroup');
+ const base = group.transform.baseVal;
+ const anim = group.transform.animVal;
+ const transform = base.getItem(0);
+ const matrix = transform.matrix;
+
+ testing.expectEqual(true, matrix === transform.matrix);
+ matrix.e = 5;
+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, transform.type);
+ testing.expectEqual(0, transform.angle);
+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix('));
+ testing.expectEqual(5, anim.getItem(0).matrix.e);
+
+ testing.expectEqual(matrix, matrix.translateSelf(2, 3));
+ testing.expectEqual(7, matrix.e);
+ testing.expectEqual(5, matrix.f);
+ testing.expectEqual(7, anim.getItem(0).matrix.e);
+ testing.expectEqual(5, anim.getItem(0).matrix.f);
+
+ testing.expectEqual(matrix, matrix.setMatrixValue('matrix(1, 0, 0, 1, 9, 10)'));
+ testing.expectEqual(9, matrix.e);
+ testing.expectEqual(10, matrix.f);
+ testing.expectEqual(9, anim.getItem(0).matrix.e);
+ testing.expectEqual(10, anim.getItem(0).matrix.f);
+
+ const animMatrix = anim.getItem(0).matrix;
+ const beforeReadOnlyWrites = group.getAttribute('transform');
+ testing.expectError('NoModificationAllowedError', () => { animMatrix.e = 99; });
+ testing.expectError('NoModificationAllowedError', () => animMatrix.translateSelf(1, 1));
+ testing.expectError('NoModificationAllowedError', () => animMatrix.setMatrixValue('scale(2)'));
+ testing.expectEqual(beforeReadOnlyWrites, group.getAttribute('transform'));
+ testing.expectEqual(9, animMatrix.e);
+
+ group.setAttribute('transform', 'scale(4)');
+ testing.expectEqual(1, base.length);
+ matrix.e = 11;
+ testing.expectEqual('scale(4)', group.getAttribute('transform'));
+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, transform.type);
+ testing.expectEqual(11, matrix.e);
+
+ const detached = root.createSVGTransform();
+ const detachedMatrix = detached.matrix;
+ detachedMatrix.e = 13;
+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, detached.type);
+ testing.expectEqual(true, detachedMatrix === detached.matrix);
+ detachedMatrix.m13 = 2;
+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_UNKNOWN, detached.type);
+ testing.expectEqual(false, detachedMatrix.is2D);
+
+ testing.expectEqual(detached, base.initialize(detached));
+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix3d('));
+ testing.expectEqual(2, base.getItem(0).matrix.m13);
+ testing.expectEqual(2, anim.getItem(0).matrix.m13);
+ testing.expectError('NoModificationAllowedError', () => { anim.getItem(0).matrix.m13 = 3; });
+
+ const consolidated = base.consolidate();
+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_UNKNOWN, consolidated.type);
+ testing.expectEqual(false, consolidated.matrix.is2D);
+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix3d('));
+
+ const replaceGroup = $('#replaceGroup');
+ const replacement = root.createSVGTransform();
+ replacement.setScale(10, 1);
+ testing.expectEqual(replacement, replaceGroup.transform.baseVal.replaceItem(replacement, 0));
+ testing.expectEqual(replacement, replaceGroup.transform.baseVal.getItem(0));
+ testing.expectEqual(10, replacement.matrix.a);
+ testing.expectEqual(true, replaceGroup.getAttribute('transform').startsWith('scale(10 1)'));
+}
+</script>
+
<script id=transformParserRegression>
{
const group = $('#group');
diff --git a/src/browser/webapi/DOMMatrix.zig b/src/browser/webapi/DOMMatrix.zig
index 132fa52a7..1e375c5f9 100644
--- a/src/browser/webapi/DOMMatrix.zig
+++ b/src/browser/webapi/DOMMatrix.zig
@@ -84,137 +84,158 @@ pub fn getF(self: *const DOMMatrix) f64 {
return self._proto._m[13];
}
-pub fn setA(self: *DOMMatrix, v: f64) void {
- self._proto._m[0] = v;
+pub fn setA(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(0, v);
}
-pub fn setB(self: *DOMMatrix, v: f64) void {
- self._proto._m[1] = v;
+pub fn setB(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(1, v);
}
-pub fn setC(self: *DOMMatrix, v: f64) void {
- self._proto._m[4] = v;
+pub fn setC(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(4, v);
}
-pub fn setD(self: *DOMMatrix, v: f64) void {
- self._proto._m[5] = v;
+pub fn setD(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(5, v);
}
-pub fn setE(self: *DOMMatrix, v: f64) void {
- self._proto._m[12] = v;
+pub fn setE(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(12, v);
}
-pub fn setF(self: *DOMMatrix, v: f64) void {
- self._proto._m[13] = v;
+pub fn setF(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(13, v);
}
-pub fn translateSelf(self: *DOMMatrix, tx_: ?f64, ty_: ?f64, tz_: ?f64) *DOMMatrix {
+pub fn translateSelf(self: *DOMMatrix, tx_: ?f64, ty_: ?f64, tz_: ?f64) !*DOMMatrix {
const tz = tz_ orelse 0;
- const p = self._proto;
- p._m = RO.multiplyMatrix(p._m, RO.translationMatrix(tx_ orelse 0, ty_ orelse 0, tz));
- if (tz != 0) p._is_2d = false;
- return self;
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.translationMatrix(tx_ orelse 0, ty_ orelse 0, tz));
+ if (tz != 0) state.is_2d = false;
+ return self.applyState(state);
}
-pub fn scaleSelf(self: *DOMMatrix, sx_: ?f64, sy_: ?f64, sz_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) *DOMMatrix {
+pub fn scaleSelf(self: *DOMMatrix, sx_: ?f64, sy_: ?f64, sz_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) !*DOMMatrix {
const sx = sx_ orelse 1;
const sy = sy_ orelse sx;
const sz = sz_ orelse 1;
const ox = ox_ orelse 0;
const oy = oy_ orelse 0;
const oz = oz_ orelse 0;
- const p = self._proto;
- var m = RO.multiplyMatrix(p._m, RO.translationMatrix(ox, oy, oz));
+ var state = self._proto.getState();
+ var m = RO.multiplyMatrix(state.matrix, RO.translationMatrix(ox, oy, oz));
m = RO.multiplyMatrix(m, RO.scaleMatrix(sx, sy, sz));
m = RO.multiplyMatrix(m, RO.translationMatrix(-ox, -oy, -oz));
- p._m = m;
- if (sz != 1 or oz != 0) p._is_2d = false;
- return self;
+ state.matrix = m;
+ if (sz != 1 or oz != 0) state.is_2d = false;
+ return self.applyState(state);
}
-pub fn scale3dSelf(self: *DOMMatrix, scale_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) *DOMMatrix {
+pub fn scale3dSelf(self: *DOMMatrix, scale_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) !*DOMMatrix {
const s = scale_ orelse 1;
const ox = ox_ orelse 0;
const oy = oy_ orelse 0;
const oz = oz_ orelse 0;
- const p = self._proto;
- var m = RO.multiplyMatrix(p._m, RO.translationMatrix(ox, oy, oz));
+ var state = self._proto.getState();
+ var m = RO.multiplyMatrix(state.matrix, RO.translationMatrix(ox, oy, oz));
m = RO.multiplyMatrix(m, RO.scaleMatrix(s, s, s));
m = RO.multiplyMatrix(m, RO.translationMatrix(-ox, -oy, -oz));
- p._m = m;
- if (s != 1) p._is_2d = false;
- return self;
+ state.matrix = m;
+ if (s != 1) state.is_2d = false;
+ return self.applyState(state);
}
-pub fn rotateSelf(self: *DOMMatrix, rx_: ?f64, ry_: ?f64, rz_: ?f64) *DOMMatrix {
- const p = self._proto;
+pub fn rotateSelf(self: *DOMMatrix, rx_: ?f64, ry_: ?f64, rz_: ?f64) !*DOMMatrix {
+ var state = self._proto.getState();
if (ry_ == null and rz_ == null) {
- p._m = RO.multiplyMatrix(p._m, RO.rotateZMatrix(RO.toRadians(rx_ orelse 0, .deg)));
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateZMatrix(RO.toRadians(rx_ orelse 0, .deg)));
} else {
- p._m = RO.multiplyMatrix(p._m, RO.rotateXMatrix(RO.toRadians(rx_ orelse 0, .deg)));
- p._m = RO.multiplyMatrix(p._m, RO.rotateYMatrix(RO.toRadians(ry_ orelse 0, .deg)));
- p._m = RO.multiplyMatrix(p._m, RO.rotateZMatrix(RO.toRadians(rz_ orelse 0, .deg)));
- p._is_2d = false;
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateXMatrix(RO.toRadians(rx_ orelse 0, .deg)));
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateYMatrix(RO.toRadians(ry_ orelse 0, .deg)));
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateZMatrix(RO.toRadians(rz_ orelse 0, .deg)));
+ state.is_2d = false;
}
- return self;
+ return self.applyState(state);
}
-pub fn rotateFromVectorSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64) *DOMMatrix {
+pub fn rotateFromVectorSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64) !*DOMMatrix {
const x = x_ orelse 0;
const y = y_ orelse 0;
const rad = if (x == 0 and y == 0) 0 else std.math.atan2(y, x);
- const p = self._proto;
- p._m = RO.multiplyMatrix(p._m, RO.rotateZMatrix(rad));
- return self;
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateZMatrix(rad));
+ return self.applyState(state);
}
-pub fn rotateAxisAngleSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64, z_: ?f64, angle_: ?f64) *DOMMatrix {
- const p = self._proto;
- p._m = RO.multiplyMatrix(p._m, RO.axisAngleMatrix(x_ orelse 0, y_ orelse 0, z_ orelse 0, RO.toRadians(angle_ orelse 0, .deg)));
- if ((x_ orelse 0) != 0 or (y_ orelse 0) != 0) p._is_2d = false;
- return self;
+pub fn rotateAxisAngleSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64, z_: ?f64, angle_: ?f64) !*DOMMatrix {
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.axisAngleMatrix(x_ orelse 0, y_ orelse 0, z_ orelse 0, RO.toRadians(angle_ orelse 0, .deg)));
+ if ((x_ orelse 0) != 0 or (y_ orelse 0) != 0) state.is_2d = false;
+ return self.applyState(state);
}
-pub fn skewXSelf(self: *DOMMatrix, sx_: ?f64) *DOMMatrix {
- const p = self._proto;
- p._m = RO.multiplyMatrix(p._m, RO.skewMatrix(RO.toRadians(sx_ orelse 0, .deg), 0));
- return self;
+pub fn skewXSelf(self: *DOMMatrix, sx_: ?f64) !*DOMMatrix {
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.skewMatrix(RO.toRadians(sx_ orelse 0, .deg), 0));
+ return self.applyState(state);
}
-pub fn skewYSelf(self: *DOMMatrix, sy_: ?f64) *DOMMatrix {
- const p = self._proto;
- p._m = RO.multiplyMatrix(p._m, RO.skewMatrix(0, RO.toRadians(sy_ orelse 0, .deg)));
- return self;
+pub fn skewYSelf(self: *DOMMatrix, sy_: ?f64) !*DOMMatrix {
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(state.matrix, RO.skewMatrix(0, RO.toRadians(sy_ orelse 0, .deg)));
+ return self.applyState(state);
}
pub fn multiplySelf(self: *DOMMatrix, other_: ?RO.DOMMatrixInit) !*DOMMatrix {
- const p = self._proto;
const other = try RO.fixupDict(other_ orelse .{});
- p._m = RO.multiplyMatrix(p._m, other.m);
- p._is_2d = p._is_2d and other.is_2d;
- return self;
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(state.matrix, other.m);
+ state.is_2d = state.is_2d and other.is_2d;
+ return self.applyState(state);
}
pub fn preMultiplySelf(self: *DOMMatrix, other_: ?RO.DOMMatrixInit) !*DOMMatrix {
- const p = self._proto;
const other = try RO.fixupDict(other_ orelse .{});
- p._m = RO.multiplyMatrix(other.m, p._m);
- p._is_2d = p._is_2d and other.is_2d;
- return self;
+ var state = self._proto.getState();
+ state.matrix = RO.multiplyMatrix(other.m, state.matrix);
+ state.is_2d = state.is_2d and other.is_2d;
+ return self.applyState(state);
}
-pub fn invertSelf(self: *DOMMatrix) *DOMMatrix {
- const p = self._proto;
- if (RO.invertMatrix(p._m)) |v| {
- p._m = v;
+pub fn invertSelf(self: *DOMMatrix) !*DOMMatrix {
+ var state = self._proto.getState();
+ if (RO.invertMatrix(state.matrix)) |v| {
+ state.matrix = v;
} else {
- p._m = .{std.math.nan(f64)} ** 16;
- p._is_2d = false;
+ state.matrix = .{std.math.nan(f64)} ** 16;
+ state.is_2d = false;
}
- return self;
+ return self.applyState(state);
}
pub fn setMatrixValue(self: *DOMMatrix, transform: []const u8) !*DOMMatrix {
- var m = RO.identity();
- var is_2d = true;
- try RO.parseTransformList(transform, &m, &is_2d);
- self._proto._m = m;
- self._proto._is_2d = is_2d;
+ var state: RO.State = .{ .matrix = RO.identity(), .is_2d = true };
+ try RO.parseTransformList(transform, &state.matrix, &state.is_2d);
+ try self._proto.applyState(state);
+ return self;
+}
+
+fn setElement(self: *DOMMatrix, comptime index: usize, value: f64) !void {
+ var state = self._proto.getState();
+ state.matrix[index] = value;
+
+ // Assigning a z/w element a value other than its identity drops the
+ // 2D flag. Setting it back does not restore is2D.
+ switch (index) {
+ 2, 3, 6, 7, 8, 9, 11, 14 => if (value != 0) {
+ state.is_2d = false;
+ },
+ 10, 15 => if (value != 1) {
+ state.is_2d = false;
+ },
+ else => {},
+ }
+ try self._proto.applyState(state);
+}
+
+fn applyState(self: *DOMMatrix, state: RO.State) !*DOMMatrix {
+ try self._proto.applyState(state);
return self;
}
@@ -281,23 +302,10 @@ pub const JsApi = struct {
}.get;
}
- fn setM(comptime idx: usize) fn (*DOMMatrix, f64) void {
+ fn setM(comptime idx: usize) fn (*DOMMatrix, f64) anyerror!void {
return struct {
- fn set(self: *DOMMatrix, v: f64) void {
- self._proto._m[idx] = v;
- // Assigning a z/w element a value other than its identity drops the
- // 2D flag. Setting it back to the identity value (0 for the
- // off-diagonal elements, 1 for m33/m44) preserves is2D. Note `-0`
- // compares equal to `0`, so it preserves it too, per spec.
- switch (idx) {
- 2, 3, 6, 7, 8, 9, 11, 14 => if (v != 0) {
- self._proto._is_2d = false;
- },
- 10, 15 => if (v != 1) {
- self._proto._is_2d = false;
- },
- else => {},
- }
+ fn set(self: *DOMMatrix, v: f64) !void {
+ try self.setElement(idx, v);
}
}.set;
}
diff --git a/src/browser/webapi/DOMMatrixReadOnly.zig b/src/browser/webapi/DOMMatrixReadOnly.zig
index 052414ab8..d86f8dd66 100644
--- a/src/browser/webapi/DOMMatrixReadOnly.zig
+++ b/src/browser/webapi/DOMMatrixReadOnly.zig
@@ -44,12 +44,24 @@ _arena: Allocator,
// out[row] = sum_col _m[col*4 + row] * in[col]
_m: [16]f64,
_is_2d: bool,
+_attachment: ?Attachment = null,
pub const Type = union(enum) {
generic,
mutable: *DOMMatrix,
};
+pub const State = struct {
+ matrix: [16]f64,
+ is_2d: bool,
+};
+
+pub const Attachment = struct {
+ owner: *anyopaque,
+ read_only: bool,
+ mutate: *const fn (*anyopaque, *DOMMatrixReadOnly, State) anyerror!void,
+};
+
pub fn init(init_: ?js.Value, exec: *const js.Execution) !*DOMMatrixReadOnly {
const parsed = try Parsed.init(init_, exec);
return createBare(parsed.m, parsed.is_2d, exec.page);
@@ -82,6 +94,40 @@ pub fn createBare(m: [16]f64, is_2d: bool, page: *Page) !*DOMMatrixReadOnly {
return self;
}
+pub fn getState(self: *const DOMMatrixReadOnly) State {
+ return .{
+ .matrix = self._m,
+ .is_2d = self._is_2d,
+ };
+}
+
+pub fn applyState(self: *DOMMatrixReadOnly, state: State) !void {
+ if (self._attachment) |attachment| {
+ if (attachment.read_only) return error.NoModificationAllowed;
+ return attachment.mutate(attachment.owner, self, state);
+ }
+ self.applyStateRaw(state);
+}
+
+pub fn applyStateRaw(self: *DOMMatrixReadOnly, state: State) void {
+ self._m = state.matrix;
+ self._is_2d = state.is_2d;
+}
+
+pub fn attach(self: *DOMMatrixReadOnly, attachment: Attachment) void {
+ self._attachment = attachment;
+}
+
+pub fn detach(self: *DOMMatrixReadOnly, owner: *anyopaque) void {
+ const attachment = self._attachment orelse return;
+ if (attachment.owner == owner) self._attachment = null;
+}
+
+pub fn isAttachedTo(self: *const DOMMatrixReadOnly, owner: *anyopaque) bool {
+ const attachment = self._attachment orelse return false;
+ return attachment.owner == owner;
+}
+
pub const DOMMatrixInit = struct {
a: ?f64 = null,
b: ?f64 = null,
@@ -432,7 +478,6 @@ pub fn parseTransformFunction(function: TransformFunction, syntax: TransformSynt
}
if (Eql(u8, name, "matrix3d")) {
- if (syntax == .svg) return error.SyntaxError;
try requireCount(count, 16, 16);
try requireUnitless(units[0..count]);
return makeParsedTransform(.matrix3d, values, values, count, false);
diff --git a/src/browser/webapi/svg/PointList.zig b/src/browser/webapi/svg/PointList.zig
index 558a04c89..e412b8ed1 100644
--- a/src/browser/webapi/svg/PointList.zig
+++ b/src/browser/webapi/svg/PointList.zig
@@ -72,8 +72,9 @@ pub fn getNumberOfItems(self: *PointList, frame: *Frame) !u32 {
pub fn clear(self: *PointList, frame: *Frame) !void {
try self.requireMutable();
try self.sync(frame);
- try self.retireAll(frame);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self.setAttribute(&.{}, frame);
+ self.retireAllAssumeCapacity();
}
pub fn initialize(self: *PointList, item: *DOMPoint, frame: *Frame) !*DOMPoint {
@@ -83,9 +84,10 @@ pub fn initialize(self: *PointList, item: *DOMPoint, frame: *Frame) !*DOMPoint {
const prepared = try self.prepareItem(item, frame);
errdefer prepared._proto.releaseRef(frame._page);
- try self.retireAll(frame);
try self._items.ensureTotalCapacity(frame.arena, 1);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self.setAttribute(&.{prepared}, frame);
+ self.retireAllAssumeCapacity();
self._items.appendAssumeCapacity(prepared);
self.attach(prepared);
return prepared;
@@ -218,17 +220,20 @@ fn sync(self: *PointList, frame: *Frame) !void {
return;
}
- self._synced = false;
var parsed = parse(raw, frame) catch |err| switch (err) {
error.SyntaxError => std.ArrayList(*DOMPoint).empty,
else => return err,
};
errdefer for (parsed.items) |point| point._proto.releaseRef(frame._page);
- self._snapshot.clearRetainingCapacity();
- try self._snapshot.appendSlice(frame.arena, raw);
- try self.retireAll(frame);
+ try self._snapshot.ensureTotalCapacity(frame.arena, raw.len);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);
+
+ self._synced = false;
+ self._snapshot.clearRetainingCapacity();
+ self._snapshot.appendSliceAssumeCapacity(raw);
+ self.retireAllAssumeCapacity();
for (parsed.items) |point| {
self._items.appendAssumeCapacity(point);
self.attach(point);
@@ -264,9 +269,7 @@ fn parse(raw: []const u8, frame: *Frame) !std.ArrayList(*DOMPoint) {
return parsed;
}
-fn retireAll(self: *PointList, frame: *Frame) !void {
- self._synced = false;
- try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
+fn retireAllAssumeCapacity(self: *PointList) void {
for (self._items.items) |point| {
point._proto.detach(self);
self._retired.appendAssumeCapacity(point);
@@ -303,10 +306,11 @@ fn setAttributeWithOverride(
}
fn commitAttribute(self: *PointList, serialized: []const u8, frame: *Frame) !void {
- self._synced = false;
+ try self._snapshot.ensureTotalCapacity(frame.arena, serialized.len);
try self._element.setAttributeSafe(comptime .wrap("points"), .wrap(serialized), frame);
+ self._synced = false;
self._snapshot.clearRetainingCapacity();
- try self._snapshot.appendSlice(frame.arena, serialized);
+ self._snapshot.appendSliceAssumeCapacity(serialized);
self._synced = true;
}
diff --git a/src/browser/webapi/svg/Transform.zig b/src/browser/webapi/svg/Transform.zig
index a1e427593..d79ab1839 100644
--- a/src/browser/webapi/svg/Transform.zig
+++ b/src/browser/webapi/svg/Transform.zig
@@ -77,19 +77,24 @@ pub fn releaseRef(self: *Transform, page: *Page) void {
pub fn detached(frame: *Frame) !*Transform {
const matrix = try DOMMatrix.create(RO.identity(), true, frame._page);
errdefer matrix._proto.deinit(frame._page);
- return frame._factory.create(Transform{ ._matrix = matrix });
+ const self = try frame._factory.create(Transform{ ._matrix = matrix });
+ self.attachMatrix(false);
+ return self;
}
pub fn fromMatrix(init: ?DOMMatrix2DInit, frame: *Frame) !*Transform {
const parsed = try fixup2D(init orelse .{});
const matrix = try DOMMatrix.create(parsed.m, true, frame._page);
errdefer matrix._proto.deinit(frame._page);
- return frame._factory.create(Transform{ ._matrix = matrix });
+ const self = try frame._factory.create(Transform{ ._matrix = matrix });
+ self.attachMatrix(false);
+ return self;
}
pub fn fromParsed(parsed: RO.ParsedTransform, frame: *Frame) !*Transform {
const typ: u16 = switch (parsed.kind) {
.matrix => 1,
+ .matrix3d => 0,
.translate => 2,
.scale => 3,
.rotate => 4,
@@ -99,26 +104,30 @@ pub fn fromParsed(parsed: RO.ParsedTransform, frame: *Frame) !*Transform {
};
const matrix = try DOMMatrix.create(parsed.matrix, parsed.is_2d, frame._page);
errdefer matrix._proto.deinit(frame._page);
- return frame._factory.create(Transform{
+ const self = try frame._factory.create(Transform{
._type = typ,
._angle = if (typ >= 4) parsed.values[0] else 0,
._cx = if (typ == 4 and parsed.count == 3) parsed.values[1] else 0,
._cy = if (typ == 4 and parsed.count == 3) parsed.values[2] else 0,
._matrix = matrix,
});
+ self.attachMatrix(false);
+ return self;
}
pub fn clone(self: *const Transform, frame: *Frame) !*Transform {
const current = self.getState();
const matrix = try DOMMatrix.create(current.matrix, current.is_2d, frame._page);
errdefer matrix._proto.deinit(frame._page);
- return frame._factory.create(Transform{
+ const cloned = try frame._factory.create(Transform{
._type = current.typ,
._angle = current.angle,
._cx = current.cx,
._cy = current.cy,
._matrix = matrix,
});
+ cloned.attachMatrix(false);
+ return cloned;
}
pub fn getType(self: *const Transform) u16 {
@@ -183,8 +192,10 @@ pub fn applyStateRaw(self: *Transform, state: State) void {
self._angle = state.angle;
self._cx = state.cx;
self._cy = state.cy;
- self._matrix._proto._m = state.matrix;
- self._matrix._proto._is_2d = state.is_2d;
+ self._matrix._proto.applyStateRaw(.{
+ .matrix = state.matrix,
+ .is_2d = state.is_2d,
+ });
}
fn applyState(self: *Transform, state: State) !void {
@@ -198,11 +209,15 @@ fn applyState(self: *Transform, state: State) !void {
pub fn attach(self: *Transform, attachment: Attachment) void {
self._attachment = attachment;
+ self.attachMatrix(attachment.read_only);
}
pub fn detach(self: *Transform, owner: *anyopaque) void {
const attachment = self._attachment orelse return;
- if (attachment.owner == owner) self._attachment = null;
+ if (attachment.owner == owner) {
+ self._attachment = null;
+ self.attachMatrix(false);
+ }
}
pub fn isAttached(self: *const Transform) bool {
@@ -216,6 +231,12 @@ pub fn isAttachedTo(self: *const Transform, owner: *anyopaque) bool {
pub fn writeState(state: State, writer: anytype) !void {
switch (state.typ) {
+ 0 => try writer.print("matrix3d({d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d})", .{
+ state.matrix[0], state.matrix[1], state.matrix[2], state.matrix[3],
+ state.matrix[4], state.matrix[5], state.matrix[6], state.matrix[7],
+ state.matrix[8], state.matrix[9], state.matrix[10], state.matrix[11],
+ state.matrix[12], state.matrix[13], state.matrix[14], state.matrix[15],
+ }),
1 => try writer.print("matrix({d} {d} {d} {d} {d} {d})", .{
state.matrix[0], state.matrix[1], state.matrix[4], state.matrix[5], state.matrix[12], state.matrix[13],
}),
@@ -231,6 +252,26 @@ pub fn writeState(state: State, writer: anytype) !void {
}
}
+fn attachMatrix(self: *Transform, read_only: bool) void {
+ self._matrix._proto.attach(.{
+ .owner = self,
+ .read_only = read_only,
+ .mutate = Transform.mutateMatrix,
+ });
+}
+
+fn mutateMatrix(context: *anyopaque, _: *RO, state: RO.State) anyerror!void {
+ const self: *Transform = @ptrCast(@alignCast(context));
+ try self.applyState(.{
+ .typ = if (state.is_2d) 1 else 0,
+ .angle = 0,
+ .cx = 0,
+ .cy = 0,
+ .matrix = state.matrix,
+ .is_2d = state.is_2d,
+ });
+}
+
fn fixup2D(init: DOMMatrix2DInit) !RO.Parsed {
const parsed = try RO.fixupDict(.{
.a = init.a,
diff --git a/src/browser/webapi/svg/TransformList.zig b/src/browser/webapi/svg/TransformList.zig
index 773b2557b..729e33223 100644
--- a/src/browser/webapi/svg/TransformList.zig
+++ b/src/browser/webapi/svg/TransformList.zig
@@ -53,8 +53,9 @@ pub fn getNumberOfItems(self: *TransformList, frame: *Frame) !u32 {
pub fn clear(self: *TransformList, frame: *Frame) !void {
try self.requireMutable();
try self.sync(frame);
- try self.retireAll(frame);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self.setAttribute(&.{}, frame);
+ self.retireAllAssumeCapacity();
}
pub fn initialize(self: *TransformList, item: *Transform, frame: *Frame) !*Transform {
@@ -63,9 +64,10 @@ pub fn initialize(self: *TransformList, item: *Transform, frame: *Frame) !*Trans
const prepared = try self.prepareItem(item, frame);
errdefer prepared.releaseRef(frame._page);
- try self.retireAll(frame);
try self._items.ensureTotalCapacity(frame.arena, 1);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self.setAttribute(&.{prepared}, frame);
+ self.retireAllAssumeCapacity();
self._items.appendAssumeCapacity(prepared);
self.attach(prepared);
return prepared;
@@ -140,28 +142,36 @@ pub fn consolidate(self: *TransformList, frame: *Frame) !?*Transform {
if (self._items.items.len == 0) return null;
var matrix = DOMMatrixReadOnly.identity();
- for (self._items.items) |item| matrix = DOMMatrixReadOnly.multiplyMatrix(matrix, item.getState().matrix);
+ var is_2d = true;
+ for (self._items.items) |item| {
+ const state = item.getState();
+ matrix = DOMMatrixReadOnly.multiplyMatrix(matrix, state.matrix);
+ is_2d = is_2d and state.is_2d;
+ }
for (matrix) |value| if (!std.math.isFinite(value)) return error.TypeError;
- var values: [16]f64 = undefined;
- values[0] = matrix[0];
- values[1] = matrix[1];
- values[2] = matrix[4];
- values[3] = matrix[5];
- values[4] = matrix[12];
- values[5] = matrix[13];
+ var values: [16]f64 = matrix;
+ if (is_2d) {
+ values[0] = matrix[0];
+ values[1] = matrix[1];
+ values[2] = matrix[4];
+ values[3] = matrix[5];
+ values[4] = matrix[12];
+ values[5] = matrix[13];
+ }
const consolidated = try Transform.fromParsed(.{
- .kind = .matrix,
+ .kind = if (is_2d) .matrix else .matrix3d,
.matrix = matrix,
.values = values,
- .count = 6,
- .is_2d = true,
+ .count = if (is_2d) 6 else 16,
+ .is_2d = is_2d,
}, frame);
consolidated.acquireRef();
errdefer consolidated.releaseRef(frame._page);
- try self.retireAll(frame);
try self._items.ensureTotalCapacity(frame.arena, 1);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self.setAttribute(&.{consolidated}, frame);
+ self.retireAllAssumeCapacity();
self._items.appendAssumeCapacity(consolidated);
self.attach(consolidated);
return consolidated;
@@ -206,17 +216,20 @@ fn sync(self: *TransformList, frame: *Frame) !void {
const raw = self._element.getAttributeSafe(comptime .wrap("transform")) orelse "";
if (self._synced and std.mem.eql(u8, self._snapshot.items, raw)) return;
- self._synced = false;
var parsed = parse(raw, frame) catch |err| switch (err) {
error.SyntaxError => std.ArrayList(*Transform).empty,
else => return err,
};
errdefer for (parsed.items) |transform| transform.releaseRef(frame._page);
- self._snapshot.clearRetainingCapacity();
- try self._snapshot.appendSlice(frame.arena, raw);
- try self.retireAll(frame);
+ try self._snapshot.ensureTotalCapacity(frame.arena, raw.len);
+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);
+
+ self._synced = false;
+ self._snapshot.clearRetainingCapacity();
+ self._snapshot.appendSliceAssumeCapacity(raw);
+ self.retireAllAssumeCapacity();
for (parsed.items) |transform| {
self._items.appendAssumeCapacity(transform);
self.attach(transform);
@@ -254,9 +267,7 @@ fn parse(raw: []const u8, frame: *Frame) !std.ArrayList(*Transform) {
return parsed;
}
-fn retireAll(self: *TransformList, frame: *Frame) !void {
- self._synced = false;
- try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);
+fn retireAllAssumeCapacity(self: *TransformList) void {
for (self._items.items) |transform| {
transform.detach(self);
self._retired.appendAssumeCapacity(transform);
@@ -285,10 +296,11 @@ fn setAttributeWithOverride(self: *TransformList, index: usize, state: Transform
}
fn commitAttribute(self: *TransformList, serialized: []const u8, frame: *Frame) !void {
- self._synced = false;
+ try self._snapshot.ensureTotalCapacity(frame.arena, serialized.len);
try self._element.setAttributeSafe(comptime .wrap("transform"), .wrap(serialized), frame);
+ self._synced = false;
self._snapshot.clearRetainingCapacity();
- try self._snapshot.appendSlice(frame.arena, serialized);
+ self._snapshot.appendSliceAssumeCapacity(serialized);
self._synced = true;
}