wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
57e0dd68c3
gecko/layout/svg/nsSVGGlyphFrame.cpp

1994 lines
62 KiB
C++
Raw Blame History

/* -*- 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/. */
// Main header first:
#include "nsSVGGlyphFrame.h"
#include <algorithm>
// Keep others in (case-insensitive) order:
#include "DOMSVGPoint.h"
#include "gfxContext.h"
#include "gfxMatrix.h"
#include "gfxPlatform.h"
#include "mozilla/LookAndFeel.h"
#include "nsBidiPresUtils.h"
#include "nsDisplayList.h"
#include "nsError.h"
#include "nsIDOMSVGRect.h"
#include "nsRenderingContext.h"
#include "nsSVGEffects.h"
#include "nsSVGIntegrationUtils.h"
#include "nsSVGPaintServerFrame.h"
#include "nsSVGRect.h"
#include "nsSVGTextPathFrame.h"
#include "nsSVGUtils.h"
#include "nsTextFragment.h"
#include "SVGContentUtils.h"
#include "SVGLengthList.h"
using namespace mozilla;
struct CharacterPosition {
gfxPoint pos;
gfxFloat angle;
bool draw;
};
static gfxContext* MakeTmpCtx() {
return new gfxContext(gfxPlatform::GetPlatform()->ScreenReferenceSurface());
}
/**
* This is a do-it-all helper class. It supports iterating through the
* drawable character clusters of a string. For each cluster, it can set up
* a graphics context with a transform appropriate for drawing the
* character, or a transform appropriate for emitting geometry in the
* text metrics coordinate system (which differs from the drawing
* coordinate system by a scale factor of AppUnitPerCSSPixels). These
* transforms include offsets and rotations of characters along paths, and
* the mPosition of the nsSVGGlyphFrame.
*
* This helper also creates the textrun as needed. It supports detecting
* the special case when the entire textrun can be drawn or measured
* as a unit, and setting the graphics context transform up for that. It
* takes care of setting up the global transform if requested. It also
* provides direct access to the character path position data for the
* DOM APIs that need that.
*
* If an error occurs, for example, a canvas TM is not available because
* the element is in a <defs> section, then the CharacterIterator will
* behave as if the frame has no drawable characters.
*
* XXX needs RTL love
* XXX might want to make AdvanceToCharacter constant time (e.g. by
* caching advances and/or the CharacterPosition array across DOM
* API calls) to ensure that calling Get*OfChar (etc) for each character
* in the text is O(N)
*/
class CharacterIterator
{
public:
/**
* Sets up the iterator so that NextCluster will return the first drawable
* cluster.
* @param aForceGlobalTransform passed on to EnsureTextRun (see below)
*/
CharacterIterator(nsSVGGlyphFrame *aSource, bool aForceGlobalTransform);
/**
* This matrix will be applied to aContext in the SetupFor methods below,
* before any glyph translation/rotation.
*/
bool SetInitialMatrix(gfxContext *aContext) {
mInitialMatrix = aContext->CurrentMatrix();
if (mInitialMatrix.IsSingular()) {
mInError = true;
}
return !mInError;
}
/**
* Try to set up aContext so we can draw the whole textrun at once.
* This applies any global transform requested by SetInitialMatrix,
* then applies the positioning of the text. Returns false if drawing
* the whole textrun at once is impossible due to individual positioning
* and/or rotation of glyphs.
*/
bool SetupForDirectTextRunDrawing(gfxContext *aContext) {
return SetupForDirectTextRun(aContext, mDrawScale);
}
/**
* Try to set up aContext so we can measure the whole textrun at once.
* This applies any global transform requested by SetInitialMatrix,
* then applies the positioning of the text, then applies a scale
* from appunits to device pixels so drawing in appunits works.
* Returns false if drawing the whole textrun at once is impossible due
* to individual positioning and/or rotation of glyphs.
*/
bool SetupForDirectTextRunMetrics(gfxContext *aContext) {
return SetupForDirectTextRun(aContext, mMetricsScale);
}
/**
* We are scaling the glyphs up/down to the size we want so we need to
* inverse scale the outline widths of those glyphs so they are invariant
*/
void SetLineWidthAndDashesForDrawing(gfxContext *aContext) {
aContext->SetLineWidth(aContext->CurrentLineWidth() / mDrawScale);
AutoFallibleTArray<gfxFloat, 10> dashes;
gfxFloat dashOffset;
if (aContext->CurrentDash(dashes, &dashOffset)) {
for (uint32_t i = 0; i < dashes.Length(); i++) {
dashes[i] /= mDrawScale;
}
aContext->SetDash(dashes.Elements(), dashes.Length(), dashOffset / mDrawScale);
}
}
/**
* Returns the index of the next cluster in the string that should be drawn,
* or InvalidCluster() (i.e. uint32_t(-1)) if there is no such cluster.
*/
uint32_t NextCluster();
/**
* Returns the length of the current cluster (usually 1, unless there
* are combining marks)
*/
uint32_t ClusterLength();
/**
* Repeated calls NextCluster until it returns aIndex (i.e. aIndex is the
* current drawable character). Returns false if that never happens
* (because aIndex is before or equal to the current character, or
* out of bounds, or not drawable).
*/
bool AdvanceToCharacter(uint32_t aIndex);
/**
* Resets the iterator to the beginning of the string.
*/
void Reset() {
// There are two ways mInError can be set
// a) If there was a problem creating the iterator (mCurrentChar == -1)
// b) If we ran off the end of the string (mCurrentChar != -1)
// We can only reset the mInError flag in case b)
if (mCurrentChar != InvalidCluster()) {
mCurrentChar = InvalidCluster();
mInError = false;
}
}
/**
* Set up aContext for glyph drawing. This applies any global transform
* requested by SetInitialMatrix, then applies any positioning and
* rotation for the current character.
*/
void SetupForDrawing(gfxContext *aContext) {
return SetupFor(aContext, mDrawScale);
}
/**
* Set up aContext for glyph measuring. This applies any global transform
* requested by SetInitialMatrix, then applies any positioning and
* rotation for the current character, then applies a scale from appunits
* to device pixels so that drawing in appunits sizes works.
*/
void SetupForMetrics(gfxContext *aContext) {
return SetupFor(aContext, mMetricsScale);
}
/**
* Get the raw position data for the current character.
*/
CharacterPosition GetPositionData();
/**
* "Invalid" cluster index returned to indicate error state
*/
uint32_t InvalidCluster() {
return uint32_t(-1);
}
private:
bool SetupForDirectTextRun(gfxContext *aContext, float aScale);
void SetupFor(gfxContext *aContext, float aScale);
nsSVGGlyphFrame *mSource;
nsAutoTArray<CharacterPosition,80> mPositions;
gfxMatrix mInitialMatrix;
// Textrun advance width from start to mCurrentChar, in appunits
gfxFloat mCurrentAdvance;
uint32_t mCurrentChar;
float mDrawScale;
float mMetricsScale;
bool mInError;
};
class nsDisplaySVGGlyphs : public nsDisplayItem {
public:
nsDisplaySVGGlyphs(nsDisplayListBuilder* aBuilder,
nsSVGGlyphFrame* aFrame)
: nsDisplayItem(aBuilder, aFrame)
{
MOZ_COUNT_CTOR(nsDisplaySVGGlyphs);
NS_ABORT_IF_FALSE(aFrame, "Must have a frame!");
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplaySVGGlyphs() {
MOZ_COUNT_DTOR(nsDisplaySVGGlyphs);
}
#endif
NS_DISPLAY_DECL_NAME("nsDisplaySVGGlyphs", TYPE_SVG_GLYPHS)
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames);
virtual void Paint(nsDisplayListBuilder* aBuilder,
nsRenderingContext* aCtx);
};
void
nsDisplaySVGGlyphs::HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames)
{
nsSVGGlyphFrame *frame = static_cast<nsSVGGlyphFrame*>(mFrame);
nsPoint pointRelativeToReferenceFrame = aRect.Center();
// ToReferenceFrame() includes frame->GetPosition(), our user space position.
nsPoint userSpacePt = pointRelativeToReferenceFrame -
(ToReferenceFrame() - frame->GetPosition());
if (frame->GetFrameForPoint(userSpacePt)) {
aOutFrames->AppendElement(frame);
}
}
void
nsDisplaySVGGlyphs::Paint(nsDisplayListBuilder* aBuilder,
nsRenderingContext* aCtx)
{
// ToReferenceFrame includes our mRect offset, but painting takes
// account of that too. To avoid double counting, we subtract that
// here.
nsPoint offset = ToReferenceFrame() - mFrame->GetPosition();
aCtx->PushState();
aCtx->Translate(offset);
static_cast<nsSVGGlyphFrame*>(mFrame)->PaintSVG(aCtx, nullptr);
aCtx->PopState();
}
//----------------------------------------------------------------------
// Implementation
nsIFrame*
NS_NewSVGGlyphFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsSVGGlyphFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGGlyphFrame)
//----------------------------------------------------------------------
// nsQueryFrame methods
NS_QUERYFRAME_HEAD(nsSVGGlyphFrame)
NS_QUERYFRAME_ENTRY(nsISVGGlyphFragmentNode)
NS_QUERYFRAME_ENTRY(nsISVGChildFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGGlyphFrameBase)
//----------------------------------------------------------------------
// nsIFrame methods
NS_IMETHODIMP
nsSVGGlyphFrame::CharacterDataChanged(CharacterDataChangeInfo* aInfo)
{
// NotifyGlyphMetricsChange takes care of calling
// nsSVGUtils::InvalidateAndScheduleBoundsUpdate on the appropriate frames.
NotifyGlyphMetricsChange();
ClearTextRun();
if (IsTextEmpty()) {
// The one time that NotifyGlyphMetricsChange fails to call
// nsSVGUtils::InvalidateAndScheduleBoundsUpdate properly is when all our
// text is gone, since it skips empty frames. So we have to invalidate
// ourself.
nsSVGUtils::InvalidateBounds(this);
}
return NS_OK;
}
// Usable font size range in devpixels / user-units
#define CLAMP_MIN_SIZE 8
#define CLAMP_MAX_SIZE 200
#define PRECISE_SIZE 200
/* virtual */ void
nsSVGGlyphFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
{
nsSVGGlyphFrameBase::DidSetStyleContext(aOldStyleContext);
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
ClearTextRun();
NotifyGlyphMetricsChange();
}
}
NS_IMETHODIMP
nsSVGGlyphFrame::IsSelectable(bool* aIsSelectable,
uint8_t* aSelectStyle) const
{
nsresult rv = nsSVGGlyphFrameBase::IsSelectable(aIsSelectable, aSelectStyle);
#if defined(DEBUG) && defined(SVG_DEBUG_SELECTION)
printf("nsSVGGlyphFrame(%p)::IsSelectable()=(%d,%d)\n", this, *aIsSelectable, aSelectStyle);
#endif
return rv;
}
NS_IMETHODIMP
nsSVGGlyphFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
#ifdef DEBUG
NS_ASSERTION(aParent, "null parent");
nsIFrame* ancestorFrame = nsSVGUtils::GetFirstNonAAncestorFrame(aParent);
NS_ASSERTION(ancestorFrame, "Must have ancestor");
nsSVGTextContainerFrame *metrics = do_QueryFrame(ancestorFrame);
NS_ASSERTION(metrics,
"trying to construct an SVGGlyphFrame for an invalid container");
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
"trying to construct an SVGGlyphFrame for wrong content element");
#endif /* DEBUG */
return nsSVGGlyphFrameBase::Init(aContent, aParent, aPrevInFlow);
}
nsIAtom *
nsSVGGlyphFrame::GetType() const
{
return nsGkAtoms::svgGlyphFrame;
}
NS_IMETHODIMP
nsSVGGlyphFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
if (GetStyleFont()->mFont.size <= 0) {
return NS_OK;
}
aLists.Content()->AppendNewToTop(
new (aBuilder) nsDisplaySVGGlyphs(aBuilder, this));
return NS_OK;
}
//----------------------------------------------------------------------
// nsISVGChildFrame methods
NS_IMETHODIMP
nsSVGGlyphFrame::PaintSVG(nsRenderingContext *aContext,
const nsIntRect *aDirtyRect)
{
if (!GetStyleVisibility()->IsVisible())
return NS_OK;
if (GetStyleFont()->mFont.size <= 0) {
// Don't even try to paint, or cairo will go into an error state.
return NS_OK;
}
AutoCanvasTMForMarker autoCanvasTMFor(this, FOR_PAINTING);
gfxContext *gfx = aContext->ThebesContext();
uint16_t renderMode = SVGAutoRenderState::GetRenderMode(aContext);
switch (GetStyleSVG()->mTextRendering) {
case NS_STYLE_TEXT_RENDERING_OPTIMIZESPEED:
gfx->SetAntialiasMode(gfxContext::MODE_ALIASED);
break;
default:
gfx->SetAntialiasMode(gfxContext::MODE_COVERAGE);
break;
}
if (renderMode != SVGAutoRenderState::NORMAL) {
NS_ABORT_IF_FALSE(renderMode == SVGAutoRenderState::CLIP ||
renderMode == SVGAutoRenderState::CLIP_MASK,
"Unknown render mode");
gfxContextMatrixAutoSaveRestore matrixAutoSaveRestore(gfx);
SetupGlobalTransform(gfx, FOR_PAINTING);
CharacterIterator iter(this, true);
if (!iter.SetInitialMatrix(gfx)) {
return NS_OK;
}
if (GetClipRule() == NS_STYLE_FILL_RULE_EVENODD)
gfx->SetFillRule(gfxContext::FILL_RULE_EVEN_ODD);
else
gfx->SetFillRule(gfxContext::FILL_RULE_WINDING);
if (renderMode == SVGAutoRenderState::CLIP_MASK) {
gfx->SetColor(gfxRGBA(1.0f, 1.0f, 1.0f, 1.0f));
DrawCharacters(&iter, gfx, gfxFont::GLYPH_FILL);
} else {
DrawCharacters(&iter, gfx, gfxFont::GLYPH_PATH);
}
return NS_OK;
}
// We are adding patterns or gradients to the context. Save
// it so we don't leak them into the next object we draw
gfx->Save();
SetupGlobalTransform(gfx, FOR_PAINTING);
CharacterIterator iter(this, true);
if (!iter.SetInitialMatrix(gfx)) {
gfx->Restore();
return NS_OK;
}
gfxTextObjectPaint *outerObjectPaint =
(gfxTextObjectPaint*)aContext->GetUserData(&gfxTextObjectPaint::sUserDataKey);
nsAutoPtr<gfxTextObjectPaint> objectPaint;
DrawMode drawMode = SetupCairoState(gfx, outerObjectPaint, getter_Transfers(objectPaint));
if (drawMode) {
DrawCharacters(&iter, gfx, drawMode, objectPaint);
}
gfx->Restore();
return NS_OK;
}
NS_IMETHODIMP_(nsIFrame*)
nsSVGGlyphFrame::GetFrameForPoint(const nsPoint &aPoint)
{
uint16_t hitTestFlags = GetHitTestFlags();
if (!hitTestFlags) {
return nullptr;
}
AutoCanvasTMForMarker autoCanvasTMFor(this, FOR_HIT_TESTING);
nsRefPtr<gfxContext> tmpCtx = MakeTmpCtx();
SetupGlobalTransform(tmpCtx, FOR_HIT_TESTING);
CharacterIterator iter(this, true);
if (!iter.SetInitialMatrix(tmpCtx)) {
return nullptr;
}
// The SVG 1.1 spec says that text is hit tested against the character cells
// of the text, not the fill and stroke. See the section starting "For text
// elements..." here:
//
// http://www.w3.org/TR/SVG11/interact.html#PointerEventsProperty
//
// Currently we just test the character cells if GetHitTestFlags says we're
// supposed to be testing either the fill OR the stroke:
uint32_t i;
while ((i = iter.NextCluster()) != iter.InvalidCluster()) {
gfxTextRun::Metrics metrics =
mTextRun->MeasureText(i, iter.ClusterLength(),
gfxFont::LOOSE_INK_EXTENTS, nullptr, nullptr);
iter.SetupForMetrics(tmpCtx);
tmpCtx->Rectangle(metrics.mBoundingBox);
}
gfxPoint userSpacePoint =
tmpCtx->DeviceToUser(gfxPoint(PresContext()->AppUnitsToGfxUnits(aPoint.x),
PresContext()->AppUnitsToGfxUnits(aPoint.y)));
bool isHit = false;
if (hitTestFlags & SVG_HIT_TEST_FILL || hitTestFlags & SVG_HIT_TEST_STROKE) {
isHit = tmpCtx->PointInFill(userSpacePoint);
}
// If isHit is false, we may also want to fill and stroke the text to check
// whether the pointer is over an area of fill or stroke that lies outside
// the character cells. (With a thick stroke, or with fonts like Zapfino, such
// areas may be very significant.) This is what Opera appears to do, but
// currently we do not.
if (isHit && nsSVGUtils::HitTestClip(this, aPoint))
return this;
return nullptr;
}
NS_IMETHODIMP_(nsRect)
nsSVGGlyphFrame::GetCoveredRegion()
{
return nsSVGUtils::TransformFrameRectToOuterSVG(
mRect, GetCanvasTM(FOR_OUTERSVG_TM), PresContext());
}
void
nsSVGGlyphFrame::ReflowSVG()
{
NS_ASSERTION(nsSVGUtils::OuterSVGIsCallingReflowSVG(this),
"This call is probably a wasteful mistake");
NS_ABORT_IF_FALSE(!(GetStateBits() & NS_STATE_SVG_NONDISPLAY_CHILD),
"ReflowSVG mechanism not designed for this");
mRect.SetEmpty();
uint32_t flags = nsSVGUtils::eBBoxIncludeFill |
nsSVGUtils::eBBoxIncludeStroke |
nsSVGUtils::eBBoxIncludeMarkers;
// Our "visual" overflow rect needs to be valid for building display lists
// for hit testing, which means that for certain values of 'pointer-events'
// it needs to include the geometry of the fill or stroke even when the fill/
// stroke don't actually render (e.g. when stroke="none" or
// stroke-opacity="0"). GetHitTestFlags() accounts for 'pointer-events'.
uint16_t hitTestFlags = GetHitTestFlags();
if ((hitTestFlags & SVG_HIT_TEST_FILL)) {
flags |= nsSVGUtils::eBBoxIncludeFillGeometry;
}
if ((hitTestFlags & SVG_HIT_TEST_STROKE)) {
flags |= nsSVGUtils::eBBoxIncludeStrokeGeometry;
}
gfxRect extent = GetBBoxContribution(gfxMatrix(), flags);
if (!extent.IsEmpty()) {
mRect = nsLayoutUtils::RoundGfxRectToAppRect(extent,
PresContext()->AppUnitsPerCSSPixel());
}
nsRect overflow = nsRect(nsPoint(0,0), mRect.Size());
nsOverflowAreas overflowAreas(overflow, overflow);
FinishAndStoreOverflow(overflowAreas, mRect.Size());
mState &= ~(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
NS_FRAME_HAS_DIRTY_CHILDREN);
// Invalidate, but only if this is not our first reflow (since if it is our
// first reflow then we haven't had our first paint yet).
if (!(GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
InvalidateFrame();
}
}
void
nsSVGGlyphFrame::NotifySVGChanged(uint32_t aFlags)
{
NS_ABORT_IF_FALSE(aFlags & (TRANSFORM_CHANGED | COORD_CONTEXT_CHANGED),
"Invalidation logic may need adjusting");
// Ancestor changes can't affect how we render from the perspective of
// any rendering observers that we may have, so we don't need to
// invalidate them. We also don't need to invalidate ourself, since our
// changed ancestor will have invalidated its entire area, which includes
// our area.
// XXXjwatt: seems to me that our ancestor's change could change our glyph
// metrics, in which case we should call NotifyGlyphMetricsChange instead.
nsSVGUtils::ScheduleReflowSVG(this);
if (aFlags & TRANSFORM_CHANGED) {
ClearTextRun();
}
}
void
nsSVGGlyphFrame::AddBoundingBoxesToPath(CharacterIterator *aIter,
gfxContext *aContext)
{
if (aIter->SetupForDirectTextRunMetrics(aContext)) {
gfxTextRun::Metrics metrics =
mTextRun->MeasureText(0, mTextRun->GetLength(),
gfxFont::LOOSE_INK_EXTENTS, nullptr, nullptr);
aContext->Rectangle(metrics.mBoundingBox);
return;
}
uint32_t i;
while ((i = aIter->NextCluster()) != aIter->InvalidCluster()) {
aIter->SetupForMetrics(aContext);
gfxTextRun::Metrics metrics =
mTextRun->MeasureText(i, aIter->ClusterLength(),
gfxFont::LOOSE_INK_EXTENTS, nullptr, nullptr);
aContext->Rectangle(metrics.mBoundingBox);
}
}
void
nsSVGGlyphFrame::DrawCharacters(CharacterIterator *aIter,
gfxContext *aContext,
DrawMode aDrawMode,
gfxTextObjectPaint *aObjectPaint)
{
if (aDrawMode & gfxFont::GLYPH_STROKE) {
aIter->SetLineWidthAndDashesForDrawing(aContext);
}
if (aIter->SetupForDirectTextRunDrawing(aContext)) {
mTextRun->Draw(aContext, gfxPoint(0, 0), aDrawMode, 0,
mTextRun->GetLength(), nullptr, nullptr, aObjectPaint);
return;
}
uint32_t i;
while ((i = aIter->NextCluster()) != aIter->InvalidCluster()) {
aIter->SetupForDrawing(aContext);
mTextRun->Draw(aContext, gfxPoint(0, 0), aDrawMode, i,
aIter->ClusterLength(), nullptr, nullptr, aObjectPaint);
}
}
SVGBBox
nsSVGGlyphFrame::GetBBoxContribution(const gfxMatrix &aToBBoxUserspace,
uint32_t aFlags)
{
SVGBBox bbox;
if (mOverrideCanvasTM) {
*mOverrideCanvasTM = aToBBoxUserspace;
} else {
mOverrideCanvasTM = new gfxMatrix(aToBBoxUserspace);
}
nsRefPtr<gfxContext> tmpCtx = MakeTmpCtx();
SetupGlobalTransform(tmpCtx, FOR_OUTERSVG_TM);
CharacterIterator iter(this, true);
if (!iter.SetInitialMatrix(tmpCtx)) {
return bbox;
}
AddBoundingBoxesToPath(&iter, tmpCtx);
tmpCtx->IdentityMatrix();
mOverrideCanvasTM = nullptr;
// Be careful when replacing the following logic to get the fill and stroke
// extents independently (instead of computing the stroke extents from the
// path extents). You may think that you can just use the stroke extents if
// there is both a fill and a stroke. In reality it's necessary to calculate
// both the fill and stroke extents, and take the union of the two. There are
// two reasons for this:
//
// # Due to stroke dashing, in certain cases the fill extents could actually
// extend outside the stroke extents.
// # If the stroke is very thin, cairo won't paint any stroke, and so the
// stroke bounds that it will return will be empty.
//
// Another thing to be aware of is that under AddBoundingBoxesToPath the
// gfxContext has SetLineWidth() called on it, so if we want to ask the
// gfxContext for *stroke* extents, we'll need to wrap the
// AddBoundingBoxesToPath() call with CurrentLineWidth()/SetLineWidth()
// calls to record and then reset the stroke width.
gfxRect pathExtents = tmpCtx->GetUserPathExtent();
// Account for fill:
if ((aFlags & nsSVGUtils::eBBoxIncludeFillGeometry) ||
((aFlags & nsSVGUtils::eBBoxIncludeFill) &&
GetStyleSVG()->mFill.mType != eStyleSVGPaintType_None)) {
bbox = pathExtents;
}
// Account for stroke:
if ((aFlags & nsSVGUtils::eBBoxIncludeStrokeGeometry) ||
((aFlags & nsSVGUtils::eBBoxIncludeStroke) &&
nsSVGUtils::HasStroke(this))) {
bbox.UnionEdges(nsSVGUtils::PathExtentsToMaxStrokeExtents(pathExtents,
this,
aToBBoxUserspace));
}
return bbox;
}
//----------------------------------------------------------------------
// nsSVGGeometryFrame methods:
gfxMatrix
nsSVGGlyphFrame::GetCanvasTM(uint32_t aFor)
{
if (mOverrideCanvasTM) {
return *mOverrideCanvasTM;
}
if (!(GetStateBits() & NS_STATE_SVG_NONDISPLAY_CHILD)) {
if ((aFor == FOR_PAINTING && NS_SVGDisplayListPaintingEnabled()) ||
(aFor == FOR_HIT_TESTING && NS_SVGDisplayListHitTestingEnabled())) {
return nsSVGIntegrationUtils::GetCSSPxToDevPxMatrix(this);
}
}
NS_ASSERTION(mParent, "null parent");
return static_cast<nsSVGContainerFrame*>(mParent)->GetCanvasTM(aFor);
}
//----------------------------------------------------------------------
// nsSVGGlyphFrame methods:
bool
nsSVGGlyphFrame::GetCharacterData(nsAString & aCharacterData)
{
nsAutoString characterData;
mContent->AppendTextTo(characterData);
if (mCompressWhitespace) {
characterData.CompressWhitespace(mTrimLeadingWhitespace,
mTrimTrailingWhitespace);
} else {
nsAString::iterator start, end;
characterData.BeginWriting(start);
characterData.EndWriting(end);
while (start != end) {
if (NS_IsAsciiWhitespace(*start))
*start = ' ';
++start;
}
}
aCharacterData = characterData;
return !characterData.IsEmpty();
}
bool
nsSVGGlyphFrame::GetCharacterPositions(nsTArray<CharacterPosition>* aCharacterPositions,
float aMetricsScale)
{
uint32_t strLength = mTextRun->GetLength();
NS_ABORT_IF_FALSE(strLength > 0, "no text");
const gfxFloat radPerDeg = M_PI / 180.0;
nsTArray<float> xList, yList;
GetEffectiveXY(strLength, xList, yList);
nsTArray<float> dxList, dyList;
GetEffectiveDxDy(strLength, dxList, dyList);
nsTArray<float> rotateList;
GetEffectiveRotate(strLength, rotateList);
gfxPoint pos = mPosition;
gfxFloat angle = 0.0;
nsSVGTextPathFrame *textPath = FindTextPathParent();
if (textPath) {
nsRefPtr<gfxFlattenedPath> data = textPath->GetFlattenedPath();
// textPath frame, but invalid target
if (!data)
return false;
if (!aCharacterPositions->SetLength(strLength))
return false;
gfxFloat pathScale = textPath->GetOffsetScale();
CharacterPosition *cp = aCharacterPositions->Elements();
gfxFloat length = data->GetLength();
for (uint32_t i = 0; i < strLength; i++) {
gfxFloat halfAdvance =
mTextRun->GetAdvanceWidth(i, 1, nullptr)*aMetricsScale / 2.0;
// use only x position for horizontal writing
if (i > 0 && i < xList.Length()) {
pos.x = xList[i];
}
pos.x += (i > 0 && i < dxList.Length()) ? dxList[i] * pathScale : 0.0;
pos.y += (i > 0 && i < dyList.Length()) ? dyList[i] * pathScale : 0.0;
if (i < rotateList.Length()) {
angle = rotateList[i] * radPerDeg;
}
// check that we're within the path boundaries
cp[i].draw = (pos.x + halfAdvance >= 0.0 &&
pos.x + halfAdvance <= length);
if (cp[i].draw) {
// add y (normal)
// add rotation
// move point back along tangent
gfxPoint pt = data->FindPoint(gfxPoint(pos.x + halfAdvance, pos.y),
&(cp[i].angle));
cp[i].pos =
pt - gfxPoint(cos(cp[i].angle), sin(cp[i].angle)) * halfAdvance;
cp[i].angle += angle;
}
pos.x += 2 * halfAdvance;
}
return true;
}
if (xList.Length() <= 1 &&
yList.Length() <= 1 &&
dxList.Length() <= 1 &&
dyList.Length() <= 1 &&
rotateList.IsEmpty()) {
// simple text without individual positioning
return true;
}
if (!aCharacterPositions->SetLength(strLength))
return false;
CharacterPosition *cp = aCharacterPositions->Elements();
uint16_t anchor = GetTextAnchor();
for (uint32_t i = 0; i < strLength; i++) {
cp[i].draw = true;
gfxFloat advance = mTextRun->GetAdvanceWidth(i, 1, nullptr)*aMetricsScale;
if (xList.Length() > 1 && i < xList.Length()) {
pos.x = xList[i];
// apply text-anchor to character
if (anchor == NS_STYLE_TEXT_ANCHOR_MIDDLE)
pos.x -= advance/2.0;
else if (anchor == NS_STYLE_TEXT_ANCHOR_END)
pos.x -= advance;
}
if (yList.Length() > 1 && i < yList.Length()) {
pos.y = yList[i];
}
pos.x += (i > 0 && i < dxList.Length()) ? dxList[i] : 0.0;
pos.y += (i > 0 && i < dyList.Length()) ? dyList[i] : 0.0;
cp[i].pos = pos;
pos.x += advance;
if (i < rotateList.Length()) {
angle = rotateList[i] * radPerDeg;
}
cp[i].angle = angle;
}
return true;
}
uint32_t
nsSVGGlyphFrame::GetTextRunFlags(uint32_t strLength)
{
// Keep the logic here consistent with GetCharacterPositions
if (FindTextPathParent()) {
return gfxTextRunFactory::TEXT_DISABLE_OPTIONAL_LIGATURES;
}
nsTArray<float> xList, yList;
GetEffectiveXY(strLength, xList, yList);
nsTArray<float> dxList, dyList;
GetEffectiveDxDy(strLength, dxList, dyList);
nsTArray<float> rotateList;
GetEffectiveRotate(strLength, rotateList);
return (xList.Length() > 1 ||
yList.Length() > 1 ||
dxList.Length() > 1 ||
dyList.Length() > 1 ||
!rotateList.IsEmpty()) ?
gfxTextRunFactory::TEXT_DISABLE_OPTIONAL_LIGATURES : 0;
}
float
nsSVGGlyphFrame::GetSubStringAdvance(uint32_t aCharnum,
uint32_t aFragmentChars,
float aMetricsScale)
{
if (aFragmentChars == 0)
return 0.0f;
gfxFloat advance =
mTextRun->GetAdvanceWidth(aCharnum, aFragmentChars, nullptr) * aMetricsScale;
nsTArray<float> dxlist, notUsed;
GetEffectiveDxDy(mTextRun->GetLength(), dxlist, notUsed);
uint32_t dxcount = dxlist.Length();
if (dxcount) {
gfxFloat pathScale = 1.0;
nsSVGTextPathFrame *textPath = FindTextPathParent();
if (textPath)
pathScale = textPath->GetOffsetScale();
if (dxcount > aFragmentChars)
dxcount = aFragmentChars;
for (uint32_t i = aCharnum; i < dxcount; i++) {
advance += dxlist[i] * pathScale;
}
}
return float(advance);
}
gfxFloat
nsSVGGlyphFrame::GetBaselineOffset(float aMetricsScale)
{
gfxTextRun::Metrics metrics =
mTextRun->MeasureText(0, mTextRun->GetLength(),
gfxFont::LOOSE_INK_EXTENTS, nullptr, nullptr);
uint16_t dominantBaseline;
for (nsIFrame *frame = GetParent(); frame; frame = frame->GetParent()) {
dominantBaseline = frame->GetStyleSVGReset()->mDominantBaseline;
if (dominantBaseline != NS_STYLE_DOMINANT_BASELINE_AUTO ||
frame->GetType() == nsGkAtoms::svgTextFrame) {
break;
}
}
gfxFloat baselineAppUnits;
switch (dominantBaseline) {
case NS_STYLE_DOMINANT_BASELINE_HANGING:
// not really right, but the best we can do with the information provided
// FALLTHROUGH
case NS_STYLE_DOMINANT_BASELINE_TEXT_BEFORE_EDGE:
baselineAppUnits = -metrics.mAscent;
break;
case NS_STYLE_DOMINANT_BASELINE_TEXT_AFTER_EDGE:
case NS_STYLE_DOMINANT_BASELINE_IDEOGRAPHIC:
baselineAppUnits = metrics.mDescent;
break;
case NS_STYLE_DOMINANT_BASELINE_CENTRAL:
case NS_STYLE_DOMINANT_BASELINE_MIDDLE:
baselineAppUnits = -(metrics.mAscent - metrics.mDescent) / 2.0;
break;
case NS_STYLE_DOMINANT_BASELINE_AUTO:
case NS_STYLE_DOMINANT_BASELINE_ALPHABETIC:
return 0.0;
default:
NS_WARNING("We don't know about this type of dominant-baseline");
return 0.0;
}
return baselineAppUnits * aMetricsScale;
}
DrawMode
nsSVGGlyphFrame::SetupCairoState(gfxContext *aContext,
gfxTextObjectPaint *aOuterObjectPaint,
gfxTextObjectPaint **aThisObjectPaint)
{
DrawMode toDraw = DrawMode(0);
SVGTextObjectPaint *thisObjectPaint = new SVGTextObjectPaint();
if (SetupCairoStroke(aContext, aOuterObjectPaint, thisObjectPaint)) {
toDraw = DrawMode(toDraw | gfxFont::GLYPH_STROKE);
}
if (SetupCairoFill(aContext, aOuterObjectPaint, thisObjectPaint)) {
toDraw = DrawMode(toDraw | gfxFont::GLYPH_FILL);
}
uint32_t paintOrder = GetStyleSVG()->mPaintOrder;
while (paintOrder) {
uint32_t component =
paintOrder & ((1 << NS_STYLE_PAINT_ORDER_BITWIDTH) - 1);
if (component == NS_STYLE_PAINT_ORDER_FILL) {
break;
}
if (component == NS_STYLE_PAINT_ORDER_STROKE) {
toDraw = DrawMode(toDraw | gfxFont::GLYPH_STROKE_UNDERNEATH);
break;
}
paintOrder >>= NS_STYLE_PAINT_ORDER_BITWIDTH;
}
*aThisObjectPaint = thisObjectPaint;
return toDraw;
}
bool
nsSVGGlyphFrame::SetupCairoStroke(gfxContext *aContext,
gfxTextObjectPaint *aOuterObjectPaint,
SVGTextObjectPaint *aThisObjectPaint)
{
if (!nsSVGUtils::HasStroke(this, aOuterObjectPaint)) {
return false;
}
const nsStyleSVG *style = GetStyleSVG();
nsSVGUtils::SetupCairoStrokeHitGeometry(this, aContext, aOuterObjectPaint);
float opacity = nsSVGUtils::GetOpacity(style->mStrokeOpacitySource,
style->mStrokeOpacity,
aOuterObjectPaint);
SetupInheritablePaint(aContext, opacity, aOuterObjectPaint,
aThisObjectPaint->mStrokePaint, &nsStyleSVG::mStroke,
nsSVGEffects::StrokeProperty());
aThisObjectPaint->SetStrokeOpacity(opacity);
return opacity != 0.0f;
}
bool
nsSVGGlyphFrame::SetupCairoFill(gfxContext *aContext,
gfxTextObjectPaint *aOuterObjectPaint,
SVGTextObjectPaint *aThisObjectPaint)
{
const nsStyleSVG *style = GetStyleSVG();
if (style->mFill.mType == eStyleSVGPaintType_None) {
aThisObjectPaint->SetFillOpacity(0.0f);
return false;
}
float opacity = nsSVGUtils::GetOpacity(style->mFillOpacitySource,
style->mFillOpacity,
aOuterObjectPaint);
SetupInheritablePaint(aContext, opacity, aOuterObjectPaint,
aThisObjectPaint->mFillPaint, &nsStyleSVG::mFill,
nsSVGEffects::FillProperty());
aThisObjectPaint->SetFillOpacity(opacity);
return true;
}
void
nsSVGGlyphFrame::SetupInheritablePaint(gfxContext *aContext,
float& aOpacity,
gfxTextObjectPaint *aOuterObjectPaint,
SVGTextObjectPaint::Paint& aTargetPaint,
nsStyleSVGPaint nsStyleSVG::*aFillOrStroke,
const FramePropertyDescriptor *aProperty)
{
const nsStyleSVG *style = GetStyleSVG();
nsSVGPaintServerFrame *ps =
nsSVGEffects::GetPaintServer(this, &(style->*aFillOrStroke), aProperty);
if (ps && ps->SetupPaintServer(aContext, this, aFillOrStroke, aOpacity)) {
aTargetPaint.SetPaintServer(this, aContext->CurrentMatrix(), ps);
} else if (SetupObjectPaint(aContext, aFillOrStroke, aOpacity, aOuterObjectPaint)) {
aTargetPaint.SetObjectPaint(aOuterObjectPaint, (style->*aFillOrStroke).mType);
} else {
nscolor color = nsSVGUtils::GetFallbackOrPaintColor(aContext,
GetStyleContext(),
aFillOrStroke);
aTargetPaint.SetColor(color);
nsRefPtr<gfxPattern> pattern =
new gfxPattern(gfxRGBA(NS_GET_R(color) / 255.0,
NS_GET_G(color) / 255.0,
NS_GET_B(color) / 255.0,
NS_GET_A(color) / 255.0 * aOpacity));
aContext->SetPattern(pattern);
}
}
bool
nsSVGGlyphFrame::SetupObjectPaint(gfxContext *aContext,
nsStyleSVGPaint nsStyleSVG::*aFillOrStroke,
float& aOpacity,
gfxTextObjectPaint *aOuterObjectPaint)
{
if (!aOuterObjectPaint) {
NS_WARNING("Outer object paint value used outside SVG glyph");
return false;
}
const nsStyleSVG *style = GetStyleSVG();
const nsStyleSVGPaint &paint = style->*aFillOrStroke;
if (paint.mType != eStyleSVGPaintType_ObjectFill &&
paint.mType != eStyleSVGPaintType_ObjectStroke) {
return false;
}
gfxMatrix current = aContext->CurrentMatrix();
nsRefPtr<gfxPattern> pattern =
paint.mType == eStyleSVGPaintType_ObjectFill ?
aOuterObjectPaint->GetFillPattern(aOpacity, current) :
aOuterObjectPaint->GetStrokePattern(aOpacity, current);
if (!pattern) {
return false;
}
aContext->SetPattern(pattern);
return true;
}
//----------------------------------------------------------------------
// SVGTextObjectPaint methods:
already_AddRefed<gfxPattern>
mozilla::SVGTextObjectPaint::GetFillPattern(float aOpacity,
const gfxMatrix& aCTM)
{
return mFillPaint.GetPattern(aOpacity, &nsStyleSVG::mFill, aCTM);
}
already_AddRefed<gfxPattern>
mozilla::SVGTextObjectPaint::GetStrokePattern(float aOpacity,
const gfxMatrix& aCTM)
{
return mStrokePaint.GetPattern(aOpacity, &nsStyleSVG::mStroke, aCTM);
}
already_AddRefed<gfxPattern>
mozilla::SVGTextObjectPaint::Paint::GetPattern(float aOpacity,
nsStyleSVGPaint nsStyleSVG::*aFillOrStroke,
const gfxMatrix& aCTM)
{
nsRefPtr<gfxPattern> pattern;
if (mPatternCache.Get(aOpacity, getter_AddRefs(pattern))) {
// Set the pattern matrix just in case it was messed with by a previous
// caller. We should get the same matrix each time a pattern is constructed
// so this should be fine.
pattern->SetMatrix(aCTM * mPatternMatrix);
return pattern.forget();
}
switch (mPaintType) {
case eStyleSVGPaintType_None:
pattern = new gfxPattern(gfxRGBA(0.0f, 0.0f, 0.0f, 0.0f));
mPatternMatrix = gfxMatrix();
break;
case eStyleSVGPaintType_Color:
pattern = new gfxPattern(gfxRGBA(NS_GET_R(mPaintDefinition.mColor) / 255.0,
NS_GET_G(mPaintDefinition.mColor) / 255.0,
NS_GET_B(mPaintDefinition.mColor) / 255.0,
NS_GET_A(mPaintDefinition.mColor) / 255.0 * aOpacity));
mPatternMatrix = gfxMatrix();
break;
case eStyleSVGPaintType_Server:
pattern = mPaintDefinition.mPaintServerFrame->GetPaintServerPattern(mFrame,
mContextMatrix,
aFillOrStroke,
aOpacity);
{
// m maps original-user-space to pattern space
gfxMatrix m = pattern->GetMatrix();
gfxMatrix deviceToOriginalUserSpace = mContextMatrix;
deviceToOriginalUserSpace.Invert();
// mPatternMatrix maps device space to pattern space via original user space
mPatternMatrix = deviceToOriginalUserSpace * m;
}
pattern->SetMatrix(aCTM * mPatternMatrix);
break;
case eStyleSVGPaintType_ObjectFill:
pattern = mPaintDefinition.mObjectPaint->GetFillPattern(aOpacity, aCTM);
// Don't cache this. mObjectPaint will have cached it anyway. If we
// cache it, we'll have to compute mPatternMatrix, which is annoying.
return pattern.forget();
case eStyleSVGPaintType_ObjectStroke:
pattern = mPaintDefinition.mObjectPaint->GetStrokePattern(aOpacity, aCTM);
// Don't cache this. mObjectPaint will have cached it anyway. If we
// cache it, we'll have to compute mPatternMatrix, which is annoying.
return pattern.forget();
default:
return nullptr;
}
mPatternCache.Put(aOpacity, pattern);
return pattern.forget();
}
//----------------------------------------------------------------------
// Utilities for converting from indices in the uncompressed content
// element strings to compressed frame string and back:
static int
CompressIndex(int index, const nsTextFragment*fragment)
{
int ci=0;
if (fragment->Is2b()) {
const PRUnichar *data=fragment->Get2b();
while(*data && index) {
if (dom::IsSpaceCharacter(*data)){
do {
++data;
--index;
}while(dom::IsSpaceCharacter(*data) && index);
}
else {
++data;
--index;
}
++ci;
}
}
else {
const char *data=fragment->Get1b();
while(*data && index) {
if (dom::IsSpaceCharacter(*data)){
do {
++data;
--index;
}while(dom::IsSpaceCharacter(*data) && index);
}
else {
++data;
--index;
}
++ci;
}
}
return ci;
}
nsresult
nsSVGGlyphFrame::GetHighlight(uint32_t *charnum, uint32_t *nchars,
nscolor *foreground, nscolor *background)
{
*foreground = NS_RGB(255,255,255);
*background = NS_RGB(0,0,0);
*charnum=0;
*nchars=0;
bool hasHighlight = IsSelected();
if (!hasHighlight) {
NS_ERROR("nsSVGGlyphFrame::GetHighlight() called by renderer when there is no highlight");
return NS_ERROR_FAILURE;
}
nsPresContext *presContext = PresContext();
// The selection ranges are relative to the uncompressed text in
// the content element. We'll need the text fragment:
const nsTextFragment *fragment = mContent->GetText();
NS_ASSERTION(fragment, "no text");
// get the selection details
SelectionDetails *details = nullptr;
{
nsRefPtr<nsFrameSelection> frameSelection = presContext->PresShell()->FrameSelection();
if (!frameSelection) {
NS_ERROR("no frameselection interface");
return NS_ERROR_FAILURE;
}
details = frameSelection->LookUpSelection(
mContent, 0, fragment->GetLength(), false
);
}
#if defined(DEBUG) && defined(SVG_DEBUG_SELECTION)
{
SelectionDetails *dp = details;
printf("nsSVGGlyphFrame(%p)::GetHighlight() [\n", this);
while (dp) {
printf("selection detail: %d(%d)->%d(%d) type %d\n",
dp->mStart, CompressIndex(dp->mStart, fragment),
dp->mEnd, CompressIndex(dp->mEnd, fragment),
dp->mType);
dp = dp->mNext;
}
printf("]\n");
}
#endif
if (details) {
NS_ASSERTION(details->mNext==nullptr, "can't do multiple selection ranges");
*charnum=CompressIndex(details->mStart, fragment);
*nchars=CompressIndex(details->mEnd, fragment)-*charnum;
LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectBackground,
background);
LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectForeground,
foreground);
SelectionDetails *dp = details;
while ((dp=details->mNext) != nullptr) {
delete details;
details = dp;
}
delete details;
}
return NS_OK;
}
//----------------------------------------------------------------------
// Internal methods
void
nsSVGGlyphFrame::SetGlyphPosition(gfxPoint *aPosition, bool aForceGlobalTransform)
{
float drawScale, metricsScale;
nsSVGTextPathFrame *textPath = FindTextPathParent();
// In a textPath, the 'y' attribute has no effect, so we reset 'y' here
// to use aPosition.y for dy only
if (textPath && textPath->GetFirstPrincipalChild() == this) {
aPosition->y = 0.0;
}
if (!EnsureTextRun(&drawScale, &metricsScale, aForceGlobalTransform))
return;
mPosition.MoveTo(aPosition->x, aPosition->y - GetBaselineOffset(metricsScale));
uint32_t strLength = mTextRun->GetLength();
nsTArray<float> xList, yList;
GetEffectiveXY(strLength, xList, yList);
uint32_t xCount = std::min(xList.Length(), strLength);
uint32_t yCount = std::min(yList.Length(), strLength);
// move aPosition to the last glyph position
gfxFloat x = aPosition->x;
if (xCount > 1) {
x = xList[xCount - 1];
x +=
mTextRun->GetAdvanceWidth(xCount - 1, 1, nullptr) * metricsScale;
// advance to the last glyph
if (strLength > xCount) {
x +=
mTextRun->GetAdvanceWidth(xCount, strLength - xCount, nullptr) *
metricsScale;
}
} else {
x += mTextRun->GetAdvanceWidth(0, strLength, nullptr) * metricsScale;
}
gfxFloat y = (textPath || yCount <= 1) ? aPosition->y : yList[yCount - 1];
aPosition->MoveTo(x, y);
gfxFloat pathScale = 1.0;
if (textPath)
pathScale = textPath->GetOffsetScale();
nsTArray<float> dxList, dyList;
GetEffectiveDxDy(strLength, dxList, dyList);
uint32_t dxcount = std::min(dxList.Length(), strLength);
if (dxcount > 0) {
mPosition.x += dxList[0] * pathScale;
}
for (uint32_t i = 0; i < dxcount; i++) {
aPosition->x += dxList[i] * pathScale;
}
uint32_t dycount = std::min(dyList.Length(), strLength);
if (dycount > 0) {
mPosition.y += dyList[0]* pathScale;
}
for (uint32_t i = 0; i < dycount; i++) {
aPosition->y += dyList[i] * pathScale;
}
}
nsresult
nsSVGGlyphFrame::GetStartPositionOfChar(uint32_t charnum,
nsISupports **_retval)
{
*_retval = nullptr;
CharacterIterator iter(this, false);
if (!iter.AdvanceToCharacter(charnum))
return NS_ERROR_DOM_INDEX_SIZE_ERR;
NS_ADDREF(*_retval = new DOMSVGPoint(iter.GetPositionData().pos));
return NS_OK;
}
nsresult
nsSVGGlyphFrame::GetEndPositionOfChar(uint32_t charnum,
nsISupports **_retval)
{
*_retval = nullptr;
CharacterIterator iter(this, false);
if (!iter.AdvanceToCharacter(charnum))
return NS_ERROR_DOM_INDEX_SIZE_ERR;
nsRefPtr<gfxContext> tmpCtx = MakeTmpCtx();
iter.SetupForMetrics(tmpCtx);
tmpCtx->MoveTo(gfxPoint(mTextRun->GetAdvanceWidth(charnum, 1, nullptr), 0));
tmpCtx->IdentityMatrix();
NS_ADDREF(*_retval = new DOMSVGPoint(tmpCtx->CurrentPoint()));
return NS_OK;
}
nsresult
nsSVGGlyphFrame::GetExtentOfChar(uint32_t charnum, nsIDOMSVGRect **_retval)
{
*_retval = nullptr;
CharacterIterator iter(this, false);
if (!iter.AdvanceToCharacter(0))
return NS_ERROR_DOM_INDEX_SIZE_ERR;
uint32_t start = charnum, limit = charnum + 1;
while (start > 0 && !mTextRun->IsClusterStart(start)) {
--start;
}
while (limit < mTextRun->GetLength() && !mTextRun->IsClusterStart(limit)) {
++limit;
}
if (start > 0 && !iter.AdvanceToCharacter(start))
return NS_ERROR_DOM_INDEX_SIZE_ERR;
gfxTextRun::Metrics metrics =
mTextRun->MeasureText(start, limit - start, gfxFont::LOOSE_INK_EXTENTS,
nullptr, nullptr);
nsRefPtr<gfxContext> tmpCtx = MakeTmpCtx();
iter.SetupForMetrics(tmpCtx);
tmpCtx->Rectangle(gfxRect(0, -metrics.mAscent,
metrics.mAdvanceWidth,
metrics.mAscent + metrics.mDescent));
tmpCtx->IdentityMatrix();
return NS_NewSVGRect(_retval, tmpCtx->GetUserPathExtent());
}
nsresult
nsSVGGlyphFrame::GetRotationOfChar(uint32_t charnum, float *_retval)
{
CharacterIterator iter(this, false);
if (!iter.AdvanceToCharacter(charnum))
return NS_ERROR_DOM_INDEX_SIZE_ERR;
CharacterPosition pos = iter.GetPositionData();
if (!pos.draw)
return NS_ERROR_DOM_INDEX_SIZE_ERR;
const gfxFloat radPerDeg = M_PI/180.0;
*_retval = float(pos.angle / radPerDeg);
return NS_OK;
}
float
nsSVGGlyphFrame::GetAdvance(bool aForceGlobalTransform)
{
float drawScale, metricsScale;
if (!EnsureTextRun(&drawScale, &metricsScale, aForceGlobalTransform))
return 0.0f;
return GetSubStringAdvance(0, mTextRun->GetLength(), metricsScale);
}
nsSVGTextPathFrame*
nsSVGGlyphFrame::FindTextPathParent()
{
/* check if we're the child of a textPath */
for (nsIFrame *frame = GetParent();
frame != nullptr;
frame = frame->GetParent()) {
nsIAtom* type = frame->GetType();
if (type == nsGkAtoms::svgTextPathFrame) {
return static_cast<nsSVGTextPathFrame*>(frame);
} else if (type == nsGkAtoms::svgTextFrame)
return nullptr;
}
return nullptr;
}
bool
nsSVGGlyphFrame::IsStartOfChunk()
{
// this fragment is a chunk if it has a corresponding absolute
// position adjustment in an ancestors' x or y array. (At the moment
// we don't map the full arrays, but only the first elements.)
return false;
}
void
nsSVGGlyphFrame::GetXY(SVGUserUnitList *aX, SVGUserUnitList *aY)
{
static_cast<nsSVGTextContainerFrame *>(mParent)->GetXY(aX, aY);
}
void
nsSVGGlyphFrame::SetStartIndex(uint32_t aStartIndex)
{
mStartIndex = aStartIndex;
}
void
nsSVGGlyphFrame::GetEffectiveXY(int32_t strLength, nsTArray<float> &aX, nsTArray<float> &aY)
{
nsTArray<float> x, y;
static_cast<nsSVGTextContainerFrame *>(mParent)->GetEffectiveXY(x, y);
int32_t xCount = std::max((int32_t)(x.Length() - mStartIndex), 0);
xCount = std::min(xCount, strLength);
aX.AppendElements(x.Elements() + mStartIndex, xCount);
int32_t yCount = std::max((int32_t)(y.Length() - mStartIndex), 0);
yCount = std::min(yCount, strLength);
aY.AppendElements(y.Elements() + mStartIndex, yCount);
}
void
nsSVGGlyphFrame::GetDxDy(SVGUserUnitList *aDx, SVGUserUnitList *aDy)
{
static_cast<nsSVGTextContainerFrame *>(mParent)->GetDxDy(aDx, aDy);
}
void
nsSVGGlyphFrame::GetEffectiveDxDy(int32_t strLength, nsTArray<float> &aDx, nsTArray<float> &aDy)
{
nsTArray<float> dx, dy;
static_cast<nsSVGTextContainerFrame *>(mParent)->GetEffectiveDxDy(dx, dy);
int32_t dxCount = std::max((int32_t)(dx.Length() - mStartIndex), 0);
dxCount = std::min(dxCount, strLength);
aDx.AppendElements(dx.Elements() + mStartIndex, dxCount);
int32_t dyCount = std::max((int32_t)(dy.Length() - mStartIndex), 0);
dyCount = std::min(dyCount, strLength);
aDy.AppendElements(dy.Elements() + mStartIndex, dyCount);
}
const SVGNumberList*
nsSVGGlyphFrame::GetRotate()
{
nsSVGTextContainerFrame *containerFrame;
containerFrame = static_cast<nsSVGTextContainerFrame *>(mParent);
if (containerFrame)
return containerFrame->GetRotate();
return nullptr;
}
void
nsSVGGlyphFrame::GetEffectiveRotate(int32_t strLength, nsTArray<float> &aRotate)
{
nsTArray<float> rotate;
static_cast<nsSVGTextContainerFrame *>(mParent)->GetEffectiveRotate(rotate);
int32_t rotateCount = std::max((int32_t)(rotate.Length() - mStartIndex), 0);
rotateCount = std::min(rotateCount, strLength);
if (rotateCount > 0) {
aRotate.AppendElements(rotate.Elements() + mStartIndex, rotateCount);
} else if (!rotate.IsEmpty()) {
// rotate is applied for extra characters too
aRotate.AppendElement(rotate[rotate.Length() - 1]);
}
}
uint16_t
nsSVGGlyphFrame::GetTextAnchor()
{
return GetStyleSVG()->mTextAnchor;
}
bool
nsSVGGlyphFrame::IsAbsolutelyPositioned()
{
bool hasTextPathAncestor = false;
for (nsIFrame *frame = GetParent();
frame != nullptr;
frame = frame->GetParent()) {
// at the start of a 'text' element
// at the start of each 'textPath' element
if (frame->GetType() == nsGkAtoms::svgTextPathFrame) {
hasTextPathAncestor = true;
}
if ((frame->GetType() == nsGkAtoms::svgTextFrame ||
frame->GetType() == nsGkAtoms::svgTextPathFrame) &&
frame->GetFirstPrincipalChild() == this) {
return true;
}
if (frame->GetType() == nsGkAtoms::svgTextFrame)
break;
}
// for each character within a 'text', 'tspan', 'tref' and 'altGlyph' element
// which has an x or y attribute value assigned to it explicitly
nsTArray<float> x, y;
GetEffectiveXY(GetNumberOfChars(), x, y);
// Note: the y of descendants of textPath has no effect in horizontal writing
return (!x.IsEmpty() || (!hasTextPathAncestor && !y.IsEmpty()));
}
//----------------------------------------------------------------------
// nsISVGGlyphFragmentNode interface:
uint32_t
nsSVGGlyphFrame::GetNumberOfChars()
{
if (mCompressWhitespace) {
nsAutoString text;
GetCharacterData(text);
return text.Length();
}
return mContent->TextLength();
}
float
nsSVGGlyphFrame::GetComputedTextLength()
{
return GetAdvance(false);
}
float
nsSVGGlyphFrame::GetSubStringLength(uint32_t charnum, uint32_t fragmentChars)
{
float drawScale, metricsScale;
if (!EnsureTextRun(&drawScale, &metricsScale, false))
return 0.0f;
return GetSubStringAdvance(charnum, fragmentChars, metricsScale);
}
int32_t
nsSVGGlyphFrame::GetCharNumAtPosition(nsISVGPoint *point)
{
float xPos = point->X(), yPos = point->Y();
nsRefPtr<gfxContext> tmpCtx = MakeTmpCtx();
CharacterIterator iter(this, false);
uint32_t i;
int32_t last = -1;
gfxPoint pt(xPos, yPos);
while ((i = iter.NextCluster()) != iter.InvalidCluster()) {
uint32_t limit = i + iter.ClusterLength();
gfxTextRun::Metrics metrics =
mTextRun->MeasureText(i, limit - i, gfxFont::LOOSE_INK_EXTENTS,
nullptr, nullptr);
// the SVG spec tells us to divide the width of the cluster equally among
// its chars, so we'll step through the chars, allocating a share of the
// total advance to each
int32_t current, end, step;
if (mTextRun->IsRightToLeft()) {
current = limit - 1;
end = i - 1;
step = -1;
} else {
current = i;
end = limit;
step = 1;
}
gfxFloat leftEdge = 0.0;
gfxFloat width = metrics.mAdvanceWidth / (limit - i);
while (current != end) {
iter.SetupForMetrics(tmpCtx);
tmpCtx->NewPath();
tmpCtx->Rectangle(gfxRect(leftEdge, -metrics.mAscent,
width, metrics.mAscent + metrics.mDescent));
tmpCtx->IdentityMatrix();
if (tmpCtx->PointInFill(pt)) {
// Can't return yet; if there's glyph overlap, the last character
// to be rendered wins, so we still have to check the rest...
last = current;
break; // ...but we don't need to check more slices of this cluster
}
current += step;
leftEdge += width;
}
}
return last;
}
NS_IMETHODIMP_(nsSVGGlyphFrame *)
nsSVGGlyphFrame::GetFirstGlyphFrame()
{
nsSVGGlyphFrame *frame = this;
while (frame && frame->IsTextEmpty()) {
frame = frame->GetNextGlyphFrame();
}
return frame;
}
NS_IMETHODIMP_(nsSVGGlyphFrame *)
nsSVGGlyphFrame::GetNextGlyphFrame()
{
nsIFrame* sibling = GetNextSibling();
while (sibling) {
nsISVGGlyphFragmentNode *node = do_QueryFrame(sibling);
if (node)
return node->GetFirstGlyphFrame();
sibling = sibling->GetNextSibling();
}
// no more siblings. go back up the tree.
NS_ASSERTION(GetParent(), "null parent");
nsISVGGlyphFragmentNode *node = do_QueryFrame(GetParent());
return node ? node->GetNextGlyphFrame() : nullptr;
}
bool
nsSVGGlyphFrame::EndsWithWhitespace() const
{
const nsTextFragment* text = mContent->GetText();
NS_ABORT_IF_FALSE(text->GetLength() > 0, "text expected");
return NS_IsAsciiWhitespace(text->CharAt(text->GetLength() - 1));
}
bool
nsSVGGlyphFrame::IsAllWhitespace() const
{
const nsTextFragment* text = mContent->GetText();
if (text->Is2b())
return false;
int32_t len = text->GetLength();
const char* str = text->Get1b();
for (int32_t i = 0; i < len; ++i) {
if (!NS_IsAsciiWhitespace(str[i]))
return false;
}
return true;
}
//----------------------------------------------------------------------
//
void
nsSVGGlyphFrame::NotifyGlyphMetricsChange()
{
nsSVGTextContainerFrame *containerFrame =
static_cast<nsSVGTextContainerFrame *>(mParent);
if (containerFrame)
containerFrame->NotifyGlyphMetricsChange();
}
void
nsSVGGlyphFrame::SetupGlobalTransform(gfxContext *aContext, uint32_t aFor)
{
gfxMatrix matrix = GetCanvasTM(aFor);
if (!matrix.IsSingular()) {
aContext->Multiply(matrix);
}
}
void
nsSVGGlyphFrame::ClearTextRun()
{
delete mTextRun;
mTextRun = nullptr;
}
bool
nsSVGGlyphFrame::EnsureTextRun(float *aDrawScale, float *aMetricsScale,
bool aForceGlobalTransform)
{
// Compute the size at which the text should render (excluding the CTM)
const nsStyleFont* fontData = GetStyleFont();
// Since SVG has its own scaling, we really don't want
// fonts in SVG to respond to the browser's "TextZoom"
// (Ctrl++,Ctrl+-)
nsPresContext *presContext = PresContext();
float textZoom = presContext->TextZoom();
double size =
presContext->AppUnitsToFloatCSSPixels(fontData->mSize) / textZoom;
double textRunSize;
if (mTextRun) {
textRunSize = mTextRun->GetFontGroup()->GetStyle()->size;
} else {
nsAutoString text;
if (!GetCharacterData(text))
return false;
nsAutoString visualText;
/*
* XXXsmontagu: The SVG spec says:
*
* http://www.w3.org/TR/SVG11/text.html#DirectionProperty
* "For the 'direction' property to have any effect, the 'unicode-bidi'
* property's value must be embed or bidi-override."
*
* The SVGTiny spec, on the other hand, says
*
* http://www.w3.org/TR/SVGTiny12/text.html#DirectionProperty
* "For the 'direction' property to have any effect on an element that
* does not by itself establish a new text chunk (such as the 'tspan'
* element in SVG 1.2 Tiny), the 'unicode-bidi' property's value must
* be embed or bidi-override."
*
* Note that this is different from HTML/CSS, where setting the 'dir'
* attribute on an inline element automatically sets unicode-bidi: embed
*
* Our current implementation of bidi in SVG does not distinguish between
* different text elements, but treats every text container frame as a
* new text chunk, so we always set the base direction according to the
* direction property
*
* See also XXXsmontagu comments in nsSVGTextFrame::UpdateGlyphPositioning
*/
// Get the unicodeBidi property from the parent, because it doesn't
// inherit
bool bidiOverride = !!(mParent->GetStyleTextReset()->mUnicodeBidi &
NS_STYLE_UNICODE_BIDI_OVERRIDE);
nsBidiLevel baseDirection =
GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL ?
NSBIDI_RTL : NSBIDI_LTR;
nsBidiPresUtils::CopyLogicalToVisual(text, visualText,
baseDirection, bidiOverride);
if (!visualText.IsEmpty()) {
text = visualText;
}
gfxMatrix m;
if (aForceGlobalTransform ||
!(GetStateBits() & NS_STATE_SVG_NONDISPLAY_CHILD)) {
m = GetCanvasTM(mGetCanvasTMForFlag);
if (m.IsSingular())
return false;
}
// The context scale is the ratio of the length of the transformed
// diagonal vector (1,1) to the length of the untransformed diagonal
// (which is sqrt(2)).
gfxPoint p = m.Transform(gfxPoint(1, 1)) - m.Transform(gfxPoint(0, 0));
double contextScale = SVGContentUtils::ComputeNormalizedHypotenuse(p.x, p.y);
if (GetStyleSVG()->mTextRendering ==
NS_STYLE_TEXT_RENDERING_GEOMETRICPRECISION) {
textRunSize = PRECISE_SIZE;
} else {
textRunSize = size*contextScale;
textRunSize = std::max(textRunSize, double(CLAMP_MIN_SIZE));
textRunSize = std::min(textRunSize, double(CLAMP_MAX_SIZE));
}
const nsFont& font = fontData->mFont;
bool printerFont = (presContext->Type() == nsPresContext::eContext_PrintPreview ||
presContext->Type() == nsPresContext::eContext_Print);
gfxFontStyle fontStyle(font.style, font.weight, font.stretch, textRunSize,
mStyleContext->GetStyleFont()->mLanguage,
font.sizeAdjust, font.systemFont,
printerFont,
font.languageOverride);
font.AddFontFeaturesToStyle(&fontStyle);
nsRefPtr<gfxFontGroup> fontGroup =
gfxPlatform::GetPlatform()->CreateFontGroup(font.name, &fontStyle, presContext->GetUserFontSet());
uint32_t flags = gfxTextRunFactory::TEXT_NEED_BOUNDING_BOX |
GetTextRunFlags(text.Length()) |
nsLayoutUtils::GetTextRunFlagsForStyle(GetStyleContext(), GetStyleFont(), 0);
// XXX We should use a better surface here! But then we'd have to
// change things so we can ensure we always have the "right" sort of
// surface available, by creating the textrun only at the right times
nsRefPtr<gfxContext> tmpCtx = MakeTmpCtx();
tmpCtx->SetMatrix(m);
// Use only the fonts' internal word caching here.
// We don't cache the textrun globally because we create
// a new fontgroup every time. Even if we cached fontgroups, we
// might render at very many different sizes (e.g. during zoom
// animation) and caching a textrun for each such size would be bad.
gfxTextRunFactory::Parameters params = {
tmpCtx, nullptr, nullptr, nullptr, 0, GetTextRunUnitsFactor()
};
mTextRun =
fontGroup->MakeTextRun(text.get(), text.Length(), &params, flags);
if (!mTextRun)
return false;
}
*aDrawScale = float(size/textRunSize);
*aMetricsScale = (*aDrawScale)/GetTextRunUnitsFactor();
return true;
}
//----------------------------------------------------------------------
// helper class
CharacterIterator::CharacterIterator(nsSVGGlyphFrame *aSource,
bool aForceGlobalTransform)
: mSource(aSource)
, mCurrentAdvance(0)
, mCurrentChar(uint32_t(-1))
, mInError(false)
{
if (!aSource->EnsureTextRun(&mDrawScale, &mMetricsScale,
aForceGlobalTransform) ||
!aSource->GetCharacterPositions(&mPositions, mMetricsScale)) {
mInError = true;
}
}
bool
CharacterIterator::SetupForDirectTextRun(gfxContext *aContext, float aScale)
{
if (!mPositions.IsEmpty() || mInError)
return false;
aContext->SetMatrix(mInitialMatrix);
aContext->Translate(mSource->mPosition);
aContext->Scale(aScale, aScale);
return true;
}
uint32_t
CharacterIterator::NextCluster()
{
if (mInError) {
#ifdef DEBUG
if (mCurrentChar != InvalidCluster()) {
bool pastEnd = (mCurrentChar >= mSource->mTextRun->GetLength());
NS_ABORT_IF_FALSE(pastEnd, "Past the end of CharacterIterator. Missing Reset?");
}
#endif
return InvalidCluster();
}
while (true) {
if (mCurrentChar != InvalidCluster() &&
(mPositions.IsEmpty() || mPositions[mCurrentChar].draw)) {
mCurrentAdvance +=
mSource->mTextRun->GetAdvanceWidth(mCurrentChar, 1, nullptr);
}
++mCurrentChar;
if (mCurrentChar >= mSource->mTextRun->GetLength()) {
mInError = true;
return InvalidCluster();
}
if (mSource->mTextRun->IsClusterStart(mCurrentChar) &&
(mPositions.IsEmpty() || mPositions[mCurrentChar].draw)) {
return mCurrentChar;
}
}
}
uint32_t
CharacterIterator::ClusterLength()
{
if (mInError) {
return 0;
}
uint32_t i = mCurrentChar;
while (++i < mSource->mTextRun->GetLength()) {
if (mSource->mTextRun->IsClusterStart(i)) {
break;
}
}
return i - mCurrentChar;
}
bool
CharacterIterator::AdvanceToCharacter(uint32_t aIndex)
{
while (NextCluster() != InvalidCluster()) {
if (mCurrentChar == aIndex)
return true;
}
return false;
}
void
CharacterIterator::SetupFor(gfxContext *aContext, float aScale)
{
NS_ASSERTION(!mInError, "We should not have reached here");
aContext->SetMatrix(mInitialMatrix);
if (mPositions.IsEmpty()) {
aContext->Translate(mSource->mPosition);
aContext->Scale(aScale, aScale);
aContext->Translate(gfxPoint(mCurrentAdvance, 0));
} else {
aContext->Translate(mPositions[mCurrentChar].pos);
aContext->Rotate(mPositions[mCurrentChar].angle);
aContext->Scale(aScale, aScale);
}
}
CharacterPosition
CharacterIterator::GetPositionData()
{
if (!mPositions.IsEmpty())
return mPositions[mCurrentChar];
gfxFloat advance = mCurrentAdvance * mMetricsScale;
CharacterPosition cp =
{ mSource->mPosition + gfxPoint(advance, 0), 0, true };
return cp;
}
Reference in New Issue View Git Blame Copy Permalink