summaryrefslogtreecommitdiffstats
path: root/layout/svg/SVGContextPaint.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /layout/svg/SVGContextPaint.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'layout/svg/SVGContextPaint.h')
-rw-r--r--layout/svg/SVGContextPaint.h287
1 files changed, 287 insertions, 0 deletions
diff --git a/layout/svg/SVGContextPaint.h b/layout/svg/SVGContextPaint.h
new file mode 100644
index 0000000000..1264bf706f
--- /dev/null
+++ b/layout/svg/SVGContextPaint.h
@@ -0,0 +1,287 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef LAYOUT_SVG_SVGCONTEXTPAINT_H_
+#define LAYOUT_SVG_SVGCONTEXTPAINT_H_
+
+#include "DrawMode.h"
+#include "gfxMatrix.h"
+#include "gfxPattern.h"
+#include "gfxTypes.h"
+#include "gfxUtils.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/gfx/2D.h"
+#include "nsColor.h"
+#include "nsStyleStruct.h"
+#include "nsTArray.h"
+#include "ImgDrawResult.h"
+#include "nsRefPtrHashtable.h"
+
+class gfxContext;
+
+namespace mozilla {
+class SVGPaintServerFrame;
+
+namespace dom {
+class Document;
+}
+
+/**
+ * This class is used to pass information about a context element through to
+ * SVG painting code in order to resolve the 'context-fill' and related
+ * keywords. See:
+ *
+ * https://www.w3.org/TR/SVG2/painting.html#context-paint
+ *
+ * This feature allows the color in an SVG-in-OpenType glyph to come from the
+ * computed style for the text that is being drawn, for example, or for color
+ * in an SVG embedded by an <img> element to come from the embedding <img>
+ * element.
+ *
+ * This class is reference counted so that it can be shared among many similar
+ * SVGImageContext objects. (SVGImageContext objects are frequently
+ * copy-constructed with small modifications, and we'd like for those copies to
+ * be able to share their context-paint data cheaply.) However, in most cases,
+ * SVGContextPaint instances are stored in a local RefPtr and only last for the
+ * duration of a function call.
+ * XXX Note: SVGImageContext doesn't actually have a SVGContextPaint member yet,
+ * but it will in a later patch in the patch series that added this comment.
+ */
+class SVGContextPaint : public RefCounted<SVGContextPaint> {
+ protected:
+ using DrawTarget = mozilla::gfx::DrawTarget;
+ using Float = mozilla::gfx::Float;
+ using imgDrawingParams = mozilla::image::imgDrawingParams;
+
+ SVGContextPaint() : mDashOffset(0.0f), mStrokeWidth(0.0f) {}
+
+ public:
+ MOZ_DECLARE_REFCOUNTED_TYPENAME(SVGContextPaint)
+
+ virtual ~SVGContextPaint() = default;
+
+ virtual already_AddRefed<gfxPattern> GetFillPattern(
+ const DrawTarget* aDrawTarget, float aOpacity, const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) = 0;
+ virtual already_AddRefed<gfxPattern> GetStrokePattern(
+ const DrawTarget* aDrawTarget, float aOpacity, const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) = 0;
+ virtual float GetFillOpacity() const = 0;
+ virtual float GetStrokeOpacity() const = 0;
+
+ already_AddRefed<gfxPattern> GetFillPattern(const DrawTarget* aDrawTarget,
+ const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) {
+ return GetFillPattern(aDrawTarget, GetFillOpacity(), aCTM, aImgParams);
+ }
+
+ already_AddRefed<gfxPattern> GetStrokePattern(const DrawTarget* aDrawTarget,
+ const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) {
+ return GetStrokePattern(aDrawTarget, GetStrokeOpacity(), aCTM, aImgParams);
+ }
+
+ static SVGContextPaint* GetContextPaint(nsIContent* aContent);
+
+ // XXX This gets the geometry params from the gfxContext. We should get that
+ // information from the actual paint context!
+ void InitStrokeGeometry(gfxContext* aContext, float devUnitsPerSVGUnit);
+
+ const FallibleTArray<Float>& GetStrokeDashArray() const { return mDashes; }
+
+ Float GetStrokeDashOffset() const { return mDashOffset; }
+
+ Float GetStrokeWidth() const { return mStrokeWidth; }
+
+ virtual uint32_t Hash() const {
+ MOZ_ASSERT_UNREACHABLE(
+ "Only VectorImage needs to hash, and that should "
+ "only be operating on our SVGEmbeddingContextPaint "
+ "subclass");
+ return 0;
+ }
+
+ /**
+ * Returns true if image context paint is allowed to be used in an image that
+ * has the given URI, else returns false.
+ */
+ static bool IsAllowedForImageFromURI(nsIURI* aURI);
+
+ private:
+ // Member-vars are initialized in InitStrokeGeometry.
+ FallibleTArray<Float> mDashes;
+ MOZ_INIT_OUTSIDE_CTOR Float mDashOffset;
+ MOZ_INIT_OUTSIDE_CTOR Float mStrokeWidth;
+};
+
+/**
+ * RAII class used to temporarily set and remove an SVGContextPaint while a
+ * piece of SVG is being painted. The context paint is set on the SVG's owner
+ * document, as expected by SVGContextPaint::GetContextPaint. Any pre-existing
+ * context paint is restored after this class removes the context paint that it
+ * set.
+ */
+class MOZ_RAII AutoSetRestoreSVGContextPaint {
+ public:
+ AutoSetRestoreSVGContextPaint(const SVGContextPaint* aContextPaint,
+ dom::Document* aDocument);
+ ~AutoSetRestoreSVGContextPaint();
+
+ private:
+ dom::Document* mDocument;
+ // The context paint that needs to be restored by our dtor after it removes
+ // aContextPaint:
+ const SVGContextPaint* mOuterContextPaint;
+};
+
+/**
+ * This class should be flattened into SVGContextPaint once we get rid of the
+ * other sub-class (SimpleTextContextPaint).
+ */
+struct SVGContextPaintImpl : public SVGContextPaint {
+ protected:
+ using DrawTarget = mozilla::gfx::DrawTarget;
+
+ public:
+ DrawMode Init(const DrawTarget* aDrawTarget, const gfxMatrix& aContextMatrix,
+ nsIFrame* aFrame, SVGContextPaint* aOuterContextPaint,
+ imgDrawingParams& aImgParams);
+
+ already_AddRefed<gfxPattern> GetFillPattern(
+ const DrawTarget* aDrawTarget, float aOpacity, const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) override;
+ already_AddRefed<gfxPattern> GetStrokePattern(
+ const DrawTarget* aDrawTarget, float aOpacity, const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) override;
+
+ void SetFillOpacity(float aOpacity) { mFillOpacity = aOpacity; }
+ float GetFillOpacity() const override { return mFillOpacity; }
+
+ void SetStrokeOpacity(float aOpacity) { mStrokeOpacity = aOpacity; }
+ float GetStrokeOpacity() const override { return mStrokeOpacity; }
+
+ struct Paint {
+ enum class Tag : uint8_t {
+ None,
+ Color,
+ PaintServer,
+ ContextFill,
+ ContextStroke,
+ };
+
+ Paint() : mPaintDefinition{}, mPaintType(Tag::None) {}
+
+ void SetPaintServer(nsIFrame* aFrame, const gfxMatrix& aContextMatrix,
+ SVGPaintServerFrame* aPaintServerFrame) {
+ mPaintType = Tag::PaintServer;
+ mPaintDefinition.mPaintServerFrame = aPaintServerFrame;
+ mFrame = aFrame;
+ mContextMatrix = aContextMatrix;
+ }
+
+ void SetColor(const nscolor& aColor) {
+ mPaintType = Tag::Color;
+ mPaintDefinition.mColor = aColor;
+ }
+
+ void SetContextPaint(SVGContextPaint* aContextPaint, Tag aTag) {
+ MOZ_ASSERT(aTag == Tag::ContextFill || aTag == Tag::ContextStroke);
+ mPaintType = aTag;
+ mPaintDefinition.mContextPaint = aContextPaint;
+ }
+
+ union {
+ SVGPaintServerFrame* mPaintServerFrame;
+ SVGContextPaint* mContextPaint;
+ nscolor mColor;
+ } mPaintDefinition;
+
+ // Initialized (if needed) in SetPaintServer():
+ MOZ_INIT_OUTSIDE_CTOR nsIFrame* mFrame;
+ // CTM defining the user space for the pattern we will use.
+ gfxMatrix mContextMatrix;
+ Tag mPaintType;
+
+ // Device-space-to-pattern-space
+ gfxMatrix mPatternMatrix;
+ nsRefPtrHashtable<nsFloatHashKey, gfxPattern> mPatternCache;
+
+ already_AddRefed<gfxPattern> GetPattern(
+ const DrawTarget* aDrawTarget, float aOpacity,
+ StyleSVGPaint nsStyleSVG::*aFillOrStroke, const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams);
+ };
+
+ Paint mFillPaint;
+ Paint mStrokePaint;
+
+ float mFillOpacity;
+ float mStrokeOpacity;
+};
+
+/**
+ * This class is used to pass context paint to an SVG image when an element
+ * references that image (e.g. via HTML <img> or SVG <image>, or by referencing
+ * it from a CSS property such as 'background-image'). In this case we only
+ * support context colors and not paint servers.
+ */
+class SVGEmbeddingContextPaint : public SVGContextPaint {
+ using DeviceColor = gfx::DeviceColor;
+
+ public:
+ SVGEmbeddingContextPaint() : mFillOpacity(1.0f), mStrokeOpacity(1.0f) {}
+
+ bool operator==(const SVGEmbeddingContextPaint& aOther) const {
+ MOZ_ASSERT(GetStrokeWidth() == aOther.GetStrokeWidth() &&
+ GetStrokeDashOffset() == aOther.GetStrokeDashOffset() &&
+ GetStrokeDashArray() == aOther.GetStrokeDashArray(),
+ "We don't currently include these in the context information "
+ "from an embedding element");
+ return mFill == aOther.mFill && mStroke == aOther.mStroke &&
+ mFillOpacity == aOther.mFillOpacity &&
+ mStrokeOpacity == aOther.mStrokeOpacity;
+ }
+
+ void SetFill(nscolor aFill) { mFill.emplace(gfx::ToDeviceColor(aFill)); }
+ const Maybe<DeviceColor>& GetFill() const { return mFill; }
+ void SetStroke(nscolor aStroke) {
+ mStroke.emplace(gfx::ToDeviceColor(aStroke));
+ }
+ const Maybe<DeviceColor>& GetStroke() const { return mStroke; }
+
+ /**
+ * Returns a pattern of type PatternType::COLOR, or else nullptr.
+ */
+ already_AddRefed<gfxPattern> GetFillPattern(
+ const DrawTarget* aDrawTarget, float aFillOpacity, const gfxMatrix& aCTM,
+ imgDrawingParams& aImgParams) override;
+
+ /**
+ * Returns a pattern of type PatternType::COLOR, or else nullptr.
+ */
+ already_AddRefed<gfxPattern> GetStrokePattern(
+ const DrawTarget* aDrawTarget, float aStrokeOpacity,
+ const gfxMatrix& aCTM, imgDrawingParams& aImgParams) override;
+
+ void SetFillOpacity(float aOpacity) { mFillOpacity = aOpacity; }
+ float GetFillOpacity() const override { return mFillOpacity; };
+
+ void SetStrokeOpacity(float aOpacity) { mStrokeOpacity = aOpacity; }
+ float GetStrokeOpacity() const override { return mStrokeOpacity; };
+
+ uint32_t Hash() const override;
+
+ private:
+ Maybe<DeviceColor> mFill;
+ Maybe<DeviceColor> mStroke;
+ float mFillOpacity;
+ float mStrokeOpacity;
+};
+
+} // namespace mozilla
+
+#endif // LAYOUT_SVG_SVGCONTEXTPAINT_H_