LCOV - app.info - layout/svg/base/src/nsSVGImageFrame.cpp

LCOV - code coverage report
| Current view: | directory - layout/svg/base/src - nsSVGImageFrame.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 185 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 26 | 0 | 0.0 %

           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 "nsSVGPathGeometryFrame.h"
          38                 : #include "imgIContainer.h"
          39                 : #include "nsStubImageDecoderObserver.h"
          40                 : #include "nsImageLoadingContent.h"
          41                 : #include "nsIDOMSVGImageElement.h"
          42                 : #include "nsLayoutUtils.h"
          43                 : #include "nsSVGImageElement.h"
          44                 : #include "nsSVGUtils.h"
          45                 : #include "gfxContext.h"
          46                 : #include "gfxMatrix.h"
          47                 : #include "nsIInterfaceRequestorUtils.h"
          48                 : #include "gfxPlatform.h"
          49                 : #include "nsSVGSVGElement.h"
          50                 :
          51                 : using namespace mozilla;
          52                 :
          53                 : class nsRenderingContext;
          54                 : class nsSVGImageFrame;
          55                 :
          56                 : class nsSVGImageListener MOZ_FINAL : public nsStubImageDecoderObserver
          57                 : {
          58                 : public:
          59                 :   nsSVGImageListener(nsSVGImageFrame *aFrame);
          60                 :
          61                 :   NS_DECL_ISUPPORTS
          62                 :   // imgIDecoderObserver (override nsStubImageDecoderObserver)
          63                 :   NS_IMETHOD OnStopDecode(imgIRequest *aRequest, nsresult status,
          64                 :                           const PRUnichar *statusArg);
          65                 :   // imgIContainerObserver (override nsStubImageDecoderObserver)
          66                 :   NS_IMETHOD FrameChanged(imgIRequest *aRequest,
          67                 :                           imgIContainer *aContainer,
          68                 :                           const nsIntRect *aDirtyRect);
          69                 :   // imgIContainerObserver (override nsStubImageDecoderObserver)
          70                 :   NS_IMETHOD OnStartContainer(imgIRequest *aRequest,
          71                 :                               imgIContainer *aContainer);
          72                 :
          73               0 :   void SetFrame(nsSVGImageFrame *frame) { mFrame = frame; }
          74                 :
          75                 : private:
          76                 :   nsSVGImageFrame *mFrame;
          77                 : };
          78                 :
          79                 : typedef nsSVGPathGeometryFrame nsSVGImageFrameBase;
          80                 :
          81                 : class nsSVGImageFrame : public nsSVGImageFrameBase
          82                 : {
          83                 :   friend nsIFrame*
          84                 :   NS_NewSVGImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
          85                 :
          86                 : protected:
          87               0 :   nsSVGImageFrame(nsStyleContext* aContext) : nsSVGImageFrameBase(aContext) {}
          88                 :   virtual ~nsSVGImageFrame();
          89                 :
          90                 : public:
          91                 :   NS_DECL_FRAMEARENA_HELPERS
          92                 :
          93                 :   // nsISVGChildFrame interface:
          94                 :   NS_IMETHOD PaintSVG(nsRenderingContext *aContext, const nsIntRect *aDirtyRect);
          95                 :   NS_IMETHOD_(nsIFrame*) GetFrameForPoint(const nsPoint &aPoint);
          96                 :
          97                 :   // nsSVGPathGeometryFrame methods:
          98                 :   NS_IMETHOD UpdateCoveredRegion();
          99                 :   virtual PRUint16 GetHitTestFlags();
         100                 :
         101                 :   // nsIFrame interface:
         102                 :   NS_IMETHOD  AttributeChanged(PRInt32         aNameSpaceID,
         103                 :                                nsIAtom*        aAttribute,
         104                 :                                PRInt32         aModType);
         105                 :   NS_IMETHOD Init(nsIContent*      aContent,
         106                 :                   nsIFrame*        aParent,
         107                 :                   nsIFrame*        aPrevInFlow);
         108                 :   virtual void DestroyFrom(nsIFrame* aDestructRoot);
         109                 :
         110                 :   /**
         111                 :    * Get the "type" of the frame
         112                 :    *
         113                 :    * @see nsGkAtoms::svgImageFrame
         114                 :    */
         115                 :   virtual nsIAtom* GetType() const;
         116                 :
         117                 : #ifdef DEBUG
         118               0 :   NS_IMETHOD GetFrameName(nsAString& aResult) const
         119                 :   {
         120               0 :     return MakeFrameName(NS_LITERAL_STRING("SVGImage"), aResult);
         121                 :   }
         122                 : #endif
         123                 :
         124                 : private:
         125                 :   gfxMatrix GetRasterImageTransform(PRInt32 aNativeWidth,
         126                 :                                     PRInt32 aNativeHeight);
         127                 :   gfxMatrix GetVectorImageTransform();
         128                 :   bool      TransformContextForPainting(gfxContext* aGfxContext);
         129                 :
         130                 :   nsCOMPtr<imgIDecoderObserver> mListener;
         131                 :
         132                 :   nsCOMPtr<imgIContainer> mImageContainer;
         133                 :
         134                 :   friend class nsSVGImageListener;
         135                 : };
         136                 :
         137                 : //----------------------------------------------------------------------
         138                 : // Implementation
         139                 :
         140                 : nsIFrame*
         141               0 : NS_NewSVGImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
         142                 : {
         143               0 :   return new (aPresShell) nsSVGImageFrame(aContext);
         144                 : }
         145                 :
         146               0 : NS_IMPL_FRAMEARENA_HELPERS(nsSVGImageFrame)
         147                 :
         148               0 : nsSVGImageFrame::~nsSVGImageFrame()
         149                 : {
         150                 :   // set the frame to null so we don't send messages to a dead object.
         151               0 :   if (mListener) {
         152               0 :     nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
         153               0 :     if (imageLoader) {
         154                 :       // Push a null JSContext on the stack so that code that runs
         155                 :       // within the below code doesn't think it's being called by
         156                 :       // JS. See bug 604262.
         157               0 :       nsCxPusher pusher;
         158               0 :       pusher.PushNull();
         159                 :
         160               0 :       imageLoader->RemoveObserver(mListener);
         161                 :     }
         162               0 :     reinterpret_cast<nsSVGImageListener*>(mListener.get())->SetFrame(nsnull);
         163                 :   }
         164               0 :   mListener = nsnull;
         165               0 : }
         166                 :
         167                 : NS_IMETHODIMP
         168               0 : nsSVGImageFrame::Init(nsIContent* aContent,
         169                 :                       nsIFrame* aParent,
         170                 :                       nsIFrame* aPrevInFlow)
         171                 : {
         172                 : #ifdef DEBUG
         173               0 :   nsCOMPtr<nsIDOMSVGImageElement> image = do_QueryInterface(aContent);
         174               0 :   NS_ASSERTION(image, "Content is not an SVG image!");
         175                 : #endif
         176                 :
         177               0 :   nsresult rv = nsSVGImageFrameBase::Init(aContent, aParent, aPrevInFlow);
         178               0 :   if (NS_FAILED(rv)) return rv;
         179                 :
         180               0 :   mListener = new nsSVGImageListener(this);
         181               0 :   if (!mListener) return NS_ERROR_OUT_OF_MEMORY;
         182               0 :   nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
         183               0 :   NS_ENSURE_TRUE(imageLoader, NS_ERROR_UNEXPECTED);
         184                 :
         185                 :   // We should have a PresContext now, so let's notify our image loader that
         186                 :   // we need to register any image animations with the refresh driver.
         187               0 :   imageLoader->FrameCreated(this);
         188                 :
         189                 :   // Push a null JSContext on the stack so that code that runs within
         190                 :   // the below code doesn't think it's being called by JS. See bug
         191                 :   // 604262.
         192               0 :   nsCxPusher pusher;
         193               0 :   pusher.PushNull();
         194                 :
         195               0 :   imageLoader->AddObserver(mListener);
         196                 :
         197               0 :   return NS_OK;
         198                 : }
         199                 :
         200                 : /* virtual */ void
         201               0 : nsSVGImageFrame::DestroyFrom(nsIFrame* aDestructRoot)
         202                 : {
         203                 :   nsCOMPtr<nsIImageLoadingContent> imageLoader =
         204               0 :     do_QueryInterface(nsFrame::mContent);
         205                 :
         206               0 :   if (imageLoader) {
         207               0 :     imageLoader->FrameDestroyed(this);
         208                 :   }
         209                 :
         210               0 :   nsFrame::DestroyFrom(aDestructRoot);
         211               0 : }
         212                 :
         213                 : //----------------------------------------------------------------------
         214                 : // nsIFrame methods:
         215                 :
         216                 : NS_IMETHODIMP
         217               0 : nsSVGImageFrame::AttributeChanged(PRInt32         aNameSpaceID,
         218                 :                                   nsIAtom*        aAttribute,
         219                 :                                   PRInt32         aModType)
         220                 : {
         221               0 :   if (aNameSpaceID == kNameSpaceID_None &&
         222                 :       (aAttribute == nsGkAtoms::x ||
         223                 :        aAttribute == nsGkAtoms::y ||
         224                 :        aAttribute == nsGkAtoms::width ||
         225                 :        aAttribute == nsGkAtoms::height ||
         226                 :        aAttribute == nsGkAtoms::preserveAspectRatio)) {
         227               0 :     nsSVGUtils::UpdateGraphic(this);
         228               0 :     return NS_OK;
         229                 :   }
         230               0 :   if (aNameSpaceID == kNameSpaceID_XLink &&
         231                 :       aAttribute == nsGkAtoms::href) {
         232                 :
         233                 :     // Prevent setting image.src by exiting early
         234               0 :     if (nsContentUtils::IsImageSrcSetDisabled()) {
         235               0 :       return NS_OK;
         236                 :     }
         237               0 :     nsSVGImageElement *element = static_cast<nsSVGImageElement*>(mContent);
         238                 :
         239               0 :     if (element->mStringAttributes[nsSVGImageElement::HREF].IsExplicitlySet()) {
         240               0 :       element->LoadSVGImage(true, true);
         241                 :     } else {
         242               0 :       element->CancelImageRequests(true);
         243                 :     }
         244                 :   }
         245                 :
         246                 :   return nsSVGImageFrameBase::AttributeChanged(aNameSpaceID,
         247               0 :                                                aAttribute, aModType);
         248                 : }
         249                 :
         250                 : gfxMatrix
         251               0 : nsSVGImageFrame::GetRasterImageTransform(PRInt32 aNativeWidth, PRInt32 aNativeHeight)
         252                 : {
         253                 :   float x, y, width, height;
         254               0 :   nsSVGImageElement *element = static_cast<nsSVGImageElement*>(mContent);
         255               0 :   element->GetAnimatedLengthValues(&x, &y, &width, &height, nsnull);
         256                 :
         257                 :   gfxMatrix viewBoxTM =
         258                 :     nsSVGUtils::GetViewBoxTransform(element,
         259                 :                                     width, height,
         260                 :                                     0, 0, aNativeWidth, aNativeHeight,
         261               0 :                                     element->mPreserveAspectRatio);
         262                 :
         263               0 :   return viewBoxTM * gfxMatrix().Translate(gfxPoint(x, y)) * GetCanvasTM();
         264                 : }
         265                 :
         266                 : gfxMatrix
         267               0 : nsSVGImageFrame::GetVectorImageTransform()
         268                 : {
         269                 :   float x, y, width, height;
         270               0 :   nsSVGImageElement *element = static_cast<nsSVGImageElement*>(mContent);
         271               0 :   element->GetAnimatedLengthValues(&x, &y, &width, &height, nsnull);
         272                 :
         273                 :   // No viewBoxTM needed here -- our height/width overrides any concept of
         274                 :   // "native size" that the SVG image has, and it will handle viewBox and
         275                 :   // preserveAspectRatio on its own once we give it a region to draw into.
         276                 :
         277               0 :   return gfxMatrix().Translate(gfxPoint(x, y)) * GetCanvasTM();
         278                 : }
         279                 :
         280                 : bool
         281               0 : nsSVGImageFrame::TransformContextForPainting(gfxContext* aGfxContext)
         282                 : {
         283               0 :   gfxMatrix imageTransform;
         284               0 :   if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
         285               0 :     imageTransform = GetVectorImageTransform();
         286                 :   } else {
         287                 :     PRInt32 nativeWidth, nativeHeight;
         288               0 :     if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
         289               0 :         NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
         290                 :         nativeWidth == 0 || nativeHeight == 0) {
         291               0 :       return false;
         292                 :     }
         293               0 :     imageTransform = GetRasterImageTransform(nativeWidth, nativeHeight);
         294                 :   }
         295                 :
         296               0 :   if (imageTransform.IsSingular()) {
         297               0 :     return false;
         298                 :   }
         299                 :
         300                 :   // NOTE: We need to cancel out the effects of Full-Page-Zoom, or else
         301                 :   // it'll get applied an extra time by DrawSingleUnscaledImage.
         302               0 :   nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
         303                 :   gfxFloat pageZoomFactor =
         304               0 :     nsPresContext::AppUnitsToFloatCSSPixels(appUnitsPerDevPx);
         305               0 :   aGfxContext->Multiply(imageTransform.Scale(pageZoomFactor, pageZoomFactor));
         306                 :
         307               0 :   return true;
         308                 : }
         309                 :
         310                 : //----------------------------------------------------------------------
         311                 : // nsISVGChildFrame methods:
         312                 : NS_IMETHODIMP
         313               0 : nsSVGImageFrame::PaintSVG(nsRenderingContext *aContext,
         314                 :                           const nsIntRect *aDirtyRect)
         315                 : {
         316               0 :   nsresult rv = NS_OK;
         317                 :
         318               0 :   if (!GetStyleVisibility()->IsVisible())
         319               0 :     return NS_OK;
         320                 :
         321                 :   float x, y, width, height;
         322               0 :   nsSVGImageElement *imgElem = static_cast<nsSVGImageElement*>(mContent);
         323               0 :   imgElem->GetAnimatedLengthValues(&x, &y, &width, &height, nsnull);
         324               0 :   NS_ASSERTION(width > 0 && height > 0,
         325                 :                "Should only be painting things with valid width/height");
         326                 :
         327               0 :   if (!mImageContainer) {
         328               0 :     nsCOMPtr<imgIRequest> currentRequest;
         329               0 :     nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
         330               0 :     if (imageLoader)
         331               0 :       imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
         332               0 :                               getter_AddRefs(currentRequest));
         333                 :
         334               0 :     if (currentRequest)
         335               0 :       currentRequest->GetImage(getter_AddRefs(mImageContainer));
         336                 :   }
         337                 :
         338               0 :   if (mImageContainer) {
         339               0 :     gfxContext* ctx = aContext->ThebesContext();
         340               0 :     gfxContextAutoSaveRestore autoRestorer(ctx);
         341                 :
         342               0 :     if (GetStyleDisplay()->IsScrollableOverflow()) {
         343                 :       gfxRect clipRect = nsSVGUtils::GetClipRectForFrame(this, x, y,
         344               0 :                                                          width, height);
         345               0 :       nsSVGUtils::SetClipRect(ctx, GetCanvasTM(), clipRect);
         346                 :     }
         347                 :
         348               0 :     if (!TransformContextForPainting(ctx)) {
         349               0 :       return NS_ERROR_FAILURE;
         350                 :     }
         351                 :
         352                 :     // fill-opacity doesn't affect <image>, so if we're allowed to
         353                 :     // optimize group opacity, the opacity used for compositing the
         354                 :     // image into the current canvas is just the group opacity.
         355               0 :     float opacity = 1.0f;
         356               0 :     if (nsSVGUtils::CanOptimizeOpacity(this)) {
         357               0 :       opacity = GetStyleDisplay()->mOpacity;
         358                 :     }
         359                 :
         360               0 :     if (opacity != 1.0f) {
         361               0 :       ctx->PushGroup(gfxASurface::CONTENT_COLOR_ALPHA);
         362                 :     }
         363                 :
         364               0 :     nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
         365               0 :     nsRect dirtyRect; // only used if aDirtyRect is non-null
         366               0 :     if (aDirtyRect) {
         367               0 :       dirtyRect = aDirtyRect->ToAppUnits(appUnitsPerDevPx);
         368                 :       // Adjust dirtyRect to match our local coordinate system.
         369                 :       nsRect rootRect =
         370               0 :         nsSVGUtils::TransformFrameRectToOuterSVG(mRect, GetCanvasTM(), PresContext());
         371               0 :       dirtyRect.MoveBy(-rootRect.TopLeft());
         372                 :     }
         373                 :
         374                 :     // XXXbholley - I don't think huge images in SVGs are common enough to
         375                 :     // warrant worrying about the responsiveness impact of doing synchronous
         376                 :     // decodes. The extra code complexity of determinining when we want to
         377                 :     // force sync probably just isn't worth it, so always pass FLAG_SYNC_DECODE
         378               0 :     PRUint32 drawFlags = imgIContainer::FLAG_SYNC_DECODE;
         379                 :
         380               0 :     if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
         381               0 :       nsIFrame* imgRootFrame = mImageContainer->GetRootLayoutFrame();
         382               0 :       if (!imgRootFrame) {
         383                 :         // bad image (e.g. XML parse error in image's SVG file)
         384               0 :         return NS_OK;
         385                 :       }
         386                 :
         387                 :       // Grab root node (w/ sanity-check to make sure it exists & is <svg>)
         388                 :       nsSVGSVGElement* rootSVGElem =
         389               0 :         static_cast<nsSVGSVGElement*>(imgRootFrame->GetContent());
         390               0 :       if (!rootSVGElem || !rootSVGElem->IsSVG(nsGkAtoms::svg)) {
         391               0 :         NS_ABORT_IF_FALSE(false, "missing or non-<svg> root node!!");
         392               0 :         return false;
         393                 :       }
         394                 :
         395                 :       // Override preserveAspectRatio in our helper document
         396                 :       // XXXdholbert We should technically be overriding the helper doc's clip
         397                 :       // and overflow properties here, too. See bug 272288 comment 36.
         398                 :       rootSVGElem->SetImageOverridePreserveAspectRatio(
         399               0 :         imgElem->mPreserveAspectRatio.GetAnimValue());
         400                 :       nsRect destRect(0, 0,
         401                 :                       appUnitsPerDevPx * width,
         402               0 :                       appUnitsPerDevPx * height);
         403                 :
         404                 :       // Note: Can't use DrawSingleUnscaledImage for the TYPE_VECTOR case.
         405                 :       // That method needs our image to have a fixed native width & height,
         406                 :       // and that's not always true for TYPE_VECTOR images.
         407                 :       nsLayoutUtils::DrawSingleImage(
         408                 :         aContext,
         409                 :         mImageContainer,
         410                 :         nsLayoutUtils::GetGraphicsFilterForFrame(this),
         411                 :         destRect,
         412                 :         aDirtyRect ? dirtyRect : destRect,
         413               0 :         drawFlags);
         414                 :
         415               0 :       rootSVGElem->ClearImageOverridePreserveAspectRatio();
         416                 :     } else { // mImageContainer->GetType() == TYPE_RASTER
         417                 :       nsLayoutUtils::DrawSingleUnscaledImage(
         418                 :         aContext,
         419                 :         mImageContainer,
         420                 :         nsLayoutUtils::GetGraphicsFilterForFrame(this),
         421                 :         nsPoint(0, 0),
         422                 :         aDirtyRect ? &dirtyRect : nsnull,
         423               0 :         drawFlags);
         424                 :     }
         425                 :
         426               0 :     if (opacity != 1.0f) {
         427               0 :       ctx->PopGroupToSource();
         428               0 :       ctx->SetOperator(gfxContext::OPERATOR_OVER);
         429               0 :       ctx->Paint(opacity);
         430                 :     }
         431                 :     // gfxContextAutoSaveRestore goes out of scope & cleans up our gfxContext
         432                 :   }
         433                 :
         434               0 :   return rv;
         435                 : }
         436                 :
         437                 : NS_IMETHODIMP_(nsIFrame*)
         438               0 : nsSVGImageFrame::GetFrameForPoint(const nsPoint &aPoint)
         439                 : {
         440                 :   // Special case for raster images -- we only want to accept points that fall
         441                 :   // in the underlying image's (transformed) native bounds.  That region
         442                 :   // doesn't necessarily map to our <image> element's [x,y,width,height].  So,
         443                 :   // we have to look up the native image size & our image transform in order
         444                 :   // to filter out points that fall outside that area.
         445               0 :   if (GetStyleDisplay()->IsScrollableOverflow() && mImageContainer) {
         446               0 :     if (mImageContainer->GetType() == imgIContainer::TYPE_RASTER) {
         447                 :       PRInt32 nativeWidth, nativeHeight;
         448               0 :       if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
         449               0 :           NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
         450                 :           nativeWidth == 0 || nativeHeight == 0) {
         451               0 :         return nsnull;
         452                 :       }
         453                 :
         454               0 :       if (!nsSVGUtils::HitTestRect(
         455               0 :                GetRasterImageTransform(nativeWidth, nativeHeight),
         456                 :                0, 0, nativeWidth, nativeHeight,
         457               0 :                PresContext()->AppUnitsToDevPixels(aPoint.x),
         458               0 :                PresContext()->AppUnitsToDevPixels(aPoint.y))) {
         459               0 :         return nsnull;
         460                 :       }
         461                 :     }
         462                 :     // The special case above doesn't apply to vector images, because they
         463                 :     // don't limit their drawing to explicit "native bounds" -- they have
         464                 :     // an infinite canvas on which to place content.  So it's reasonable to
         465                 :     // just fall back on our <image> element's own bounds here.
         466                 :   }
         467                 :
         468               0 :   return nsSVGImageFrameBase::GetFrameForPoint(aPoint);
         469                 : }
         470                 :
         471                 : nsIAtom *
         472               0 : nsSVGImageFrame::GetType() const
         473                 : {
         474               0 :   return nsGkAtoms::svgImageFrame;
         475                 : }
         476                 :
         477                 : //----------------------------------------------------------------------
         478                 : // nsSVGPathGeometryFrame methods:
         479                 :
         480                 : // Lie about our fill/stroke so that covered region and hit detection work properly
         481                 :
         482                 : NS_IMETHODIMP
         483               0 : nsSVGImageFrame::UpdateCoveredRegion()
         484                 : {
         485               0 :   mRect.SetEmpty();
         486                 :
         487               0 :   gfxContext context(gfxPlatform::GetPlatform()->ScreenReferenceSurface());
         488                 :
         489               0 :   gfxMatrix identity;
         490               0 :   GeneratePath(&context, &identity);
         491                 :
         492               0 :   gfxRect extent = context.GetUserPathExtent();
         493                 :
         494               0 :   if (!extent.IsEmpty()) {
         495                 :     mRect = nsLayoutUtils::RoundGfxRectToAppRect(extent,
         496               0 :               PresContext()->AppUnitsPerCSSPixel());
         497                 :   }
         498                 :
         499                 :   // See bug 614732 comment 32.
         500                 :   mCoveredRegion = nsSVGUtils::TransformFrameRectToOuterSVG(
         501               0 :     mRect, GetCanvasTM(), PresContext());
         502                 :
         503               0 :   return NS_OK;
         504                 : }
         505                 :
         506                 : PRUint16
         507               0 : nsSVGImageFrame::GetHitTestFlags()
         508                 : {
         509               0 :   PRUint16 flags = 0;
         510                 :
         511               0 :   switch(GetStyleVisibility()->mPointerEvents) {
         512                 :     case NS_STYLE_POINTER_EVENTS_NONE:
         513               0 :       break;
         514                 :     case NS_STYLE_POINTER_EVENTS_VISIBLEPAINTED:
         515                 :     case NS_STYLE_POINTER_EVENTS_AUTO:
         516               0 :       if (GetStyleVisibility()->IsVisible()) {
         517                 :         /* XXX: should check pixel transparency */
         518               0 :         flags |= SVG_HIT_TEST_FILL;
         519                 :       }
         520               0 :       break;
         521                 :     case NS_STYLE_POINTER_EVENTS_VISIBLEFILL:
         522                 :     case NS_STYLE_POINTER_EVENTS_VISIBLESTROKE:
         523                 :     case NS_STYLE_POINTER_EVENTS_VISIBLE:
         524               0 :       if (GetStyleVisibility()->IsVisible()) {
         525               0 :         flags |= SVG_HIT_TEST_FILL;
         526                 :       }
         527               0 :       break;
         528                 :     case NS_STYLE_POINTER_EVENTS_PAINTED:
         529                 :       /* XXX: should check pixel transparency */
         530               0 :       flags |= SVG_HIT_TEST_FILL;
         531               0 :       break;
         532                 :     case NS_STYLE_POINTER_EVENTS_FILL:
         533                 :     case NS_STYLE_POINTER_EVENTS_STROKE:
         534                 :     case NS_STYLE_POINTER_EVENTS_ALL:
         535               0 :       flags |= SVG_HIT_TEST_FILL;
         536               0 :       break;
         537                 :     default:
         538               0 :       NS_ERROR("not reached");
         539               0 :       break;
         540                 :   }
         541                 :
         542               0 :   return flags;
         543                 : }
         544                 :
         545                 : //----------------------------------------------------------------------
         546                 : // nsSVGImageListener implementation
         547                 :
         548               0 : NS_IMPL_ISUPPORTS2(nsSVGImageListener,
         549                 :                    imgIDecoderObserver,
         550                 :                    imgIContainerObserver)
         551                 :
         552               0 : nsSVGImageListener::nsSVGImageListener(nsSVGImageFrame *aFrame) :  mFrame(aFrame)
         553                 : {
         554               0 : }
         555                 :
         556               0 : NS_IMETHODIMP nsSVGImageListener::OnStopDecode(imgIRequest *aRequest,
         557                 :                                                nsresult status,
         558                 :                                                const PRUnichar *statusArg)
         559                 : {
         560               0 :   if (!mFrame)
         561               0 :     return NS_ERROR_FAILURE;
         562                 :
         563               0 :   nsSVGUtils::UpdateGraphic(mFrame);
         564               0 :   return NS_OK;
         565                 : }
         566                 :
         567               0 : NS_IMETHODIMP nsSVGImageListener::FrameChanged(imgIRequest *aRequest,
         568                 :                                                imgIContainer *aContainer,
         569                 :                                                const nsIntRect *aDirtyRect)
         570                 : {
         571               0 :   if (!mFrame)
         572               0 :     return NS_ERROR_FAILURE;
         573                 :
         574               0 :   nsSVGUtils::UpdateGraphic(mFrame);
         575               0 :   return NS_OK;
         576                 : }
         577                 :
         578               0 : NS_IMETHODIMP nsSVGImageListener::OnStartContainer(imgIRequest *aRequest,
         579                 :                                                    imgIContainer *aContainer)
         580                 : {
         581               0 :   if (!mFrame)
         582               0 :     return NS_ERROR_FAILURE;
         583                 :
         584               0 :   mFrame->mImageContainer = aContainer;
         585               0 :   nsSVGUtils::UpdateGraphic(mFrame);
         586                 :
         587               0 :   return NS_OK;
         588                 : }
         589                 :

Generated by: LCOV version 1.7