2007-03-22 10:30:00 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is the Mozilla SVG project.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Crocodile Clips Ltd..
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2002
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Alex Fritze <alex.fritze@crocodile-clips.com> (original author)
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
#include "nsSVGPathGeometryFrame.h"
|
|
|
|
#include "nsSVGContainerFrame.h"
|
|
|
|
#include "nsReadableUtils.h"
|
|
|
|
#include "nsUnicharUtils.h"
|
|
|
|
#include "nsGkAtoms.h"
|
|
|
|
#include "nsSVGMarkerFrame.h"
|
|
|
|
#include "nsSVGMatrix.h"
|
|
|
|
#include "nsSVGUtils.h"
|
|
|
|
#include "nsSVGGraphicElement.h"
|
|
|
|
#include "nsSVGOuterSVGFrame.h"
|
|
|
|
#include "nsSVGRect.h"
|
|
|
|
#include "nsSVGPathGeometryElement.h"
|
|
|
|
#include "gfxContext.h"
|
|
|
|
|
|
|
|
class nsSVGMarkerProperty : public nsStubMutationObserver {
|
|
|
|
public:
|
2007-04-10 03:19:59 -07:00
|
|
|
nsSVGMarkerProperty(nsIURI *aMarkerStart,
|
|
|
|
nsIURI *aMarkerMid,
|
|
|
|
nsIURI *aMarkerEnd,
|
|
|
|
nsSVGPathGeometryFrame *aMarkedFrame);
|
|
|
|
virtual ~nsSVGMarkerProperty();
|
|
|
|
|
|
|
|
nsSVGMarkerFrame *GetMarkerStartFrame() {
|
|
|
|
return GetMarkerFrame(mObservedMarkerStart);
|
|
|
|
}
|
|
|
|
nsSVGMarkerFrame *GetMarkerMidFrame() {
|
|
|
|
return GetMarkerFrame(mObservedMarkerMid);
|
|
|
|
}
|
|
|
|
nsSVGMarkerFrame *GetMarkerEndFrame() {
|
|
|
|
return GetMarkerFrame(mObservedMarkerEnd);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
// nsISupports
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
// nsIMutationObserver
|
2007-04-27 07:37:15 -07:00
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_PARENTCHAINCHANGED
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
private:
|
2007-04-10 03:19:59 -07:00
|
|
|
nsSVGMarkerFrame *GetMarkerFrame(nsWeakPtr aObservedMarker);
|
|
|
|
already_AddRefed<nsIWeakReference>
|
|
|
|
AddMutationObserver(nsIURI *aURI, nsIContent *aContent);
|
2007-03-22 10:30:00 -07:00
|
|
|
void RemoveMutationObserver(nsWeakPtr aObservedMarker);
|
|
|
|
void DoUpdate();
|
|
|
|
|
|
|
|
nsWeakPtr mObservedMarkerStart, mObservedMarkerMid, mObservedMarkerEnd;
|
|
|
|
nsSVGPathGeometryFrame *mFrame; // frame being marked
|
|
|
|
};
|
|
|
|
|
|
|
|
NS_IMPL_ISUPPORTS1(nsSVGMarkerProperty, nsIMutationObserver)
|
|
|
|
|
2007-04-10 03:19:59 -07:00
|
|
|
nsSVGMarkerProperty::nsSVGMarkerProperty(nsIURI *aMarkerStart,
|
|
|
|
nsIURI *aMarkerMid,
|
|
|
|
nsIURI *aMarkerEnd,
|
|
|
|
nsSVGPathGeometryFrame *aMarkedFrame)
|
|
|
|
: mFrame(aMarkedFrame)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2007-04-10 03:19:59 -07:00
|
|
|
nsIContent *content = mFrame->GetContent();
|
|
|
|
|
|
|
|
mObservedMarkerStart = AddMutationObserver(aMarkerStart, content);
|
|
|
|
mObservedMarkerMid = AddMutationObserver(aMarkerMid, content);
|
|
|
|
mObservedMarkerEnd = AddMutationObserver(aMarkerEnd, content);
|
|
|
|
|
2007-04-26 01:36:16 -07:00
|
|
|
NS_ADDREF(this); // addref to allow QI - SupportsDtorFunc releases
|
2007-03-22 10:30:00 -07:00
|
|
|
mFrame->SetProperty(nsGkAtoms::marker,
|
2007-07-08 00:08:04 -07:00
|
|
|
static_cast<nsISupports*>(this),
|
2007-03-22 10:30:00 -07:00
|
|
|
nsPropertyTable::SupportsDtorFunc);
|
|
|
|
|
|
|
|
mFrame->AddStateBits(NS_STATE_SVG_HAS_MARKERS);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsSVGMarkerProperty::~nsSVGMarkerProperty()
|
|
|
|
{
|
|
|
|
RemoveMutationObserver(mObservedMarkerStart);
|
|
|
|
RemoveMutationObserver(mObservedMarkerMid);
|
|
|
|
RemoveMutationObserver(mObservedMarkerEnd);
|
|
|
|
|
|
|
|
mFrame->RemoveStateBits(NS_STATE_SVG_HAS_MARKERS);
|
|
|
|
}
|
|
|
|
|
2007-04-10 03:19:59 -07:00
|
|
|
nsSVGMarkerFrame *
|
|
|
|
nsSVGMarkerProperty::GetMarkerFrame(nsWeakPtr aObservedMarker)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2007-04-10 03:19:59 -07:00
|
|
|
nsCOMPtr<nsIContent> marker = do_QueryReferent(aObservedMarker);
|
|
|
|
if (marker) {
|
|
|
|
nsIFrame *frame =
|
2007-07-08 00:08:04 -07:00
|
|
|
static_cast<nsGenericElement*>(marker.get())->GetPrimaryFrame();
|
2007-04-10 03:19:59 -07:00
|
|
|
if (frame && frame->GetType() == nsGkAtoms::svgMarkerFrame)
|
2007-07-08 00:08:04 -07:00
|
|
|
return static_cast<nsSVGMarkerFrame*>(frame);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2007-04-10 03:19:59 -07:00
|
|
|
return nsnull;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2007-04-10 03:19:59 -07:00
|
|
|
already_AddRefed<nsIWeakReference>
|
|
|
|
nsSVGMarkerProperty::AddMutationObserver(nsIURI *aURI,
|
|
|
|
nsIContent *aContent)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2007-04-10 03:19:59 -07:00
|
|
|
if (!aURI)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
nsIContent *marker = NS_GetSVGMarkerElement(aURI, aContent);
|
|
|
|
if (marker) {
|
|
|
|
marker->AddMutationObserver(this);
|
|
|
|
return do_GetWeakReference(marker);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2007-04-10 03:19:59 -07:00
|
|
|
return nsnull;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::RemoveMutationObserver(nsWeakPtr aObservedMarker)
|
|
|
|
{
|
|
|
|
if (!aObservedMarker)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> marker = do_QueryReferent(aObservedMarker);
|
|
|
|
if (marker)
|
|
|
|
marker->RemoveMutationObserver(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::DoUpdate()
|
|
|
|
{
|
2008-04-08 05:51:19 -07:00
|
|
|
nsSVGUtils::UpdateGraphic(mFrame);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::AttributeChanged(nsIDocument *aDocument,
|
|
|
|
nsIContent *aContent,
|
|
|
|
PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom *aAttribute,
|
2007-07-12 13:05:45 -07:00
|
|
|
PRInt32 aModType,
|
|
|
|
PRUint32 aStateMask)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
DoUpdate();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::ContentAppended(nsIDocument *aDocument,
|
|
|
|
nsIContent *aContainer,
|
|
|
|
PRInt32 aNewIndexInContainer)
|
|
|
|
{
|
|
|
|
DoUpdate();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::ContentInserted(nsIDocument *aDocument,
|
|
|
|
nsIContent *aContainer,
|
|
|
|
nsIContent *aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
|
|
|
DoUpdate();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::ContentRemoved(nsIDocument *aDocument,
|
|
|
|
nsIContent *aContainer,
|
|
|
|
nsIContent *aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
|
|
|
DoUpdate();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGMarkerProperty::ParentChainChanged(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
if (aContent->IsInDoc())
|
|
|
|
return;
|
|
|
|
|
|
|
|
mFrame->DeleteProperty(nsGkAtoms::marker);
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Implementation
|
|
|
|
|
|
|
|
nsIFrame*
|
|
|
|
NS_NewSVGPathGeometryFrame(nsIPresShell* aPresShell,
|
|
|
|
nsIContent* aContent,
|
|
|
|
nsStyleContext* aContext)
|
|
|
|
{
|
|
|
|
return new (aPresShell) nsSVGPathGeometryFrame(aContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsISupports methods
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsSVGPathGeometryFrame)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISVGChildFrame)
|
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsSVGPathGeometryFrameBase)
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsIFrame methods
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGPathGeometryFrame::Destroy()
|
|
|
|
{
|
|
|
|
RemovePathProperties();
|
|
|
|
nsSVGPathGeometryFrameBase::Destroy();
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::AttributeChanged(PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
|
|
|
PRInt32 aModType)
|
|
|
|
{
|
|
|
|
if (aNameSpaceID == kNameSpaceID_None &&
|
2007-07-08 00:08:04 -07:00
|
|
|
(static_cast<nsSVGPathGeometryElement*>
|
|
|
|
(mContent)->IsDependentAttribute(aAttribute) ||
|
2007-03-22 10:30:00 -07:00
|
|
|
aAttribute == nsGkAtoms::transform))
|
2008-04-08 05:51:19 -07:00
|
|
|
nsSVGUtils::UpdateGraphic(this);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::DidSetStyleContext()
|
|
|
|
{
|
|
|
|
nsSVGPathGeometryFrameBase::DidSetStyleContext();
|
|
|
|
|
2007-12-03 08:57:34 -08:00
|
|
|
nsSVGOuterSVGFrame *outerSVGFrame = nsSVGUtils::GetOuterSVGFrame(this);
|
|
|
|
if (outerSVGFrame) {
|
|
|
|
// invalidate here while we still have the filter information
|
2008-03-19 14:27:33 -07:00
|
|
|
outerSVGFrame->InvalidateCoveredRegion(this);
|
2007-12-03 08:57:34 -08:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
RemovePathProperties();
|
|
|
|
|
|
|
|
// XXX: we'd like to use the style_hint mechanism and the
|
|
|
|
// ContentStateChanged/AttributeChanged functions for style changes
|
|
|
|
// to get slightly finer granularity, but unfortunately the
|
|
|
|
// style_hints don't map very well onto svg. Here seems to be the
|
|
|
|
// best place to deal with style changes:
|
|
|
|
|
2008-04-08 05:51:19 -07:00
|
|
|
nsSVGUtils::UpdateGraphic(this);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIAtom *
|
|
|
|
nsSVGPathGeometryFrame::GetType() const
|
|
|
|
{
|
|
|
|
return nsGkAtoms::svgPathGeometryFrame;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsISVGChildFrame methods
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::PaintSVG(nsSVGRenderState *aContext,
|
2008-08-19 07:14:01 -07:00
|
|
|
nsIntRect *aDirtyRect)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
if (!GetStyleVisibility()->IsVisible())
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
/* render */
|
|
|
|
Render(aContext);
|
|
|
|
|
2007-07-08 00:08:04 -07:00
|
|
|
if (static_cast<nsSVGPathGeometryElement*>(mContent)->IsMarkable()) {
|
2007-03-22 10:30:00 -07:00
|
|
|
nsSVGMarkerProperty *property = GetMarkerProperty();
|
|
|
|
|
|
|
|
if (property) {
|
|
|
|
float strokeWidth = GetStrokeWidth();
|
|
|
|
|
|
|
|
nsTArray<nsSVGMark> marks;
|
2007-07-08 00:08:04 -07:00
|
|
|
static_cast<nsSVGPathGeometryElement*>
|
|
|
|
(mContent)->GetMarkPoints(&marks);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
PRUint32 num = marks.Length();
|
2007-04-10 03:19:59 -07:00
|
|
|
|
|
|
|
if (num) {
|
|
|
|
nsSVGMarkerFrame *frame = property->GetMarkerStartFrame();
|
|
|
|
if (frame)
|
|
|
|
frame->PaintMark(aContext, this, &marks[0], strokeWidth);
|
|
|
|
|
|
|
|
frame = property->GetMarkerMidFrame();
|
|
|
|
if (frame) {
|
|
|
|
for (PRUint32 i = 1; i < num - 1; i++)
|
|
|
|
frame->PaintMark(aContext, this, &marks[i], strokeWidth);
|
|
|
|
}
|
|
|
|
|
|
|
|
frame = property->GetMarkerEndFrame();
|
|
|
|
if (frame)
|
|
|
|
frame->PaintMark(aContext, this, &marks[num-1], strokeWidth);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2008-08-19 07:14:01 -07:00
|
|
|
NS_IMETHODIMP_(nsIFrame*)
|
|
|
|
nsSVGPathGeometryFrame::GetFrameForPoint(const nsPoint &aPoint)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2007-12-03 21:11:49 -08:00
|
|
|
PRUint16 fillRule, mask;
|
|
|
|
// check if we're a clipPath - cheaper than IsClipChild(), and we shouldn't
|
|
|
|
// get in here for other nondisplay children
|
|
|
|
if (GetStateBits() & NS_STATE_SVG_NONDISPLAY_CHILD) {
|
|
|
|
NS_ASSERTION(IsClipChild(), "should be in clipPath but we're not");
|
|
|
|
mask = HITTEST_MASK_FILL;
|
|
|
|
fillRule = GetClipRule();
|
|
|
|
} else {
|
|
|
|
mask = GetHittestMask();
|
|
|
|
if (!mask || (!(mask & HITTEST_MASK_FORCE_TEST) &&
|
2008-08-19 07:14:01 -07:00
|
|
|
!mRect.Contains(aPoint)))
|
|
|
|
return nsnull;
|
2007-12-03 21:11:49 -08:00
|
|
|
fillRule = GetStyleSVG()->mFillRule;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
PRBool isHit = PR_FALSE;
|
|
|
|
|
|
|
|
gfxContext context(nsSVGUtils::GetThebesComputationalSurface());
|
|
|
|
|
|
|
|
GeneratePath(&context);
|
2008-08-19 07:14:01 -07:00
|
|
|
gfxPoint userSpacePoint =
|
|
|
|
context.DeviceToUser(gfxPoint(PresContext()->AppUnitsToGfxUnits(aPoint.x),
|
|
|
|
PresContext()->AppUnitsToGfxUnits(aPoint.y)));
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
if (fillRule == NS_STYLE_FILL_RULE_EVENODD)
|
|
|
|
context.SetFillRule(gfxContext::FILL_RULE_EVEN_ODD);
|
|
|
|
else
|
|
|
|
context.SetFillRule(gfxContext::FILL_RULE_WINDING);
|
|
|
|
|
|
|
|
if (mask & HITTEST_MASK_FILL)
|
2008-08-19 07:14:01 -07:00
|
|
|
isHit = context.PointInFill(userSpacePoint);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!isHit && (mask & HITTEST_MASK_STROKE)) {
|
|
|
|
SetupCairoStrokeHitGeometry(&context);
|
2008-08-19 07:14:01 -07:00
|
|
|
isHit = context.PointInStroke(userSpacePoint);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2008-08-19 07:14:01 -07:00
|
|
|
if (isHit && nsSVGUtils::HitTestClip(this, aPoint))
|
|
|
|
return this;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-08-19 07:14:01 -07:00
|
|
|
return nsnull;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP_(nsRect)
|
|
|
|
nsSVGPathGeometryFrame::GetCoveredRegion()
|
|
|
|
{
|
2007-07-08 00:08:04 -07:00
|
|
|
if (static_cast<nsSVGPathGeometryElement*>(mContent)->IsMarkable()) {
|
2007-03-22 10:30:00 -07:00
|
|
|
nsSVGMarkerProperty *property = GetMarkerProperty();
|
|
|
|
|
|
|
|
if (!property)
|
|
|
|
return mRect;
|
|
|
|
|
|
|
|
nsRect rect(mRect);
|
|
|
|
|
|
|
|
float strokeWidth = GetStrokeWidth();
|
|
|
|
|
|
|
|
nsTArray<nsSVGMark> marks;
|
2007-07-08 00:08:04 -07:00
|
|
|
static_cast<nsSVGPathGeometryElement*>(mContent)->GetMarkPoints(&marks);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
PRUint32 num = marks.Length();
|
|
|
|
|
2007-04-10 03:19:59 -07:00
|
|
|
if (num) {
|
|
|
|
nsSVGMarkerFrame *frame = property->GetMarkerStartFrame();
|
|
|
|
if (frame) {
|
|
|
|
nsRect mark = frame->RegionMark(this, &marks[0], strokeWidth);
|
2007-03-22 10:30:00 -07:00
|
|
|
rect.UnionRect(rect, mark);
|
|
|
|
}
|
|
|
|
|
2007-04-10 03:19:59 -07:00
|
|
|
frame = property->GetMarkerMidFrame();
|
|
|
|
if (frame) {
|
|
|
|
for (PRUint32 i = 1; i < num - 1; i++) {
|
|
|
|
nsRect mark = frame->RegionMark(this, &marks[i], strokeWidth);
|
|
|
|
rect.UnionRect(rect, mark);
|
|
|
|
}
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-04-10 03:19:59 -07:00
|
|
|
frame = property->GetMarkerEndFrame();
|
|
|
|
if (frame) {
|
|
|
|
nsRect mark = frame->RegionMark(this, &marks[num-1], strokeWidth);
|
|
|
|
rect.UnionRect(rect, mark);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mRect;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::UpdateCoveredRegion()
|
|
|
|
{
|
|
|
|
mRect.Empty();
|
|
|
|
|
|
|
|
gfxContext context(nsSVGUtils::GetThebesComputationalSurface());
|
|
|
|
|
|
|
|
GeneratePath(&context);
|
|
|
|
|
|
|
|
gfxRect extent;
|
|
|
|
|
|
|
|
if (HasStroke()) {
|
|
|
|
SetupCairoStrokeGeometry(&context);
|
|
|
|
extent = context.GetUserStrokeExtent();
|
|
|
|
if (!IsDegeneratePath(extent)) {
|
|
|
|
extent = context.UserToDevice(extent);
|
2008-08-19 07:14:01 -07:00
|
|
|
mRect = nsSVGUtils::ToAppPixelRect(PresContext(),extent);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
context.IdentityMatrix();
|
2008-01-27 06:55:53 -08:00
|
|
|
extent = context.GetUserPathExtent();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!IsDegeneratePath(extent)) {
|
2008-08-19 07:14:01 -07:00
|
|
|
mRect = nsSVGUtils::ToAppPixelRect(PresContext(),extent);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add in markers
|
2008-04-08 05:51:19 -07:00
|
|
|
UpdateMarkerProperty();
|
2007-03-22 10:30:00 -07:00
|
|
|
mRect = GetCoveredRegion();
|
|
|
|
|
2008-04-08 05:51:19 -07:00
|
|
|
nsSVGUtils::UpdateFilterRegion(this);
|
2007-03-22 10:30:00 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::InitialUpdate()
|
|
|
|
{
|
2007-10-19 04:07:08 -07:00
|
|
|
NS_ASSERTION(GetStateBits() & NS_FRAME_FIRST_REFLOW,
|
|
|
|
"Yikes! We've been called already! Hopefully we weren't called "
|
|
|
|
"before our nsSVGOuterSVGFrame's initial Reflow()!!!");
|
|
|
|
|
2008-04-08 05:51:19 -07:00
|
|
|
nsSVGUtils::UpdateGraphic(this);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
NS_ASSERTION(!(mState & NS_FRAME_IN_REFLOW),
|
|
|
|
"We don't actually participate in reflow");
|
|
|
|
|
|
|
|
// Do unset the various reflow bits, though.
|
|
|
|
mState &= ~(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
|
|
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2008-01-25 01:27:03 -08:00
|
|
|
void
|
|
|
|
nsSVGPathGeometryFrame::NotifySVGChanged(PRUint32 aFlags)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2008-04-08 05:51:19 -07:00
|
|
|
if (!(aFlags & SUPPRESS_INVALIDATION)) {
|
|
|
|
nsSVGUtils::UpdateGraphic(this);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::NotifyRedrawSuspended()
|
|
|
|
{
|
|
|
|
// XXX should we cache the fact that redraw is suspended?
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::NotifyRedrawUnsuspended()
|
|
|
|
{
|
|
|
|
if (GetStateBits() & NS_STATE_SVG_DIRTY)
|
2008-04-08 05:51:19 -07:00
|
|
|
nsSVGUtils::UpdateGraphic(this);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::SetMatrixPropagation(PRBool aPropagate)
|
|
|
|
{
|
|
|
|
mPropagateTransform = aPropagate;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::SetOverrideCTM(nsIDOMSVGMatrix *aCTM)
|
|
|
|
{
|
|
|
|
mOverrideCTM = aCTM;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-08-30 11:45:06 -07:00
|
|
|
already_AddRefed<nsIDOMSVGMatrix>
|
|
|
|
nsSVGPathGeometryFrame::GetOverrideCTM()
|
|
|
|
{
|
|
|
|
nsIDOMSVGMatrix *matrix = mOverrideCTM.get();
|
|
|
|
NS_IF_ADDREF(matrix);
|
|
|
|
return matrix;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::GetBBox(nsIDOMSVGRect **_retval)
|
|
|
|
{
|
|
|
|
gfxContext context(nsSVGUtils::GetThebesComputationalSurface());
|
|
|
|
|
|
|
|
GeneratePath(&context);
|
|
|
|
context.IdentityMatrix();
|
|
|
|
|
2008-01-27 06:55:53 -08:00
|
|
|
return NS_NewSVGRect(_retval, context.GetUserPathExtent());
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsSVGGeometryFrame methods:
|
|
|
|
|
|
|
|
/* readonly attribute nsIDOMSVGMatrix canvasTM; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsSVGPathGeometryFrame::GetCanvasTM(nsIDOMSVGMatrix * *aCTM)
|
|
|
|
{
|
|
|
|
*aCTM = nsnull;
|
|
|
|
|
|
|
|
if (!mPropagateTransform) {
|
|
|
|
if (mOverrideCTM) {
|
|
|
|
*aCTM = mOverrideCTM;
|
|
|
|
NS_ADDREF(*aCTM);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NewSVGMatrix(aCTM);
|
|
|
|
}
|
|
|
|
|
2007-07-08 00:08:04 -07:00
|
|
|
nsSVGContainerFrame *containerFrame = static_cast<nsSVGContainerFrame*>
|
|
|
|
(mParent);
|
2007-03-22 10:30:00 -07:00
|
|
|
nsCOMPtr<nsIDOMSVGMatrix> parentTM = containerFrame->GetCanvasTM();
|
|
|
|
NS_ASSERTION(parentTM, "null TM");
|
|
|
|
|
|
|
|
// append our local transformations if we have any:
|
|
|
|
nsSVGGraphicElement *element =
|
2007-07-08 00:08:04 -07:00
|
|
|
static_cast<nsSVGGraphicElement*>(mContent);
|
2007-03-22 10:30:00 -07:00
|
|
|
nsCOMPtr<nsIDOMSVGMatrix> localTM = element->GetLocalTransformMatrix();
|
|
|
|
|
|
|
|
if (localTM)
|
|
|
|
return parentTM->Multiply(localTM, aCTM);
|
|
|
|
|
|
|
|
*aCTM = parentTM;
|
|
|
|
NS_ADDREF(*aCTM);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsSVGPathGeometryFrame methods:
|
|
|
|
|
2007-07-24 02:05:37 -07:00
|
|
|
nsSVGMarkerProperty *
|
|
|
|
nsSVGPathGeometryFrame::GetMarkerProperty()
|
|
|
|
{
|
|
|
|
if (GetStateBits() & NS_STATE_SVG_HAS_MARKERS)
|
|
|
|
return static_cast<nsSVGMarkerProperty *>
|
|
|
|
(GetProperty(nsGkAtoms::marker));
|
|
|
|
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGPathGeometryFrame::UpdateMarkerProperty()
|
|
|
|
{
|
|
|
|
if (GetStateBits() & NS_STATE_SVG_HAS_MARKERS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
const nsStyleSVG *style = GetStyleSVG();
|
|
|
|
|
|
|
|
if ((style->mMarkerStart || style->mMarkerMid || style->mMarkerEnd) &&
|
|
|
|
!new nsSVGMarkerProperty(style->mMarkerStart,
|
|
|
|
style->mMarkerMid,
|
|
|
|
style->mMarkerEnd,
|
|
|
|
this)) {
|
|
|
|
NS_ERROR("Could not create marker property");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGPathGeometryFrame::RemovePathProperties()
|
|
|
|
{
|
|
|
|
if (GetStateBits() & NS_STATE_SVG_HAS_MARKERS)
|
|
|
|
DeleteProperty(nsGkAtoms::marker);
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
void
|
|
|
|
nsSVGPathGeometryFrame::Render(nsSVGRenderState *aContext)
|
|
|
|
{
|
|
|
|
gfxContext *gfx = aContext->GetGfxContext();
|
|
|
|
|
|
|
|
PRUint16 renderMode = aContext->GetRenderMode();
|
|
|
|
|
|
|
|
/* save/pop the state so we don't screw up the xform */
|
|
|
|
gfx->Save();
|
|
|
|
|
|
|
|
GeneratePath(gfx);
|
|
|
|
|
|
|
|
if (renderMode != nsSVGRenderState::NORMAL) {
|
|
|
|
gfx->Restore();
|
|
|
|
|
|
|
|
if (GetClipRule() == NS_STYLE_FILL_RULE_EVENODD)
|
|
|
|
gfx->SetFillRule(gfxContext::FILL_RULE_EVEN_ODD);
|
|
|
|
else
|
|
|
|
gfx->SetFillRule(gfxContext::FILL_RULE_WINDING);
|
|
|
|
|
|
|
|
if (renderMode == nsSVGRenderState::CLIP_MASK) {
|
|
|
|
gfx->SetAntialiasMode(gfxContext::MODE_ALIASED);
|
|
|
|
gfx->SetColor(gfxRGBA(1.0f, 1.0f, 1.0f, 1.0f));
|
|
|
|
gfx->Fill();
|
|
|
|
gfx->NewPath();
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (GetStyleSVG()->mShapeRendering) {
|
|
|
|
case NS_STYLE_SHAPE_RENDERING_OPTIMIZESPEED:
|
|
|
|
case NS_STYLE_SHAPE_RENDERING_CRISPEDGES:
|
|
|
|
gfx->SetAntialiasMode(gfxContext::MODE_ALIASED);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gfx->SetAntialiasMode(gfxContext::MODE_COVERAGE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-10-21 02:05:41 -07:00
|
|
|
if (HasFill() && SetupCairoFill(gfx)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
gfx->Fill();
|
|
|
|
}
|
|
|
|
|
2007-10-21 02:05:41 -07:00
|
|
|
if (HasStroke() && SetupCairoStroke(gfx)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
gfx->Stroke();
|
|
|
|
}
|
|
|
|
|
|
|
|
gfx->NewPath();
|
|
|
|
|
|
|
|
gfx->Restore();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSVGPathGeometryFrame::GeneratePath(gfxContext* aContext)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMSVGMatrix> ctm;
|
|
|
|
GetCanvasTM(getter_AddRefs(ctm));
|
|
|
|
NS_ASSERTION(ctm, "graphic source didn't specify a ctm");
|
|
|
|
|
|
|
|
gfxMatrix matrix = nsSVGUtils::ConvertSVGMatrixToThebes(ctm);
|
|
|
|
|
|
|
|
if (matrix.IsSingular()) {
|
|
|
|
aContext->IdentityMatrix();
|
|
|
|
aContext->NewPath();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-03-27 05:43:59 -07:00
|
|
|
aContext->Multiply(matrix);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
aContext->NewPath();
|
2007-07-08 00:08:04 -07:00
|
|
|
static_cast<nsSVGPathGeometryElement*>(mContent)->ConstructPath(aContext);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
PRUint16
|
|
|
|
nsSVGPathGeometryFrame::GetHittestMask()
|
|
|
|
{
|
|
|
|
PRUint16 mask = 0;
|
|
|
|
|
|
|
|
switch(GetStyleSVG()->mPointerEvents) {
|
|
|
|
case NS_STYLE_POINTER_EVENTS_NONE:
|
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_VISIBLEPAINTED:
|
|
|
|
if (GetStyleVisibility()->IsVisible()) {
|
|
|
|
if (GetStyleSVG()->mFill.mType != eStyleSVGPaintType_None)
|
|
|
|
mask |= HITTEST_MASK_FILL;
|
|
|
|
if (GetStyleSVG()->mStroke.mType != eStyleSVGPaintType_None)
|
|
|
|
mask |= HITTEST_MASK_STROKE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_VISIBLEFILL:
|
|
|
|
if (GetStyleVisibility()->IsVisible()) {
|
2007-08-30 11:53:05 -07:00
|
|
|
mask |= HITTEST_MASK_FILL | HITTEST_MASK_FORCE_TEST;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_VISIBLESTROKE:
|
|
|
|
if (GetStyleVisibility()->IsVisible()) {
|
2007-08-30 11:53:05 -07:00
|
|
|
mask |= HITTEST_MASK_STROKE | HITTEST_MASK_FORCE_TEST;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_VISIBLE:
|
|
|
|
if (GetStyleVisibility()->IsVisible()) {
|
2007-08-30 11:53:05 -07:00
|
|
|
mask |=
|
|
|
|
HITTEST_MASK_FILL |
|
|
|
|
HITTEST_MASK_STROKE |
|
|
|
|
HITTEST_MASK_FORCE_TEST;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_PAINTED:
|
|
|
|
if (GetStyleSVG()->mFill.mType != eStyleSVGPaintType_None)
|
|
|
|
mask |= HITTEST_MASK_FILL;
|
|
|
|
if (GetStyleSVG()->mStroke.mType != eStyleSVGPaintType_None)
|
|
|
|
mask |= HITTEST_MASK_STROKE;
|
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_FILL:
|
2007-08-30 11:53:05 -07:00
|
|
|
mask |= HITTEST_MASK_FILL | HITTEST_MASK_FORCE_TEST;
|
2007-03-22 10:30:00 -07:00
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_STROKE:
|
2007-08-30 11:53:05 -07:00
|
|
|
mask |= HITTEST_MASK_STROKE | HITTEST_MASK_FORCE_TEST;
|
2007-03-22 10:30:00 -07:00
|
|
|
break;
|
|
|
|
case NS_STYLE_POINTER_EVENTS_ALL:
|
2007-08-30 11:53:05 -07:00
|
|
|
mask |=
|
|
|
|
HITTEST_MASK_FILL |
|
|
|
|
HITTEST_MASK_STROKE |
|
|
|
|
HITTEST_MASK_FORCE_TEST;
|
2007-03-22 10:30:00 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
NS_ERROR("not reached");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mask;
|
|
|
|
}
|