layout/generic/nsImageFrame.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* rendering object for replaced elements with image data */
   8
   9 #ifndef nsImageFrame_h___
  10 #define nsImageFrame_h___
  11
  12 #include "nsAtomicContainerFrame.h"
  13 #include "nsIObserver.h"
  14
  15 #include "imgINotificationObserver.h"
  16
  17 #include "nsDisplayList.h"
  18 #include "imgIContainer.h"
  19 #include "mozilla/Attributes.h"
  20 #include "mozilla/DebugOnly.h"
  21 #include "mozilla/StaticPtr.h"
  22 #include "nsIReflowCallback.h"
  23 #include "nsTObserverArray.h"
  24
  25 class nsFontMetrics;
  26 class nsImageMap;
  27 class nsIURI;
  28 class nsILoadGroup;
  29 class nsPresContext;
  30 class nsImageFrame;
  31 class nsTransform2D;
  32 class nsImageLoadingContent;
  33
  34 namespace mozilla {
  35 class nsDisplayImage;
  36 class PresShell;
  37 namespace layers {
  38 class ImageContainer;
  39 class LayerManager;
  40 }  // namespace layers
  41 }  // namespace mozilla
  42
  43 class nsImageListener final : public imgINotificationObserver {
  44  protected:
  45   virtual ~nsImageListener();
  46
  47  public:
  48   explicit nsImageListener(nsImageFrame* aFrame);
  49
  50   NS_DECL_ISUPPORTS
  51   NS_DECL_IMGINOTIFICATIONOBSERVER
  52
  53   void SetFrame(nsImageFrame* frame) { mFrame = frame; }
  54
  55  private:
  56   nsImageFrame* mFrame;
  57 };
  58
  59 class nsImageFrame : public nsAtomicContainerFrame, public nsIReflowCallback {
  60  public:
  61   template <typename T>
  62   using Maybe = mozilla::Maybe<T>;
  63   using Nothing = mozilla::Nothing;
  64   using Visibility = mozilla::Visibility;
  65
  66   typedef mozilla::image::ImgDrawResult ImgDrawResult;
  67   typedef mozilla::layers::ImageContainer ImageContainer;
  68   typedef mozilla::layers::LayerManager LayerManager;
  69
  70   NS_DECL_FRAMEARENA_HELPERS(nsImageFrame)
  71   NS_DECL_QUERYFRAME
  72
  73   void Destroy(DestroyContext&) override;
  74   void DidSetComputedStyle(ComputedStyle* aOldStyle) final;
  75
  76   void Init(nsIContent* aContent, nsContainerFrame* aParent,
  77             nsIFrame* aPrevInFlow) override;
  78   void BuildDisplayList(nsDisplayListBuilder*, const nsDisplayListSet&) final;
  79   nscoord GetMinISize(gfxContext* aRenderingContext) final;
  80   nscoord GetPrefISize(gfxContext* aRenderingContext) final;
  81   mozilla::IntrinsicSize GetIntrinsicSize() final { return mIntrinsicSize; }
  82   mozilla::AspectRatio GetIntrinsicRatio() const final {
  83     return mIntrinsicRatio;
  84   }
  85   void Reflow(nsPresContext*, ReflowOutput&, const ReflowInput&,
  86               nsReflowStatus&) override;
  87   bool IsLeafDynamic() const override;
  88
  89   nsresult GetContentForEvent(const mozilla::WidgetEvent*,
  90                               nsIContent** aContent) final;
  91   nsresult HandleEvent(nsPresContext*, mozilla::WidgetGUIEvent*,
  92                        nsEventStatus*) override;
  93   Cursor GetCursor(const nsPoint&) override;
  94   nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
  95                             int32_t aModType) final;
  96
  97   void OnVisibilityChange(
  98       Visibility aNewVisibility,
  99       const Maybe<OnNonvisible>& aNonvisibleAction = Nothing()) final;
 100
 101   void ResponsiveContentDensityChanged();
 102   void ElementStateChanged(mozilla::dom::ElementState) override;
 103   void SetupOwnedRequest();
 104   void DeinitOwnedRequest();
 105   bool ShouldShowBrokenImageIcon() const;
 106
 107   bool IsForImageLoadingContent() const {
 108     return mKind == Kind::ImageLoadingContent;
 109   }
 110
 111   void UpdateXULImage();
 112   const mozilla::StyleImage* GetImageFromStyle() const;
 113
 114 #ifdef ACCESSIBILITY
 115   mozilla::a11y::AccType AccessibleType() override;
 116 #endif
 117
 118 #ifdef DEBUG_FRAME_DUMP
 119   nsresult GetFrameName(nsAString& aResult) const override;
 120   void List(FILE* out = stderr, const char* aPrefix = "",
 121             ListFlags aFlags = ListFlags()) const final;
 122 #endif
 123
 124   LogicalSides GetLogicalSkipSides() const final;
 125
 126   static void ReleaseGlobals();
 127
 128   already_AddRefed<imgIRequest> GetCurrentRequest() const;
 129   void Notify(imgIRequest*, int32_t aType, const nsIntRect* aData);
 130
 131   /**
 132    * Returns whether we should replace an element with an image corresponding to
 133    * its 'content' CSS property.
 134    */
 135   static bool ShouldCreateImageFrameForContentProperty(
 136       const mozilla::dom::Element&, const ComputedStyle&);
 137
 138   /**
 139    * Function to test whether given an element and its style, that element
 140    * should get an image frame, and if so, which kind of image frame (for
 141    * `content`, or for the element itself).
 142    */
 143   enum class ImageFrameType {
 144     ForContentProperty,
 145     ForElementRequest,
 146     None,
 147   };
 148   static ImageFrameType ImageFrameTypeFor(const mozilla::dom::Element&,
 149                                           const ComputedStyle&);
 150
 151   ImgDrawResult DisplayAltFeedback(gfxContext& aRenderingContext,
 152                                    const nsRect& aDirtyRect, nsPoint aPt,
 153                                    uint32_t aFlags);
 154
 155   ImgDrawResult DisplayAltFeedbackWithoutLayer(
 156       nsDisplayItem*, mozilla::wr::DisplayListBuilder&,
 157       mozilla::wr::IpcResourceUpdateQueue&,
 158       const mozilla::layers::StackingContextHelper&,
 159       mozilla::layers::RenderRootStateManager*, nsDisplayListBuilder*,
 160       nsPoint aPt, uint32_t aFlags);
 161
 162   /**
 163    * Return a map element associated with this image.
 164    */
 165   mozilla::dom::Element* GetMapElement() const;
 166
 167   /**
 168    * Return true if the image has associated image map.
 169    */
 170   bool HasImageMap() const { return mImageMap || GetMapElement(); }
 171
 172   nsImageMap* GetImageMap();
 173   nsImageMap* GetExistingImageMap() const { return mImageMap; }
 174
 175   void AddInlineMinISize(gfxContext* aRenderingContext,
 176                          InlineMinISizeData* aData) final;
 177
 178   void DisconnectMap();
 179
 180   // nsIReflowCallback
 181   bool ReflowFinished() final;
 182   void ReflowCallbackCanceled() final;
 183
 184   // The kind of image frame we are.
 185   enum class Kind : uint8_t {
 186     // For an nsImageLoadingContent.
 187     ImageLoadingContent,
 188     // For a <xul:image> element.
 189     XULImage,
 190     // For css 'content: url(..)' on non-generated content.
 191     ContentProperty,
 192     // For a child of a ::before / ::after pseudo-element that had an url() item
 193     // for the content property.
 194     ContentPropertyAtIndex,
 195     // For a list-style-image ::marker.
 196     ListStyleImage,
 197   };
 198
 199   // Creates a suitable continuing frame for this frame.
 200   nsImageFrame* CreateContinuingFrame(mozilla::PresShell*,
 201                                       ComputedStyle*) const;
 202
 203  private:
 204   friend nsIFrame* NS_NewImageFrame(mozilla::PresShell*, ComputedStyle*);
 205   friend nsIFrame* NS_NewXULImageFrame(mozilla::PresShell*, ComputedStyle*);
 206   friend nsIFrame* NS_NewImageFrameForContentProperty(mozilla::PresShell*,
 207                                                       ComputedStyle*);
 208   friend nsIFrame* NS_NewImageFrameForGeneratedContentIndex(mozilla::PresShell*,
 209                                                             ComputedStyle*);
 210   friend nsIFrame* NS_NewImageFrameForListStyleImage(mozilla::PresShell*,
 211                                                      ComputedStyle*);
 212
 213   nsImageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, Kind aKind)
 214       : nsImageFrame(aStyle, aPresContext, kClassID, aKind) {}
 215
 216   nsImageFrame(ComputedStyle*, nsPresContext* aPresContext, ClassID, Kind);
 217
 218   void ReflowChildren(nsPresContext*, const ReflowInput&,
 219                       const mozilla::LogicalSize& aImageSize);
 220
 221   void UpdateIntrinsicSizeAndRatio();
 222
 223  protected:
 224   nsImageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, ClassID aID)
 225       : nsImageFrame(aStyle, aPresContext, aID, Kind::ImageLoadingContent) {}
 226
 227   ~nsImageFrame() override;
 228
 229   void EnsureIntrinsicSizeAndRatio();
 230
 231   bool GotInitialReflow() const {
 232     return !HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
 233   }
 234
 235   SizeComputationResult ComputeSize(
 236       gfxContext* aRenderingContext, mozilla::WritingMode aWM,
 237       const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize,
 238       const mozilla::LogicalSize& aMargin,
 239       const mozilla::LogicalSize& aBorderPadding,
 240       const mozilla::StyleSizeOverrides& aSizeOverrides,
 241       mozilla::ComputeSizeFlags aFlags) final;
 242
 243   bool IsServerImageMap();
 244
 245   // Translate a point that is relative to our frame into a localized CSS pixel
 246   // coordinate that is relative to the content area of this frame (inside the
 247   // border+padding).
 248   mozilla::CSSIntPoint TranslateEventCoords(const nsPoint& aPoint);
 249
 250   bool GetAnchorHREFTargetAndNode(nsIURI** aHref, nsString& aTarget,
 251                                   nsIContent** aNode);
 252   /**
 253    * Computes the width of the string that fits into the available space
 254    *
 255    * @param in aLength total length of the string in PRUnichars
 256    * @param in aMaxWidth width not to be exceeded
 257    * @param out aMaxFit length of the string that fits within aMaxWidth
 258    *            in PRUnichars
 259    * @return width of the string that fits within aMaxWidth
 260    */
 261   nscoord MeasureString(const char16_t* aString, int32_t aLength,
 262                         nscoord aMaxWidth, uint32_t& aMaxFit,
 263                         gfxContext& aContext, nsFontMetrics& aFontMetrics);
 264
 265   void DisplayAltText(nsPresContext* aPresContext,
 266                       gfxContext& aRenderingContext, const nsString& aAltText,
 267                       const nsRect& aRect);
 268
 269   ImgDrawResult PaintImage(gfxContext& aRenderingContext, nsPoint aPt,
 270                            const nsRect& aDirtyRect, imgIContainer* aImage,
 271                            uint32_t aFlags);
 272
 273   /**
 274    * If we're ready to decode - that is, if our current request's image is
 275    * available and our decoding heuristics are satisfied - then trigger a decode
 276    * for our image at the size we predict it will be drawn next time it's
 277    * painted.
 278    */
 279   void MaybeDecodeForPredictedSize();
 280
 281   /**
 282    * Is this frame part of a ::marker pseudo?
 283    */
 284   bool IsForMarkerPseudo() const;
 285
 286  protected:
 287   friend class nsImageListener;
 288   friend class nsImageLoadingContent;
 289   friend class mozilla::PresShell;
 290
 291   void OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage);
 292   void OnFrameUpdate(imgIRequest* aRequest, const nsIntRect* aRect);
 293   void OnLoadComplete(imgIRequest* aRequest, nsresult aStatus);
 294
 295   /**
 296    * Notification that aRequest will now be the current request.
 297    */
 298   void NotifyNewCurrentRequest(imgIRequest* aRequest, nsresult aStatus);
 299
 300   /// Always sync decode our image when painting if @aForce is true.
 301   void SetForceSyncDecoding(bool aForce) { mForceSyncDecoding = aForce; }
 302
 303   void AssertSyncDecodingHintIsInSync() const
 304 #ifndef DEBUG
 305       {}
 306 #else
 307       ;
 308 #endif
 309
 310   /**
 311    * Computes the predicted dest rect that we'll draw into, in app units, based
 312    * upon the provided frame content box. (The content box is what
 313    * nsDisplayImage::GetBounds() returns.)
 314    * The result is not necessarily contained in the frame content box.
 315    */
 316   nsRect PredictedDestRect(const nsRect& aFrameContentBox);
 317
 318  private:
 319   nscoord GetContinuationOffset() const;
 320   bool ShouldDisplaySelection();
 321
 322   // Whether the image frame should use the mapped aspect ratio from width=""
 323   // and height="".
 324   bool ShouldUseMappedAspectRatio() const;
 325
 326   // Recalculate mIntrinsicSize from the image.
 327   bool UpdateIntrinsicSize();
 328
 329   // Recalculate mIntrinsicRatio from the image.
 330   bool UpdateIntrinsicRatio();
 331
 332   /**
 333    * This function calculates the transform for converting between
 334    * source space & destination space. May fail if our image has a
 335    * percent-valued or zero-valued height or width.
 336    *
 337    * @param aTransform The transform object to populate.
 338    *
 339    * @return whether we succeeded in creating the transform.
 340    */
 341   bool GetSourceToDestTransform(nsTransform2D& aTransform);
 342
 343   /**
 344    * Helper function to check whether the request corresponds to a load we don't
 345    * care about.  Most of the decoder observer methods will bail early if this
 346    * returns true.
 347    */
 348   bool IsPendingLoad(imgIRequest*) const;
 349
 350   /**
 351    * Updates mImage based on the current image request, and the image passed in
 352    * (both can be null), and invalidate layout and paint as needed.
 353    */
 354   void UpdateImage(imgIRequest*, imgIContainer*);
 355
 356   /**
 357    * Function to convert a dirty rect in the source image to a dirty
 358    * rect for the image frame.
 359    */
 360   nsRect SourceRectToDest(const nsIntRect& aRect);
 361
 362   /**
 363    * Triggers invalidation for both our image display item and, if appropriate,
 364    * our alt-feedback display item.
 365    *
 366    * @param aLayerInvalidRect The area to invalidate in layer space. If null,
 367    * the entire layer will be invalidated.
 368    * @param aFrameInvalidRect The area to invalidate in frame space. If null,
 369    * the entire frame will be invalidated.
 370    */
 371   void InvalidateSelf(const nsIntRect* aLayerInvalidRect,
 372                       const nsRect* aFrameInvalidRect);
 373
 374   void MaybeSendIntrinsicSizeAndRatioToEmbedder();
 375   void MaybeSendIntrinsicSizeAndRatioToEmbedder(Maybe<mozilla::IntrinsicSize>,
 376                                                 Maybe<mozilla::AspectRatio>);
 377
 378   RefPtr<nsImageMap> mImageMap;
 379
 380   RefPtr<nsImageListener> mListener;
 381
 382   // An image request created for content: url(..), list-style-image, or
 383   // <xul:image>.
 384   RefPtr<imgRequestProxy> mOwnedRequest;
 385
 386   nsCOMPtr<imgIContainer> mImage;
 387   nsCOMPtr<imgIContainer> mPrevImage;
 388
 389   // The content-box size as if we are not fragmented, cached in the most recent
 390   // reflow.
 391   nsSize mComputedSize;
 392
 393   mozilla::IntrinsicSize mIntrinsicSize;
 394
 395   // Stores mImage's intrinsic ratio, or a default AspectRatio if there's no
 396   // intrinsic ratio.
 397   mozilla::AspectRatio mIntrinsicRatio;
 398
 399   const Kind mKind;
 400   bool mOwnedRequestRegistered = false;
 401   bool mDisplayingIcon = false;
 402   bool mFirstFrameComplete = false;
 403   bool mReflowCallbackPosted = false;
 404   bool mForceSyncDecoding = false;
 405   bool mIsInObjectOrEmbed = false;
 406
 407  public:
 408   friend class mozilla::nsDisplayImage;
 409   friend class nsDisplayGradient;
 410 };
 411
 412 namespace mozilla {
 413 /**
 414  * Note that nsDisplayImage does not receive events. However, an image element
 415  * is replaced content so its background will be z-adjacent to the
 416  * image itself, and hence receive events just as if the image itself
 417  * received events.
 418  */
 419 class nsDisplayImage final : public nsPaintedDisplayItem {
 420  public:
 421   typedef mozilla::layers::LayerManager LayerManager;
 422
 423   nsDisplayImage(nsDisplayListBuilder* aBuilder, nsImageFrame* aFrame,
 424                  imgIContainer* aImage, imgIContainer* aPrevImage)
 425       : nsPaintedDisplayItem(aBuilder, aFrame),
 426         mImage(aImage),
 427         mPrevImage(aPrevImage) {
 428     MOZ_COUNT_CTOR(nsDisplayImage);
 429   }
 430   ~nsDisplayImage() final { MOZ_COUNT_DTOR(nsDisplayImage); }
 431
 432   void Paint(nsDisplayListBuilder*, gfxContext* aCtx) final;
 433
 434   /**
 435    * @return The dest rect we'll use when drawing this image, in app units.
 436    *         Not necessarily contained in this item's bounds.
 437    */
 438   nsRect GetDestRect() const;
 439
 440   nsRect GetBounds(bool* aSnap) const {
 441     *aSnap = true;
 442     return Frame()->GetContentRectRelativeToSelf() + ToReferenceFrame();
 443   }
 444
 445   nsRect GetBounds(nsDisplayListBuilder*, bool* aSnap) const final {
 446     return GetBounds(aSnap);
 447   }
 448
 449   nsRegion GetOpaqueRegion(nsDisplayListBuilder*, bool* aSnap) const final;
 450
 451   bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder&,
 452                                mozilla::wr::IpcResourceUpdateQueue&,
 453                                const StackingContextHelper&,
 454                                mozilla::layers::RenderRootStateManager*,
 455                                nsDisplayListBuilder*) final;
 456
 457   NS_DISPLAY_DECL_NAME("Image", TYPE_IMAGE)
 458  private:
 459   nsCOMPtr<imgIContainer> mImage;
 460   nsCOMPtr<imgIContainer> mPrevImage;
 461 };
 462
 463 }  // namespace mozilla
 464
 465 #endif /* nsImageFrame_h___ */