layout/svg/base/src/nsSVGMarkerFrame.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is the Mozilla SVG project.
  16  *
  17  * The Initial Developer of the Original Code is IBM Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 2004
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either of the GNU General Public License Version 2 or later (the "GPL"),
  25  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #include "nsIDOMSVGAnimatedRect.h"
  38 #include "nsIDOMSVGRect.h"
  39 #include "nsIDocument.h"
  40 #include "nsSVGMarkerFrame.h"
  41 #include "nsSVGPathGeometryFrame.h"
  42 #include "nsSVGMatrix.h"
  43 #include "nsSVGEffects.h"
  44 #include "nsSVGMarkerElement.h"
  45 #include "nsSVGPathGeometryElement.h"
  46 #include "gfxContext.h"
  47
  48 nsIFrame*
  49 NS_NewSVGMarkerFrame(nsIPresShell* aPresShell, nsIContent* aContent, nsStyleContext* aContext)
  50 {
  51   nsCOMPtr<nsIDOMSVGMarkerElement> marker = do_QueryInterface(aContent);
  52   if (!marker) {
  53     NS_ASSERTION(marker, "Can't create frame! Content is not an SVG marker");
  54     return nsnull;
  55   }
  56
  57   return new (aPresShell) nsSVGMarkerFrame(aContext);
  58 }
  59
  60 //----------------------------------------------------------------------
  61 // nsIFrame methods:
  62
  63 NS_IMETHODIMP
  64 nsSVGMarkerFrame::AttributeChanged(PRInt32  aNameSpaceID,
  65                                    nsIAtom* aAttribute,
  66                                    PRInt32  aModType)
  67 {
  68   if (aNameSpaceID == kNameSpaceID_None &&
  69       (aAttribute == nsGkAtoms::markerUnits ||
  70        aAttribute == nsGkAtoms::refX ||
  71        aAttribute == nsGkAtoms::refY ||
  72        aAttribute == nsGkAtoms::markerWidth ||
  73        aAttribute == nsGkAtoms::markerHeight ||
  74        aAttribute == nsGkAtoms::orient ||
  75        aAttribute == nsGkAtoms::preserveAspectRatio ||
  76        aAttribute == nsGkAtoms::viewBox)) {
  77     nsSVGEffects::InvalidateRenderingObservers(this);
  78   }
  79
  80   return nsSVGMarkerFrameBase::AttributeChanged(aNameSpaceID,
  81                                                 aAttribute, aModType);
  82 }
  83
  84 nsIAtom *
  85 nsSVGMarkerFrame::GetType() const
  86 {
  87   return nsGkAtoms::svgMarkerFrame;
  88 }
  89
  90 //----------------------------------------------------------------------
  91 // nsSVGContainerFrame methods:
  92
  93 already_AddRefed<nsIDOMSVGMatrix>
  94 nsSVGMarkerFrame::GetCanvasTM()
  95 {
  96   if (mInUse2) {
  97     // really we should return null, but the rest of the SVG code
  98     // isn't set up for that.  We're going to be bailing drawing the
  99     // marker anyway, so return an identity.
 100     nsCOMPtr<nsIDOMSVGMatrix> ident;
 101     NS_NewSVGMatrix(getter_AddRefs(ident));
 102
 103     nsIDOMSVGMatrix *retval = ident.get();
 104     NS_IF_ADDREF(retval);
 105     return retval;
 106   }
 107
 108   mInUse2 = PR_TRUE;
 109
 110   // get the tm from the path geometry frame and append local transform
 111
 112   NS_ASSERTION(mMarkedFrame, "null nsSVGPathGeometry frame");
 113   nsCOMPtr<nsIDOMSVGMatrix> markedTM;
 114   mMarkedFrame->GetCanvasTM(getter_AddRefs(markedTM));
 115   NS_ASSERTION(markedTM, "null marked TM");
 116
 117   // get element
 118   nsSVGMarkerElement *element = static_cast<nsSVGMarkerElement*>(mContent);
 119
 120   // scale/move marker
 121   nsCOMPtr<nsIDOMSVGMatrix> markerTM;
 122   element->GetMarkerTransform(mStrokeWidth, mX, mY, mAngle, getter_AddRefs(markerTM));
 123
 124   // viewport marker
 125   nsCOMPtr<nsIDOMSVGMatrix> viewBoxTM;
 126   nsresult res =
 127     element->GetViewboxToViewportTransform(getter_AddRefs(viewBoxTM));
 128
 129   nsCOMPtr<nsIDOMSVGMatrix> tmpTM;
 130   nsCOMPtr<nsIDOMSVGMatrix> resultTM;
 131
 132   markedTM->Multiply(markerTM, getter_AddRefs(tmpTM));
 133
 134   if (NS_SUCCEEDED(res) && viewBoxTM) {
 135     tmpTM->Multiply(viewBoxTM, getter_AddRefs(resultTM));
 136   } else {
 137     NS_WARNING("We should propagate the fact that the viewBox is invalid.");
 138     resultTM = tmpTM;
 139   }
 140
 141   nsIDOMSVGMatrix *retval = resultTM.get();
 142   NS_IF_ADDREF(retval);
 143
 144   mInUse2 = PR_FALSE;
 145
 146   return retval;
 147 }
 148
 149
 150 nsresult
 151 nsSVGMarkerFrame::PaintMark(nsSVGRenderState *aContext,
 152                             nsSVGPathGeometryFrame *aMarkedFrame,
 153                             nsSVGMark *aMark, float aStrokeWidth)
 154 {
 155   // If the flag is set when we get here, it means this marker frame
 156   // has already been used painting the current mark, and the document
 157   // has a marker reference loop.
 158   if (mInUse)
 159     return NS_OK;
 160
 161   nsSVGMarkerElement *marker = static_cast<nsSVGMarkerElement*>(mContent);
 162
 163   nsCOMPtr<nsIDOMSVGAnimatedRect> arect;
 164   nsresult rv = marker->GetViewBox(getter_AddRefs(arect));
 165   NS_ENSURE_SUCCESS(rv, rv);
 166
 167   nsCOMPtr<nsIDOMSVGRect> rect;
 168   rv = arect->GetAnimVal(getter_AddRefs(rect));
 169   NS_ENSURE_SUCCESS(rv, rv);
 170
 171   float x, y, width, height;
 172   rect->GetX(&x);
 173   rect->GetY(&y);
 174   rect->GetWidth(&width);
 175   rect->GetHeight(&height);
 176
 177   if (width <= 0.0f || height <= 0.0f) {
 178     // We must disable rendering if the viewBox width or height are zero.
 179     return NS_OK;
 180   }
 181
 182   AutoMarkerReferencer markerRef(this, aMarkedFrame);
 183
 184   mStrokeWidth = aStrokeWidth;
 185   mX = aMark->x;
 186   mY = aMark->y;
 187   mAngle = aMark->angle;
 188
 189   gfxContext *gfx = aContext->GetGfxContext();
 190
 191   if (GetStyleDisplay()->IsScrollableOverflow()) {
 192     nsCOMPtr<nsIDOMSVGMatrix> matrix = GetCanvasTM();
 193     NS_ENSURE_TRUE(matrix, NS_ERROR_OUT_OF_MEMORY);
 194
 195     gfx->Save();
 196     nsSVGUtils::SetClipRect(gfx, matrix, x, y, width, height);
 197   }
 198
 199   for (nsIFrame* kid = mFrames.FirstChild(); kid;
 200        kid = kid->GetNextSibling()) {
 201     nsISVGChildFrame* SVGFrame = nsnull;
 202     CallQueryInterface(kid, &SVGFrame);
 203     if (SVGFrame) {
 204       // The CTM of each frame referencing us may be different.
 205       SVGFrame->NotifySVGChanged(nsISVGChildFrame::SUPPRESS_INVALIDATION |
 206                                  nsISVGChildFrame::TRANSFORM_CHANGED);
 207       nsSVGUtils::PaintFrameWithEffects(aContext, nsnull, kid);
 208     }
 209   }
 210
 211   if (GetStyleDisplay()->IsScrollableOverflow())
 212     gfx->Restore();
 213
 214   return NS_OK;
 215 }
 216
 217
 218 nsRect
 219 nsSVGMarkerFrame::RegionMark(nsSVGPathGeometryFrame *aMarkedFrame,
 220                              const nsSVGMark *aMark, float aStrokeWidth)
 221 {
 222   // If the flag is set when we get here, it means this marker frame
 223   // has already been used in calculating the current mark region, and
 224   // the document has a marker reference loop.
 225   if (mInUse)
 226     return nsRect(0,0,0,0);
 227
 228   AutoMarkerReferencer markerRef(this, aMarkedFrame);
 229
 230   mStrokeWidth = aStrokeWidth;
 231   mX = aMark->x;
 232   mY = aMark->y;
 233   mAngle = aMark->angle;
 234
 235   // Force children to update their covered region
 236   for (nsIFrame* kid = mFrames.FirstChild();
 237        kid;
 238        kid = kid->GetNextSibling()) {
 239     nsISVGChildFrame* child = nsnull;
 240     CallQueryInterface(kid, &child);
 241     if (child)
 242       child->UpdateCoveredRegion();
 243   }
 244
 245   // Now get the combined covered region
 246   return nsSVGUtils::GetCoveredRegion(mFrames);
 247 }
 248
 249 void
 250 nsSVGMarkerFrame::SetParentCoordCtxProvider(nsSVGSVGElement *aContext)
 251 {
 252   nsSVGMarkerElement *marker = static_cast<nsSVGMarkerElement*>(mContent);
 253   marker->SetParentCoordCtxProvider(aContext);
 254 }
 255
 256 //----------------------------------------------------------------------
 257 // helper class
 258
 259 nsSVGMarkerFrame::AutoMarkerReferencer::AutoMarkerReferencer(
 260     nsSVGMarkerFrame *aFrame,
 261     nsSVGPathGeometryFrame *aMarkedFrame)
 262       : mFrame(aFrame)
 263 {
 264   mFrame->mInUse = PR_TRUE;
 265   mFrame->mMarkedFrame = aMarkedFrame;
 266
 267   nsSVGSVGElement *ctx =
 268     static_cast<nsSVGElement*>(aMarkedFrame->GetContent())->GetCtx();
 269   mFrame->SetParentCoordCtxProvider(ctx);
 270 }
 271
 272 nsSVGMarkerFrame::AutoMarkerReferencer::~AutoMarkerReferencer()
 273 {
 274   mFrame->SetParentCoordCtxProvider(nsnull);
 275
 276   mFrame->mMarkedFrame = nsnull;
 277   mFrame->mInUse = PR_FALSE;
 278 }