From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- layout/generic/nsImageFrame.h | 465 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 465 insertions(+) create mode 100644 layout/generic/nsImageFrame.h (limited to 'layout/generic/nsImageFrame.h') diff --git a/layout/generic/nsImageFrame.h b/layout/generic/nsImageFrame.h new file mode 100644 index 0000000000..d9e2610e81 --- /dev/null +++ b/layout/generic/nsImageFrame.h @@ -0,0 +1,465 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* rendering object for replaced elements with image data */ + +#ifndef nsImageFrame_h___ +#define nsImageFrame_h___ + +#include "nsAtomicContainerFrame.h" +#include "nsIObserver.h" + +#include "imgINotificationObserver.h" + +#include "nsDisplayList.h" +#include "imgIContainer.h" +#include "mozilla/Attributes.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/StaticPtr.h" +#include "nsIReflowCallback.h" +#include "nsTObserverArray.h" + +class nsFontMetrics; +class nsImageMap; +class nsIURI; +class nsILoadGroup; +class nsPresContext; +class nsImageFrame; +class nsTransform2D; +class nsImageLoadingContent; + +namespace mozilla { +class nsDisplayImage; +class PresShell; +namespace layers { +class ImageContainer; +class LayerManager; +} // namespace layers +} // namespace mozilla + +class nsImageListener final : public imgINotificationObserver { + protected: + virtual ~nsImageListener(); + + public: + explicit nsImageListener(nsImageFrame* aFrame); + + NS_DECL_ISUPPORTS + NS_DECL_IMGINOTIFICATIONOBSERVER + + void SetFrame(nsImageFrame* frame) { mFrame = frame; } + + private: + nsImageFrame* mFrame; +}; + +class nsImageFrame : public nsAtomicContainerFrame, public nsIReflowCallback { + public: + template + using Maybe = mozilla::Maybe; + using Nothing = mozilla::Nothing; + using Visibility = mozilla::Visibility; + + typedef mozilla::image::ImgDrawResult ImgDrawResult; + typedef mozilla::layers::ImageContainer ImageContainer; + typedef mozilla::layers::LayerManager LayerManager; + + NS_DECL_FRAMEARENA_HELPERS(nsImageFrame) + NS_DECL_QUERYFRAME + + void Destroy(DestroyContext&) override; + void DidSetComputedStyle(ComputedStyle* aOldStyle) final; + + void Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) override; + void BuildDisplayList(nsDisplayListBuilder*, const nsDisplayListSet&) final; + nscoord GetMinISize(gfxContext* aRenderingContext) final; + nscoord GetPrefISize(gfxContext* aRenderingContext) final; + mozilla::IntrinsicSize GetIntrinsicSize() final { return mIntrinsicSize; } + mozilla::AspectRatio GetIntrinsicRatio() const final { + return mIntrinsicRatio; + } + void Reflow(nsPresContext*, ReflowOutput&, const ReflowInput&, + nsReflowStatus&) override; + bool IsLeafDynamic() const override; + + nsresult GetContentForEvent(const mozilla::WidgetEvent*, + nsIContent** aContent) final; + nsresult HandleEvent(nsPresContext*, mozilla::WidgetGUIEvent*, + nsEventStatus*) override; + Cursor GetCursor(const nsPoint&) override; + nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute, + int32_t aModType) final; + + void OnVisibilityChange( + Visibility aNewVisibility, + const Maybe& aNonvisibleAction = Nothing()) final; + + void ResponsiveContentDensityChanged(); + void ElementStateChanged(mozilla::dom::ElementState) override; + void SetupOwnedRequest(); + void DeinitOwnedRequest(); + bool ShouldShowBrokenImageIcon() const; + + bool IsForImageLoadingContent() const { + return mKind == Kind::ImageLoadingContent; + } + + void UpdateXULImage(); + const mozilla::StyleImage* GetImageFromStyle() const; + +#ifdef ACCESSIBILITY + mozilla::a11y::AccType AccessibleType() override; +#endif + +#ifdef DEBUG_FRAME_DUMP + nsresult GetFrameName(nsAString& aResult) const override; + void List(FILE* out = stderr, const char* aPrefix = "", + ListFlags aFlags = ListFlags()) const final; +#endif + + LogicalSides GetLogicalSkipSides() const final; + + static void ReleaseGlobals(); + + already_AddRefed GetCurrentRequest() const; + void Notify(imgIRequest*, int32_t aType, const nsIntRect* aData); + + /** + * Returns whether we should replace an element with an image corresponding to + * its 'content' CSS property. + */ + static bool ShouldCreateImageFrameForContentProperty( + const mozilla::dom::Element&, const ComputedStyle&); + + /** + * Function to test whether given an element and its style, that element + * should get an image frame, and if so, which kind of image frame (for + * `content`, or for the element itself). + */ + enum class ImageFrameType { + ForContentProperty, + ForElementRequest, + None, + }; + static ImageFrameType ImageFrameTypeFor(const mozilla::dom::Element&, + const ComputedStyle&); + + ImgDrawResult DisplayAltFeedback(gfxContext& aRenderingContext, + const nsRect& aDirtyRect, nsPoint aPt, + uint32_t aFlags); + + ImgDrawResult DisplayAltFeedbackWithoutLayer( + nsDisplayItem*, mozilla::wr::DisplayListBuilder&, + mozilla::wr::IpcResourceUpdateQueue&, + const mozilla::layers::StackingContextHelper&, + mozilla::layers::RenderRootStateManager*, nsDisplayListBuilder*, + nsPoint aPt, uint32_t aFlags); + + /** + * Return a map element associated with this image. + */ + mozilla::dom::Element* GetMapElement() const; + + /** + * Return true if the image has associated image map. + */ + bool HasImageMap() const { return mImageMap || GetMapElement(); } + + nsImageMap* GetImageMap(); + nsImageMap* GetExistingImageMap() const { return mImageMap; } + + void AddInlineMinISize(gfxContext* aRenderingContext, + InlineMinISizeData* aData) final; + + void DisconnectMap(); + + // nsIReflowCallback + bool ReflowFinished() final; + void ReflowCallbackCanceled() final; + + // The kind of image frame we are. + enum class Kind : uint8_t { + // For an nsImageLoadingContent. + ImageLoadingContent, + // For a element. + XULImage, + // For css 'content: url(..)' on non-generated content. + ContentProperty, + // For a child of a ::before / ::after pseudo-element that had an url() item + // for the content property. + ContentPropertyAtIndex, + // For a list-style-image ::marker. + ListStyleImage, + }; + + // Creates a suitable continuing frame for this frame. + nsImageFrame* CreateContinuingFrame(mozilla::PresShell*, + ComputedStyle*) const; + + private: + friend nsIFrame* NS_NewImageFrame(mozilla::PresShell*, ComputedStyle*); + friend nsIFrame* NS_NewXULImageFrame(mozilla::PresShell*, ComputedStyle*); + friend nsIFrame* NS_NewImageFrameForContentProperty(mozilla::PresShell*, + ComputedStyle*); + friend nsIFrame* NS_NewImageFrameForGeneratedContentIndex(mozilla::PresShell*, + ComputedStyle*); + friend nsIFrame* NS_NewImageFrameForListStyleImage(mozilla::PresShell*, + ComputedStyle*); + + nsImageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, Kind aKind) + : nsImageFrame(aStyle, aPresContext, kClassID, aKind) {} + + nsImageFrame(ComputedStyle*, nsPresContext* aPresContext, ClassID, Kind); + + void ReflowChildren(nsPresContext*, const ReflowInput&, + const mozilla::LogicalSize& aImageSize); + + void UpdateIntrinsicSizeAndRatio(); + + protected: + nsImageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, ClassID aID) + : nsImageFrame(aStyle, aPresContext, aID, Kind::ImageLoadingContent) {} + + ~nsImageFrame() override; + + void EnsureIntrinsicSizeAndRatio(); + + bool GotInitialReflow() const { + return !HasAnyStateBits(NS_FRAME_FIRST_REFLOW); + } + + SizeComputationResult ComputeSize( + gfxContext* aRenderingContext, mozilla::WritingMode aWM, + const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize, + const mozilla::LogicalSize& aMargin, + const mozilla::LogicalSize& aBorderPadding, + const mozilla::StyleSizeOverrides& aSizeOverrides, + mozilla::ComputeSizeFlags aFlags) final; + + bool IsServerImageMap(); + + // Translate a point that is relative to our frame into a localized CSS pixel + // coordinate that is relative to the content area of this frame (inside the + // border+padding). + mozilla::CSSIntPoint TranslateEventCoords(const nsPoint& aPoint); + + bool GetAnchorHREFTargetAndNode(nsIURI** aHref, nsString& aTarget, + nsIContent** aNode); + /** + * Computes the width of the string that fits into the available space + * + * @param in aLength total length of the string in PRUnichars + * @param in aMaxWidth width not to be exceeded + * @param out aMaxFit length of the string that fits within aMaxWidth + * in PRUnichars + * @return width of the string that fits within aMaxWidth + */ + nscoord MeasureString(const char16_t* aString, int32_t aLength, + nscoord aMaxWidth, uint32_t& aMaxFit, + gfxContext& aContext, nsFontMetrics& aFontMetrics); + + void DisplayAltText(nsPresContext* aPresContext, + gfxContext& aRenderingContext, const nsString& aAltText, + const nsRect& aRect); + + ImgDrawResult PaintImage(gfxContext& aRenderingContext, nsPoint aPt, + const nsRect& aDirtyRect, imgIContainer* aImage, + uint32_t aFlags); + + /** + * If we're ready to decode - that is, if our current request's image is + * available and our decoding heuristics are satisfied - then trigger a decode + * for our image at the size we predict it will be drawn next time it's + * painted. + */ + void MaybeDecodeForPredictedSize(); + + /** + * Is this frame part of a ::marker pseudo? + */ + bool IsForMarkerPseudo() const; + + protected: + friend class nsImageListener; + friend class nsImageLoadingContent; + friend class mozilla::PresShell; + + void OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage); + void OnFrameUpdate(imgIRequest* aRequest, const nsIntRect* aRect); + void OnLoadComplete(imgIRequest* aRequest, nsresult aStatus); + + /** + * Notification that aRequest will now be the current request. + */ + void NotifyNewCurrentRequest(imgIRequest* aRequest, nsresult aStatus); + + /// Always sync decode our image when painting if @aForce is true. + void SetForceSyncDecoding(bool aForce) { mForceSyncDecoding = aForce; } + + void AssertSyncDecodingHintIsInSync() const +#ifndef DEBUG + {} +#else + ; +#endif + + /** + * Computes the predicted dest rect that we'll draw into, in app units, based + * upon the provided frame content box. (The content box is what + * nsDisplayImage::GetBounds() returns.) + * The result is not necessarily contained in the frame content box. + */ + nsRect PredictedDestRect(const nsRect& aFrameContentBox); + + private: + nscoord GetContinuationOffset() const; + bool ShouldDisplaySelection(); + + // Whether the image frame should use the mapped aspect ratio from width="" + // and height="". + bool ShouldUseMappedAspectRatio() const; + + // Recalculate mIntrinsicSize from the image. + bool UpdateIntrinsicSize(); + + // Recalculate mIntrinsicRatio from the image. + bool UpdateIntrinsicRatio(); + + /** + * This function calculates the transform for converting between + * source space & destination space. May fail if our image has a + * percent-valued or zero-valued height or width. + * + * @param aTransform The transform object to populate. + * + * @return whether we succeeded in creating the transform. + */ + bool GetSourceToDestTransform(nsTransform2D& aTransform); + + /** + * Helper function to check whether the request corresponds to a load we don't + * care about. Most of the decoder observer methods will bail early if this + * returns true. + */ + bool IsPendingLoad(imgIRequest*) const; + + /** + * Updates mImage based on the current image request, and the image passed in + * (both can be null), and invalidate layout and paint as needed. + */ + void UpdateImage(imgIRequest*, imgIContainer*); + + /** + * Function to convert a dirty rect in the source image to a dirty + * rect for the image frame. + */ + nsRect SourceRectToDest(const nsIntRect& aRect); + + /** + * Triggers invalidation for both our image display item and, if appropriate, + * our alt-feedback display item. + * + * @param aLayerInvalidRect The area to invalidate in layer space. If null, + * the entire layer will be invalidated. + * @param aFrameInvalidRect The area to invalidate in frame space. If null, + * the entire frame will be invalidated. + */ + void InvalidateSelf(const nsIntRect* aLayerInvalidRect, + const nsRect* aFrameInvalidRect); + + void MaybeSendIntrinsicSizeAndRatioToEmbedder(); + void MaybeSendIntrinsicSizeAndRatioToEmbedder(Maybe, + Maybe); + + RefPtr mImageMap; + + RefPtr mListener; + + // An image request created for content: url(..), list-style-image, or + // . + RefPtr mOwnedRequest; + + nsCOMPtr mImage; + nsCOMPtr mPrevImage; + + // The content-box size as if we are not fragmented, cached in the most recent + // reflow. + nsSize mComputedSize; + + mozilla::IntrinsicSize mIntrinsicSize; + + // Stores mImage's intrinsic ratio, or a default AspectRatio if there's no + // intrinsic ratio. + mozilla::AspectRatio mIntrinsicRatio; + + const Kind mKind; + bool mOwnedRequestRegistered = false; + bool mDisplayingIcon = false; + bool mFirstFrameComplete = false; + bool mReflowCallbackPosted = false; + bool mForceSyncDecoding = false; + bool mIsInObjectOrEmbed = false; + + public: + friend class mozilla::nsDisplayImage; + friend class nsDisplayGradient; +}; + +namespace mozilla { +/** + * Note that nsDisplayImage does not receive events. However, an image element + * is replaced content so its background will be z-adjacent to the + * image itself, and hence receive events just as if the image itself + * received events. + */ +class nsDisplayImage final : public nsPaintedDisplayItem { + public: + typedef mozilla::layers::LayerManager LayerManager; + + nsDisplayImage(nsDisplayListBuilder* aBuilder, nsImageFrame* aFrame, + imgIContainer* aImage, imgIContainer* aPrevImage) + : nsPaintedDisplayItem(aBuilder, aFrame), + mImage(aImage), + mPrevImage(aPrevImage) { + MOZ_COUNT_CTOR(nsDisplayImage); + } + ~nsDisplayImage() final { MOZ_COUNT_DTOR(nsDisplayImage); } + + void Paint(nsDisplayListBuilder*, gfxContext* aCtx) final; + + /** + * @return The dest rect we'll use when drawing this image, in app units. + * Not necessarily contained in this item's bounds. + */ + nsRect GetDestRect() const; + + nsRect GetBounds(bool* aSnap) const { + *aSnap = true; + return Frame()->GetContentRectRelativeToSelf() + ToReferenceFrame(); + } + + nsRect GetBounds(nsDisplayListBuilder*, bool* aSnap) const final { + return GetBounds(aSnap); + } + + nsRegion GetOpaqueRegion(nsDisplayListBuilder*, bool* aSnap) const final; + + bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder&, + mozilla::wr::IpcResourceUpdateQueue&, + const StackingContextHelper&, + mozilla::layers::RenderRootStateManager*, + nsDisplayListBuilder*) final; + + NS_DISPLAY_DECL_NAME("Image", TYPE_IMAGE) + private: + nsCOMPtr mImage; + nsCOMPtr mPrevImage; +}; + +} // namespace mozilla + +#endif /* nsImageFrame_h___ */ -- cgit v1.2.3