mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-12 04:45:45 +00:00
fc56b170d0
This function calculates the offset between "bounding box frame space" and "user space" for SVG frames. For non-SVG frames it returns no offset. It's crucial that this is consistent with what nsSVGUtils::GetBBox does. nsFilterInstance has several methods that are called by consumers before the actual painting, e.g. to calculate post filter extents or invalidation regions. Those nsFilterInstance APIs have their input and output values in "bounding box frame space" coordinates, but if the filter units are "objectBoundingBox", then those methods also do calculations involving the result of nsSVGUtils::GetBBox. So a consistent conversion is very important.
580 lines
20 KiB
C++
580 lines
20 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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 NS_SVGUTILS_H
|
|
#define NS_SVGUTILS_H
|
|
|
|
// include math.h to pick up definition of M_ maths defines e.g. M_PI
|
|
#define _USE_MATH_DEFINES
|
|
#include <math.h>
|
|
|
|
#include "DrawMode.h"
|
|
#include "gfx2DGlue.h"
|
|
#include "gfxMatrix.h"
|
|
#include "gfxPoint.h"
|
|
#include "gfxRect.h"
|
|
#include "mozilla/gfx/Rect.h"
|
|
#include "nsAlgorithm.h"
|
|
#include "nsChangeHint.h"
|
|
#include "nsColor.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsID.h"
|
|
#include "nsISupportsBase.h"
|
|
#include "nsMathUtils.h"
|
|
#include "nsStyleStruct.h"
|
|
#include "mozilla/Constants.h"
|
|
#include <algorithm>
|
|
|
|
class gfxContext;
|
|
class gfxPattern;
|
|
class nsFrameList;
|
|
class nsIContent;
|
|
class nsIDocument;
|
|
class nsIFrame;
|
|
class nsPresContext;
|
|
class nsRenderingContext;
|
|
class nsStyleContext;
|
|
class nsStyleCoord;
|
|
class nsSVGDisplayContainerFrame;
|
|
class nsSVGElement;
|
|
class nsSVGEnum;
|
|
class nsSVGLength2;
|
|
class nsSVGOuterSVGFrame;
|
|
class nsSVGPathGeometryFrame;
|
|
class nsTextFrame;
|
|
class gfxTextContextPaint;
|
|
|
|
struct nsStyleSVG;
|
|
struct nsStyleSVGPaint;
|
|
struct nsRect;
|
|
struct nsIntRect;
|
|
struct nsPoint;
|
|
|
|
namespace mozilla {
|
|
class SVGAnimatedPreserveAspectRatio;
|
|
class SVGPreserveAspectRatio;
|
|
namespace dom {
|
|
class Element;
|
|
} // namespace dom
|
|
namespace gfx {
|
|
class SourceSurface;
|
|
}
|
|
} // namespace mozilla
|
|
|
|
// maximum dimension of an offscreen surface - choose so that
|
|
// the surface size doesn't overflow a 32-bit signed int using
|
|
// 4 bytes per pixel; in line with gfxASurface::CheckSurfaceSize
|
|
// In fact Macs can't even manage that
|
|
#define NS_SVG_OFFSCREEN_MAX_DIMENSION 4096
|
|
|
|
#define SVG_HIT_TEST_FILL 0x01
|
|
#define SVG_HIT_TEST_STROKE 0x02
|
|
#define SVG_HIT_TEST_CHECK_MRECT 0x04
|
|
|
|
|
|
bool NS_SVGDisplayListHitTestingEnabled();
|
|
bool NS_SVGDisplayListPaintingEnabled();
|
|
|
|
/**
|
|
* Sometimes we need to distinguish between an empty box and a box
|
|
* that contains an element that has no size e.g. a point at the origin.
|
|
*/
|
|
class SVGBBox {
|
|
typedef mozilla::gfx::Rect Rect;
|
|
|
|
public:
|
|
SVGBBox()
|
|
: mIsEmpty(true) {}
|
|
|
|
SVGBBox(const Rect& aRect)
|
|
: mBBox(aRect), mIsEmpty(false) {}
|
|
|
|
SVGBBox(const gfxRect& aRect)
|
|
: mBBox(ToRect(aRect)), mIsEmpty(false) {}
|
|
|
|
gfxRect ToThebesRect() const {
|
|
return ThebesRect(mBBox);
|
|
}
|
|
|
|
bool IsEmpty() const {
|
|
return mIsEmpty;
|
|
}
|
|
|
|
void UnionEdges(const SVGBBox& aSVGBBox) {
|
|
if (aSVGBBox.mIsEmpty) {
|
|
return;
|
|
}
|
|
mBBox = mIsEmpty ? aSVGBBox.mBBox : mBBox.UnionEdges(aSVGBBox.mBBox);
|
|
mIsEmpty = false;
|
|
}
|
|
|
|
private:
|
|
Rect mBBox;
|
|
bool mIsEmpty;
|
|
};
|
|
|
|
// GRRR WINDOWS HATE HATE HATE
|
|
#undef CLIP_MASK
|
|
|
|
class MOZ_STACK_CLASS SVGAutoRenderState
|
|
{
|
|
public:
|
|
enum RenderMode {
|
|
/**
|
|
* Used to inform SVG frames that they should paint as normal.
|
|
*/
|
|
NORMAL,
|
|
/**
|
|
* Used to inform SVG frames when they are painting as the child of a
|
|
* simple clipPath. In this case they should only draw their basic geometry
|
|
* as a path. They should not fill, stroke, or paint anything else.
|
|
*/
|
|
CLIP,
|
|
/**
|
|
* Used to inform SVG frames when they are painting as the child of a
|
|
* complex clipPath that requires the use of a clip mask. In this case they
|
|
* should only draw their basic geometry as a path and then fill it using
|
|
* fully opaque white. They should not stroke, or paint anything else.
|
|
*/
|
|
CLIP_MASK
|
|
};
|
|
|
|
SVGAutoRenderState(nsRenderingContext *aContext, RenderMode aMode
|
|
MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
|
|
~SVGAutoRenderState();
|
|
|
|
void SetPaintingToWindow(bool aPaintingToWindow);
|
|
|
|
static RenderMode GetRenderMode(nsRenderingContext *aContext);
|
|
static bool IsPaintingToWindow(nsRenderingContext *aContext);
|
|
|
|
private:
|
|
nsRenderingContext *mContext;
|
|
void *mOriginalRenderState;
|
|
RenderMode mMode;
|
|
bool mPaintingToWindow;
|
|
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
|
|
};
|
|
|
|
|
|
#define NS_ISVGFILTERREFERENCE_IID \
|
|
{ 0x9744ee20, 0x1bcf, 0x4c62, \
|
|
{ 0x86, 0x7d, 0xd3, 0x7a, 0x91, 0x60, 0x3e, 0xef } }
|
|
|
|
class nsISVGFilterReference : public nsISupports
|
|
{
|
|
public:
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ISVGFILTERREFERENCE_IID)
|
|
virtual void Invalidate() = 0;
|
|
};
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(nsISVGFilterReference, NS_ISVGFILTERREFERENCE_IID)
|
|
|
|
/**
|
|
* General functions used by all of SVG layout and possibly content code.
|
|
* If a method is used by content and depends only on other content methods
|
|
* it should go in SVGContentUtils instead.
|
|
*/
|
|
class nsSVGUtils
|
|
{
|
|
public:
|
|
typedef mozilla::dom::Element Element;
|
|
|
|
static void Init();
|
|
|
|
/**
|
|
* Gets the nearest nsSVGInnerSVGFrame or nsSVGOuterSVGFrame frame. aFrame
|
|
* must be an SVG frame. If aFrame is of type nsGkAtoms::svgOuterSVGFrame,
|
|
* returns nullptr.
|
|
*/
|
|
static nsSVGDisplayContainerFrame* GetNearestSVGViewport(nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Returns the frame's post-filter visual overflow rect when passed the
|
|
* frame's pre-filter visual overflow rect. If the frame is not currently
|
|
* being filtered, this function simply returns aUnfilteredRect.
|
|
*/
|
|
static nsRect GetPostFilterVisualOverflowRect(nsIFrame *aFrame,
|
|
const nsRect &aUnfilteredRect);
|
|
|
|
/**
|
|
* Schedules an update of the frame's bounds (which will in turn invalidate
|
|
* the new area that the frame should paint to).
|
|
*
|
|
* This does nothing when passed an NS_FRAME_IS_NONDISPLAY frame.
|
|
* In future we may want to allow ReflowSVG to be called on such frames,
|
|
* but that would be better implemented as a ForceReflowSVG function to
|
|
* be called synchronously while painting them without marking or paying
|
|
* attention to dirty bits like this function.
|
|
*
|
|
* This is very similar to PresShell::FrameNeedsReflow. The main reason that
|
|
* we have this function instead of using FrameNeedsReflow is because we need
|
|
* to be able to call it under nsSVGOuterSVGFrame::NotifyViewportChange when
|
|
* that function is called by nsSVGOuterSVGFrame::Reflow. FrameNeedsReflow
|
|
* is not suitable for calling during reflow though, and it asserts as much.
|
|
* The reason that we want to be callable under NotifyViewportChange is
|
|
* because we want to synchronously notify and dirty the nsSVGOuterSVGFrame's
|
|
* children so that when nsSVGOuterSVGFrame::DidReflow is called its children
|
|
* will be updated for the new size as appropriate. Otherwise we'd have to
|
|
* post an event to the event loop to mark dirty flags and request an update.
|
|
*
|
|
* Another reason that we don't currently want to call
|
|
* PresShell::FrameNeedsReflow is because passing eRestyle to it to get it to
|
|
* mark descendants dirty would cause it to descend through
|
|
* nsSVGForeignObjectFrame frames to mark their children dirty, but we want to
|
|
* handle nsSVGForeignObjectFrame specially. It would also do unnecessary work
|
|
* descending into NS_FRAME_IS_NONDISPLAY frames.
|
|
*/
|
|
static void ScheduleReflowSVG(nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Returns true if the frame or any of its children need ReflowSVG
|
|
* to be called on them.
|
|
*/
|
|
static bool NeedsReflowSVG(nsIFrame *aFrame);
|
|
|
|
/*
|
|
* Update the filter invalidation region for ancestor frames, if relevant.
|
|
*/
|
|
static void NotifyAncestorsOfFilterRegionChange(nsIFrame *aFrame);
|
|
|
|
/* Computes the input length in terms of object space coordinates.
|
|
Input: rect - bounding box
|
|
length - length to be converted
|
|
*/
|
|
static float ObjectSpace(const gfxRect &aRect, const nsSVGLength2 *aLength);
|
|
|
|
/* Computes the input length in terms of user space coordinates.
|
|
Input: content - object to be used for determining user space
|
|
Input: length - length to be converted
|
|
*/
|
|
static float UserSpace(nsSVGElement *aSVGElement, const nsSVGLength2 *aLength);
|
|
|
|
/* Computes the input length in terms of user space coordinates.
|
|
Input: aFrame - object to be used for determining user space
|
|
length - length to be converted
|
|
*/
|
|
static float UserSpace(nsIFrame *aFrame, const nsSVGLength2 *aLength);
|
|
|
|
/* Find the outermost SVG frame of the passed frame */
|
|
static nsSVGOuterSVGFrame *
|
|
GetOuterSVGFrame(nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Get the covered region for a frame. Return null if it's not an SVG frame.
|
|
* @param aRect gets a rectangle in app units
|
|
* @return the outer SVG frame which aRect is relative to
|
|
*/
|
|
static nsIFrame*
|
|
GetOuterSVGFrameAndCoveredRegion(nsIFrame* aFrame, nsRect* aRect);
|
|
|
|
/* Paint SVG frame with SVG effects - aDirtyRect is the area being
|
|
* redrawn, in device pixel coordinates relative to the outer svg */
|
|
static void
|
|
PaintFrameWithEffects(nsRenderingContext *aContext,
|
|
const nsIntRect *aDirtyRect,
|
|
nsIFrame *aFrame,
|
|
nsIFrame* aTransformRoot = nullptr);
|
|
|
|
/* Hit testing - check if point hits the clipPath of indicated
|
|
* frame. Returns true if no clipPath set. */
|
|
static bool
|
|
HitTestClip(nsIFrame *aFrame, const nsPoint &aPoint);
|
|
|
|
/* Hit testing - check if point hits any children of frame. */
|
|
|
|
static nsIFrame *
|
|
HitTestChildren(nsIFrame *aFrame, const nsPoint &aPoint);
|
|
|
|
/*
|
|
* Returns the CanvasTM of the indicated frame, whether it's a
|
|
* child SVG frame, container SVG frame, or a regular frame.
|
|
* For regular frames, we just return an identity matrix.
|
|
*/
|
|
static gfxMatrix GetCanvasTM(nsIFrame* aFrame, uint32_t aFor,
|
|
nsIFrame* aTransformRoot = nullptr);
|
|
|
|
/**
|
|
* Returns the transform from aFrame's user space to canvas space. Only call
|
|
* with SVG frames. This is like GetCanvasTM, except that it only includes
|
|
* the transforms from aFrame's user space (i.e. the coordinate context
|
|
* established by its 'transform' attribute, or else the coordinate context
|
|
* that its _parent_ establishes for its children) to outer-<svg> device
|
|
* space. Specifically, it does not include any other transforms introduced
|
|
* by the frame such as x/y offsets and viewBox attributes.
|
|
*/
|
|
static gfxMatrix GetUserToCanvasTM(nsIFrame* aFrame, uint32_t aFor);
|
|
|
|
/**
|
|
* Notify the descendants of aFrame of a change to one of their ancestors
|
|
* that might affect them.
|
|
*/
|
|
static void
|
|
NotifyChildrenOfSVGChange(nsIFrame *aFrame, uint32_t aFlags);
|
|
|
|
/*
|
|
* Get frame's covered region by walking the children and doing union.
|
|
*/
|
|
static nsRect
|
|
GetCoveredRegion(const nsFrameList &aFrames);
|
|
|
|
// Converts aPoint from an app unit point in outer-<svg> content rect space
|
|
// to an app unit point in a frame's SVG userspace.
|
|
// This is a temporary helper we should no longer need after bug 614732 is
|
|
// fixed.
|
|
static nsPoint
|
|
TransformOuterSVGPointToChildFrame(nsPoint aPoint,
|
|
const gfxMatrix& aFrameToCanvasTM,
|
|
nsPresContext* aPresContext);
|
|
|
|
static nsRect
|
|
TransformFrameRectToOuterSVG(const nsRect& aRect,
|
|
const gfxMatrix& aMatrix,
|
|
nsPresContext* aPresContext);
|
|
|
|
/*
|
|
* Convert a surface size to an integer for use by thebes
|
|
* possibly making it smaller in the process so the surface does not
|
|
* use excessive memory.
|
|
*
|
|
* @param aSize the desired surface size
|
|
* @param aResultOverflows true if the desired surface size is too big
|
|
* @return the surface size to use
|
|
*/
|
|
static gfxIntSize ConvertToSurfaceSize(const gfxSize& aSize,
|
|
bool *aResultOverflows);
|
|
|
|
/*
|
|
* Hit test a given rectangle/matrix.
|
|
*/
|
|
static bool
|
|
HitTestRect(const mozilla::gfx::Matrix &aMatrix,
|
|
float aRX, float aRY, float aRWidth, float aRHeight,
|
|
float aX, float aY);
|
|
|
|
|
|
/**
|
|
* Get the clip rect for the given frame, taking into account the CSS 'clip'
|
|
* property. See:
|
|
* http://www.w3.org/TR/SVG11/masking.html#OverflowAndClipProperties
|
|
* The arguments for aX, aY, aWidth and aHeight should be the dimensions of
|
|
* the viewport established by aFrame.
|
|
*/
|
|
static gfxRect
|
|
GetClipRectForFrame(nsIFrame *aFrame,
|
|
float aX, float aY, float aWidth, float aHeight);
|
|
|
|
static void SetClipRect(gfxContext *aContext,
|
|
const gfxMatrix &aCTM,
|
|
const gfxRect &aRect);
|
|
|
|
/* Using group opacity instead of fill or stroke opacity on a
|
|
* geometry object seems to be a common authoring mistake. If we're
|
|
* not applying filters and not both stroking and filling, we can
|
|
* generate the same result without going through the overhead of a
|
|
* push/pop group. */
|
|
static bool
|
|
CanOptimizeOpacity(nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Take the CTM to userspace for an element, and adjust it to a CTM to its
|
|
* object bounding box space if aUnits is SVG_UNIT_TYPE_OBJECTBOUNDINGBOX.
|
|
* (I.e. so that [0,0] is at the top left of its bbox, and [1,1] is at the
|
|
* bottom right of its bbox).
|
|
*
|
|
* If the bbox is empty, this will return a singular matrix.
|
|
*/
|
|
static gfxMatrix
|
|
AdjustMatrixForUnits(const gfxMatrix &aMatrix,
|
|
nsSVGEnum *aUnits,
|
|
nsIFrame *aFrame);
|
|
|
|
enum BBoxFlags {
|
|
eBBoxIncludeFill = 1 << 0,
|
|
eBBoxIncludeFillGeometry = 1 << 1,
|
|
eBBoxIncludeStroke = 1 << 2,
|
|
eBBoxIncludeStrokeGeometry = 1 << 3,
|
|
eBBoxIncludeMarkers = 1 << 4
|
|
};
|
|
/**
|
|
* Get the SVG bbox (the SVG spec's simplified idea of bounds) of aFrame in
|
|
* aFrame's userspace.
|
|
*/
|
|
static gfxRect GetBBox(nsIFrame *aFrame,
|
|
uint32_t aFlags = eBBoxIncludeFillGeometry);
|
|
|
|
/*
|
|
* "User space" is the space that the frame's BBox (as calculated by
|
|
* nsSVGUtils::GetBBox) is in. "Frame space" is the space that has its origin
|
|
* at the top left of the union of the frame's border-box rects over all
|
|
* continuations.
|
|
* This function returns the offset one needs to add to something in frame
|
|
* space in order to get its coordinates in user space.
|
|
*/
|
|
static gfxPoint FrameSpaceInCSSPxToUserSpaceOffset(nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Convert a userSpaceOnUse/objectBoundingBoxUnits rectangle that's specified
|
|
* using four nsSVGLength2 values into a user unit rectangle in user space.
|
|
*
|
|
* @param aXYWH pointer to 4 consecutive nsSVGLength2 objects containing
|
|
* the x, y, width and height values in that order
|
|
* @param aBBox the bounding box of the object the rect is relative to;
|
|
* may be null if aUnits is not SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
|
|
* @param aFrame the object in which to interpret user-space units;
|
|
* may be null if aUnits is SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
|
|
*/
|
|
static gfxRect
|
|
GetRelativeRect(uint16_t aUnits, const nsSVGLength2 *aXYWH,
|
|
const gfxRect &aBBox, nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Find the first frame, starting with aStartFrame and going up its
|
|
* parent chain, that is not an svgAFrame.
|
|
*/
|
|
static nsIFrame* GetFirstNonAAncestorFrame(nsIFrame* aStartFrame);
|
|
|
|
static bool OuterSVGIsCallingReflowSVG(nsIFrame *aFrame);
|
|
static bool AnyOuterSVGIsCallingReflowSVG(nsIFrame *aFrame);
|
|
|
|
/*
|
|
* Get any additional transforms that apply only to stroking
|
|
* e.g. non-scaling-stroke
|
|
*/
|
|
static gfxMatrix GetStrokeTransform(nsIFrame *aFrame);
|
|
|
|
/**
|
|
* Compute the maximum possible device space stroke extents of a path given
|
|
* the path's device space path extents, its stroke style and its ctm.
|
|
*
|
|
* This is a workaround for the lack of suitable cairo API for getting the
|
|
* tight device space stroke extents of a path. This basically gives us the
|
|
* tightest extents that we can guarantee fully enclose the inked stroke
|
|
* without doing the calculations for the actual tight extents. We exploit
|
|
* the fact that cairo does have an API for getting the tight device space
|
|
* fill/path extents.
|
|
*
|
|
* This should die once bug 478152 is fixed.
|
|
*/
|
|
static gfxRect PathExtentsToMaxStrokeExtents(const gfxRect& aPathExtents,
|
|
nsTextFrame* aFrame,
|
|
const gfxMatrix& aMatrix);
|
|
static gfxRect PathExtentsToMaxStrokeExtents(const gfxRect& aPathExtents,
|
|
nsSVGPathGeometryFrame* aFrame,
|
|
const gfxMatrix& aMatrix);
|
|
|
|
/**
|
|
* Convert a floating-point value to a 32-bit integer value, clamping to
|
|
* the range of valid integers.
|
|
*/
|
|
static int32_t ClampToInt(double aVal)
|
|
{
|
|
return NS_lround(std::max(double(INT32_MIN),
|
|
std::min(double(INT32_MAX), aVal)));
|
|
}
|
|
|
|
static nscolor GetFallbackOrPaintColor(gfxContext *aContext,
|
|
nsStyleContext *aStyleContext,
|
|
nsStyleSVGPaint nsStyleSVG::*aFillOrStroke);
|
|
|
|
/**
|
|
* Set up cairo context with an object pattern
|
|
*/
|
|
static bool SetupContextPaint(gfxContext *aContext,
|
|
gfxTextContextPaint *aContextPaint,
|
|
const nsStyleSVGPaint& aPaint,
|
|
float aOpacity);
|
|
|
|
/**
|
|
* Sets the current paint on the specified gfxContent to be the SVG 'fill'
|
|
* for the given frame.
|
|
*/
|
|
static bool SetupCairoFillPaint(nsIFrame* aFrame, gfxContext* aContext,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
/**
|
|
* Sets the current paint on the specified gfxContent to be the SVG 'stroke'
|
|
* for the given frame.
|
|
*/
|
|
static bool SetupCairoStrokePaint(nsIFrame* aFrame, gfxContext* aContext,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
static float GetOpacity(nsStyleSVGOpacitySource aOpacityType,
|
|
const float& aOpacity,
|
|
gfxTextContextPaint *aOuterContextPaint);
|
|
|
|
/*
|
|
* @return false if there is no stroke
|
|
*/
|
|
static bool HasStroke(nsIFrame* aFrame,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
static float GetStrokeWidth(nsIFrame* aFrame,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
/*
|
|
* Set up a cairo context for measuring the bounding box of a stroked path.
|
|
*/
|
|
static void SetupCairoStrokeBBoxGeometry(nsIFrame* aFrame,
|
|
gfxContext *aContext,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
/*
|
|
* Set up a cairo context for a stroked path (including any dashing that
|
|
* applies).
|
|
*/
|
|
static void SetupCairoStrokeGeometry(nsIFrame* aFrame, gfxContext *aContext,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
/*
|
|
* Set up a cairo context for stroking, including setting up any stroke-related
|
|
* properties such as dashing and setting the current paint on the gfxContext.
|
|
*/
|
|
static bool SetupCairoStroke(nsIFrame* aFrame, gfxContext *aContext,
|
|
gfxTextContextPaint *aContextPaint = nullptr);
|
|
|
|
/**
|
|
* This function returns a set of bit flags indicating which parts of the
|
|
* element (fill, stroke, bounds) should intercept pointer events. It takes
|
|
* into account the type of element and the value of the 'pointer-events'
|
|
* property on the element.
|
|
*/
|
|
static uint16_t GetGeometryHitTestFlags(nsIFrame* aFrame);
|
|
|
|
/**
|
|
* Render a SVG glyph.
|
|
* @param aElement the SVG glyph element to render
|
|
* @param aContext the thebes aContext to draw to
|
|
* @param aDrawMode fill or stroke or both (see DrawMode)
|
|
* @return true if rendering succeeded
|
|
*/
|
|
static bool PaintSVGGlyph(Element* aElement, gfxContext* aContext,
|
|
DrawMode aDrawMode,
|
|
gfxTextContextPaint* aContextPaint);
|
|
/**
|
|
* Get the extents of a SVG glyph.
|
|
* @param aElement the SVG glyph element
|
|
* @param aSVGToAppSpace the matrix mapping the SVG glyph space to the
|
|
* target context space
|
|
* @param aResult the result (valid when true is returned)
|
|
* @return true if calculating the extents succeeded
|
|
*/
|
|
static bool GetSVGGlyphExtents(Element* aElement,
|
|
const gfxMatrix& aSVGToAppSpace,
|
|
gfxRect* aResult);
|
|
|
|
/**
|
|
* Returns the app unit canvas bounds of a userspace rect.
|
|
*
|
|
* @param aToCanvas Transform from userspace to canvas device space.
|
|
*/
|
|
static nsRect
|
|
ToCanvasBounds(const gfxRect &aUserspaceRect,
|
|
const gfxMatrix &aToCanvas,
|
|
const nsPresContext *presContext);
|
|
};
|
|
|
|
#endif
|