prototyped svg reports

server/ui/svg/transform.go

@@ -0,0 +1,155 @@
+package svg
+
+import (
+	"fmt"
+	"strings"
+)
+
+// TODO consider replacing the Transform matrices with a single 'matrix' type with different constructors and a builder/chaining api.
+
+type (
+	Transform []TransformExpression
+
+	// Transform is itself a Transform, meaning you could nest them, if you wanted.
+	TransformExpression interface {
+		PrintTransform() string
+	}
+
+	// TransformExpression implementations
+	// They can tehemselves be used as standalone 'transform' attributes.
+
+	TransformRotate      float64
+	TransformRotateAbout struct {
+		A    float64
+		X, Y float64
+	}
+	TransformTranslate struct {
+		X, Y float64
+	}
+	TransformSkewX float64
+	TransformSkewY float64
+	TransformScale struct {
+		X, Y float64
+	}
+)
+
+func (Transform) PrintKey() string {
+	return "transform"
+}
+
+func (ts Transform) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", ts.PrintTransform()), true
+}
+
+func (ts Transform) PrintTransform() string {
+	ss := make([]string, len(ts))
+	for i, t := range ts {
+		ss[i] = t.PrintTransform()
+	}
+
+	return strings.Join(ss, " ")
+}
+
+func (ts Transform) Rotate(a float64) Transform {
+	return append(ts, TransformRotate(a))
+}
+
+func (ts Transform) RotateAbout(a, x, y float64) Transform {
+	return append(ts, TransformRotateAbout{A: a, X: x, Y: y})
+}
+
+func (ts Transform) Translate(x, y float64) Transform {
+	return append(ts, TransformTranslate{X: x, Y: y})
+}
+
+func (ts Transform) SkewX(x float64) Transform {
+	return append(ts, TransformSkewX(x))
+}
+
+func (ts Transform) SkewY(y float64) Transform {
+	return append(ts, TransformSkewY(y))
+}
+
+func (ts Transform) Scale(x, y float64) Transform {
+	return append(ts, TransformScale{X: x, Y: y})
+}
+
+func (TransformRotate) PrintKey() string {
+	return "transform"
+}
+
+func (t TransformRotate) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", t.PrintTransform()), true
+}
+
+func (t TransformRotate) PrintTransform() string {
+	return fmt.Sprintf("rotate(%v)", float64(t))
+}
+
+func (t TransformRotate) About(x, y float64) TransformRotateAbout {
+	return TransformRotateAbout{
+		A: float64(t),
+		X: x,
+		Y: y,
+	}
+}
+
+func (TransformRotateAbout) PrintKey() string {
+	return "transform"
+}
+
+func (t TransformRotateAbout) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", t.PrintTransform()), true
+}
+
+func (t TransformRotateAbout) PrintTransform() string {
+	return fmt.Sprintf("rotate(%v %v %v)", t.A, t.X, t.Y)
+}
+
+func (TransformTranslate) PrintKey() string {
+	return "transform"
+}
+
+func (t TransformTranslate) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", t.PrintTransform()), true
+}
+
+func (t TransformTranslate) PrintTransform() string {
+	return fmt.Sprintf("translate(%v %v)", t.X, t.Y)
+}
+
+func (TransformSkewX) PrintKey() string {
+	return "transform"
+}
+
+func (t TransformSkewX) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", t.PrintTransform()), true
+}
+
+func (t TransformSkewX) PrintTransform() string {
+	return fmt.Sprintf("skewX(%v)", float64(t))
+}
+
+func (TransformSkewY) PrintKey() string {
+	return "transform"
+}
+
+func (t TransformSkewY) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", t.PrintTransform()), true
+}
+
+func (t TransformSkewY) PrintTransform() string {
+	return fmt.Sprintf("skewY(%v)", float64(t))
+}
+
+func (TransformScale) PrintKey() string {
+	return "transform"
+}
+
+func (t TransformScale) PrintValue() (string, bool) {
+	return fmt.Sprintf("%q", t.PrintTransform()), true
+}
+
+func (t TransformScale) PrintTransform() string {
+	return fmt.Sprintf("scale(%v %v)", t.X, t.Y)
+}