RandomHuman
/
Mypal
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Mypal/layout/xul/nsImageBoxFrame.cpp

828 lines
24 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
//
// Eric Vaughan
// Netscape Communications
//
// See documentation in associated header file
//
#include "nsImageBoxFrame.h"
#include "nsGkAtoms.h"
#include "nsRenderingContext.h"
#include "nsStyleContext.h"
#include "nsStyleConsts.h"
#include "nsStyleUtil.h"
#include "nsCOMPtr.h"
#include "nsPresContext.h"
#include "nsBoxLayoutState.h"
#include "nsHTMLParts.h"
#include "nsString.h"
#include "nsLeafFrame.h"
#include "nsIPresShell.h"
#include "nsIDocument.h"
#include "nsImageMap.h"
#include "nsILinkHandler.h"
#include "nsIURL.h"
#include "nsILoadGroup.h"
#include "nsContainerFrame.h"
#include "prprf.h"
#include "nsCSSRendering.h"
#include "nsIDOMHTMLImageElement.h"
#include "nsNameSpaceManager.h"
#include "nsTextFragment.h"
#include "nsIDOMHTMLMapElement.h"
#include "nsTransform2D.h"
#include "nsITheme.h"
#include "nsIServiceManager.h"
#include "nsIURI.h"
#include "nsThreadUtils.h"
#include "nsDisplayList.h"
#include "ImageLayers.h"
#include "ImageContainer.h"
#include "nsIContent.h"
#include "nsContentUtils.h"
#include "nsSerializationHelper.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/Maybe.h"
#define ONLOAD_CALLED_TOO_EARLY 1
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::image;
using namespace mozilla::layers;
class nsImageBoxFrameEvent : public Runnable
{
public:
nsImageBoxFrameEvent(nsIContent *content, EventMessage message)
: mContent(content), mMessage(message) {}
NS_IMETHOD Run() override;
private:
nsCOMPtr<nsIContent> mContent;
EventMessage mMessage;
};
NS_IMETHODIMP
nsImageBoxFrameEvent::Run()
{
nsIPresShell *pres_shell = mContent->OwnerDoc()->GetShell();
if (!pres_shell) {
return NS_OK;
}
RefPtr<nsPresContext> pres_context = pres_shell->GetPresContext();
if (!pres_context) {
return NS_OK;
}
nsEventStatus status = nsEventStatus_eIgnore;
WidgetEvent event(true, mMessage);
event.mFlags.mBubbles = false;
EventDispatcher::Dispatch(mContent, pres_context, &event, nullptr, &status);
return NS_OK;
}
// Fire off an event that'll asynchronously call the image elements
// onload handler once handled. This is needed since the image library
// can't decide if it wants to call it's observer methods
// synchronously or asynchronously. If an image is loaded from the
// cache the notifications come back synchronously, but if the image
// is loaded from the netswork the notifications come back
// asynchronously.
void
FireImageDOMEvent(nsIContent* aContent, EventMessage aMessage)
{
NS_ASSERTION(aMessage == eLoad || aMessage == eLoadError,
"invalid message");
nsCOMPtr<nsIRunnable> event = new nsImageBoxFrameEvent(aContent, aMessage);
if (NS_FAILED(NS_DispatchToCurrentThread(event)))
NS_WARNING("failed to dispatch image event");
}
//
// NS_NewImageBoxFrame
//
// Creates a new image frame and returns it
//
nsIFrame*
NS_NewImageBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsImageBoxFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsImageBoxFrame)
nsresult
nsImageBoxFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
nsresult rv = nsLeafBoxFrame::AttributeChanged(aNameSpaceID, aAttribute,
aModType);
if (aAttribute == nsGkAtoms::src) {
UpdateImage();
PresContext()->PresShell()->
FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
}
else if (aAttribute == nsGkAtoms::validate)
UpdateLoadFlags();
return rv;
}
nsImageBoxFrame::nsImageBoxFrame(nsStyleContext* aContext):
nsLeafBoxFrame(aContext),
mIntrinsicSize(0,0),
mLoadFlags(nsIRequest::LOAD_NORMAL),
mRequestRegistered(false),
mUseSrcAttr(false),
mSuppressStyleCheck(false)
{
MarkIntrinsicISizesDirty();
}
nsImageBoxFrame::~nsImageBoxFrame()
{
}
/* virtual */ void
nsImageBoxFrame::MarkIntrinsicISizesDirty()
{
SizeNeedsRecalc(mImageSize);
nsLeafBoxFrame::MarkIntrinsicISizesDirty();
}
void
nsImageBoxFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
if (mImageRequest) {
nsLayoutUtils::DeregisterImageRequest(PresContext(), mImageRequest,
&mRequestRegistered);
// Release image loader first so that it's refcnt can go to zero
mImageRequest->CancelAndForgetObserver(NS_ERROR_FAILURE);
}
if (mListener)
reinterpret_cast<nsImageBoxListener*>(mListener.get())->SetFrame(nullptr); // set the frame to null so we don't send messages to a dead object.
nsLeafBoxFrame::DestroyFrom(aDestructRoot);
}
void
nsImageBoxFrame::Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow)
{
if (!mListener) {
RefPtr<nsImageBoxListener> listener = new nsImageBoxListener();
listener->SetFrame(this);
mListener = listener.forget();
}
mSuppressStyleCheck = true;
nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow);
mSuppressStyleCheck = false;
UpdateLoadFlags();
UpdateImage();
}
void
nsImageBoxFrame::UpdateImage()
{
nsPresContext* presContext = PresContext();
RefPtr<imgRequestProxy> oldImageRequest = mImageRequest;
if (mImageRequest) {
nsLayoutUtils::DeregisterImageRequest(presContext, mImageRequest,
&mRequestRegistered);
mImageRequest->CancelAndForgetObserver(NS_ERROR_FAILURE);
mImageRequest = nullptr;
}
// get the new image src
nsAutoString src;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::src, src);
mUseSrcAttr = !src.IsEmpty();
if (mUseSrcAttr) {
nsIDocument* doc = mContent->GetComposedDoc();
if (doc) {
// Use the serialized loadingPrincipal from the image element. Fall back
// to mContent's principal (SystemPrincipal) if not available.
nsContentPolicyType contentPolicyType = nsIContentPolicy::TYPE_INTERNAL_IMAGE;
nsCOMPtr<nsIPrincipal> loadingPrincipal = mContent->NodePrincipal();
nsAutoString imageLoadingPrincipal;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::loadingprincipal,
imageLoadingPrincipal);
if (!imageLoadingPrincipal.IsEmpty()) {
nsCOMPtr<nsISupports> serializedPrincipal;
NS_DeserializeObject(NS_ConvertUTF16toUTF8(imageLoadingPrincipal),
getter_AddRefs(serializedPrincipal));
loadingPrincipal = do_QueryInterface(serializedPrincipal);
if (loadingPrincipal) {
// Set the content policy type to TYPE_INTERNAL_IMAGE_FAVICON for
// indicating it's a favicon loading.
contentPolicyType = nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON;
} else {
// Fallback if the deserialization is failed.
loadingPrincipal = mContent->NodePrincipal();
}
}
nsCOMPtr<nsIURI> baseURI = mContent->GetBaseURI();
nsCOMPtr<nsIURI> uri;
nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(uri),
src,
doc,
baseURI);
if (uri) {
nsresult rv = nsContentUtils::LoadImage(uri, mContent, doc, loadingPrincipal,
doc->GetDocumentURI(), doc->GetReferrerPolicy(),
mListener, mLoadFlags,
EmptyString(), getter_AddRefs(mImageRequest),
contentPolicyType);
if (NS_SUCCEEDED(rv) && mImageRequest) {
nsLayoutUtils::RegisterImageRequestIfAnimated(presContext,
mImageRequest,
&mRequestRegistered);
}
}
}
} else {
// Only get the list-style-image if we aren't being drawn
// by a native theme.
uint8_t appearance = StyleDisplay()->mAppearance;
if (!(appearance && nsBox::gTheme &&
nsBox::gTheme->ThemeSupportsWidget(nullptr, this, appearance))) {
// get the list-style-image
imgRequestProxy *styleRequest = StyleList()->GetListStyleImage();
if (styleRequest) {
styleRequest->Clone(mListener, getter_AddRefs(mImageRequest));
}
}
}
if (!mImageRequest) {
// We have no image, so size to 0
mIntrinsicSize.SizeTo(0, 0);
} else {
// We don't want discarding or decode-on-draw for xul images.
mImageRequest->StartDecoding();
mImageRequest->LockImage();
}
// Do this _after_ locking the new image in case they are the same image.
if (oldImageRequest) {
oldImageRequest->UnlockImage();
}
}
void
nsImageBoxFrame::UpdateLoadFlags()
{
static nsIContent::AttrValuesArray strings[] =
{&nsGkAtoms::always, &nsGkAtoms::never, nullptr};
switch (mContent->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::validate,
strings, eCaseMatters)) {
case 0:
mLoadFlags = nsIRequest::VALIDATE_ALWAYS;
break;
case 1:
mLoadFlags = nsIRequest::VALIDATE_NEVER|nsIRequest::LOAD_FROM_CACHE;
break;
default:
mLoadFlags = nsIRequest::LOAD_NORMAL;
break;
}
}
void
nsImageBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists)
{
nsLeafBoxFrame::BuildDisplayList(aBuilder, aLists);
if ((0 == mRect.width) || (0 == mRect.height)) {
// Do not render when given a zero area. This avoids some useless
// scaling work while we wait for our image dimensions to arrive
// asynchronously.
return;
}
if (!IsVisibleForPainting(aBuilder))
return;
uint32_t clipFlags =
nsStyleUtil::ObjectPropsMightCauseOverflow(StylePosition()) ?
0 : DisplayListClipState::ASSUME_DRAWING_RESTRICTED_TO_CONTENT_RECT;
DisplayListClipState::AutoClipContainingBlockDescendantsToContentBox
clip(aBuilder, this, clipFlags);
nsDisplayList list;
list.AppendNewToTop(
new (aBuilder) nsDisplayXULImage(aBuilder, this));
CreateOwnLayerIfNeeded(aBuilder, &list);
aLists.Content()->AppendToTop(&list);
}
DrawResult
nsImageBoxFrame::PaintImage(nsRenderingContext& aRenderingContext,
const nsRect& aDirtyRect, nsPoint aPt,
uint32_t aFlags)
{
nsRect constraintRect;
GetXULClientRect(constraintRect);
constraintRect += aPt;
if (!mImageRequest) {
// This probably means we're drawn by a native theme.
return DrawResult::SUCCESS;
}
// don't draw if the image is not dirty
// XXX(seth): Can this actually happen anymore?
nsRect dirty;
if (!dirty.IntersectRect(aDirtyRect, constraintRect)) {
return DrawResult::TEMPORARY_ERROR;
}
// Don't draw if the image's size isn't available.
uint32_t imgStatus;
if (!NS_SUCCEEDED(mImageRequest->GetImageStatus(&imgStatus)) ||
!(imgStatus & imgIRequest::STATUS_SIZE_AVAILABLE)) {
return DrawResult::NOT_READY;
}
nsCOMPtr<imgIContainer> imgCon;
mImageRequest->GetImage(getter_AddRefs(imgCon));
if (!imgCon) {
return DrawResult::NOT_READY;
}
bool hasSubRect = !mUseSrcAttr && (mSubRect.width > 0 || mSubRect.height > 0);
Maybe<nsPoint> anchorPoint;
nsRect dest;
if (!mUseSrcAttr) {
// Our image (if we have one) is coming from the CSS property
// 'list-style-image' (combined with '-moz-image-region'). For now, ignore
// 'object-fit' & 'object-position' in this case, and just fill our rect.
// XXXdholbert Should we even honor these properties in this case? They only
// apply to replaced elements, and I'm not sure we count as a replaced
// element when our image data is determined by CSS.
dest = constraintRect;
} else {
// Determine dest rect based on intrinsic size & ratio, along with
// 'object-fit' & 'object-position' properties:
IntrinsicSize intrinsicSize;
AspectRatio intrinsicRatio;
if (mIntrinsicSize.width > 0 && mIntrinsicSize.height > 0) {
// Image has a valid size; use it as intrinsic size & ratio.
intrinsicSize.width.SetCoordValue(mIntrinsicSize.width);
intrinsicSize.height.SetCoordValue(mIntrinsicSize.height);
intrinsicRatio = AspectRatio::FromSize(mIntrinsicSize);
} else {
// Image doesn't have a (valid) intrinsic size.
// Try to look up intrinsic ratio and use that at least.
imgCon->GetIntrinsicRatio(&intrinsicRatio);
}
anchorPoint.emplace();
dest = nsLayoutUtils::ComputeObjectDestRect(constraintRect,
intrinsicSize,
intrinsicRatio,
StylePosition(),
anchorPoint.ptr());
}
return nsLayoutUtils::DrawSingleImage(
*aRenderingContext.ThebesContext(),
PresContext(), imgCon,
nsLayoutUtils::GetSamplingFilterForFrame(this),
dest, dirty, nullptr, aFlags,
anchorPoint.ptrOr(nullptr),
hasSubRect ? &mSubRect : nullptr);
}
void nsDisplayXULImage::Paint(nsDisplayListBuilder* aBuilder,
nsRenderingContext* aCtx)
{
uint32_t flags = imgIContainer::FLAG_NONE;
if (aBuilder->ShouldSyncDecodeImages())
flags |= imgIContainer::FLAG_SYNC_DECODE;
if (aBuilder->IsPaintingToWindow())
flags |= imgIContainer::FLAG_HIGH_QUALITY_SCALING;
DrawResult result = static_cast<nsImageBoxFrame*>(mFrame)->
PaintImage(*aCtx, mVisibleRect, ToReferenceFrame(), flags);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
}
nsDisplayItemGeometry*
nsDisplayXULImage::AllocateGeometry(nsDisplayListBuilder* aBuilder)
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
}
void
nsDisplayXULImage::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion)
{
auto boxFrame = static_cast<nsImageBoxFrame*>(mFrame);
auto geometry =
static_cast<const nsDisplayItemGenericImageGeometry*>(aGeometry);
if (aBuilder->ShouldSyncDecodeImages() &&
boxFrame->mImageRequest &&
geometry->ShouldInvalidateToSyncDecodeImages()) {
bool snap;
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
}
nsDisplayImageContainer::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
}
bool
nsDisplayXULImage::CanOptimizeToImageLayer(LayerManager* aManager,
nsDisplayListBuilder* aBuilder)
{
nsImageBoxFrame* imageFrame = static_cast<nsImageBoxFrame*>(mFrame);
if (!imageFrame->CanOptimizeToImageLayer()) {
return false;
}
return nsDisplayImageContainer::CanOptimizeToImageLayer(aManager, aBuilder);
}
already_AddRefed<imgIContainer>
nsDisplayXULImage::GetImage()
{
nsImageBoxFrame* imageFrame = static_cast<nsImageBoxFrame*>(mFrame);
if (!imageFrame->mImageRequest) {
return nullptr;
}
nsCOMPtr<imgIContainer> imgCon;
imageFrame->mImageRequest->GetImage(getter_AddRefs(imgCon));
return imgCon.forget();
}
nsRect
nsDisplayXULImage::GetDestRect()
{
nsImageBoxFrame* imageFrame = static_cast<nsImageBoxFrame*>(mFrame);
nsRect clientRect;
imageFrame->GetXULClientRect(clientRect);
return clientRect + ToReferenceFrame();
}
bool
nsImageBoxFrame::CanOptimizeToImageLayer()
{
bool hasSubRect = !mUseSrcAttr && (mSubRect.width > 0 || mSubRect.height > 0);
if (hasSubRect) {
return false;
}
return true;
}
//
// DidSetStyleContext
//
// When the style context changes, make sure that all of our image is up to date.
//
/* virtual */ void
nsImageBoxFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
{
nsLeafBoxFrame::DidSetStyleContext(aOldStyleContext);
// Fetch our subrect.
const nsStyleList* myList = StyleList();
mSubRect = myList->mImageRegion; // before |mSuppressStyleCheck| test!
if (mUseSrcAttr || mSuppressStyleCheck)
return; // No more work required, since the image isn't specified by style.
// If we're using a native theme implementation, we shouldn't draw anything.
const nsStyleDisplay* disp = StyleDisplay();
if (disp->mAppearance && nsBox::gTheme &&
nsBox::gTheme->ThemeSupportsWidget(nullptr, this, disp->mAppearance))
return;
// If list-style-image changes, we have a new image.
nsCOMPtr<nsIURI> oldURI, newURI;
if (mImageRequest)
mImageRequest->GetURI(getter_AddRefs(oldURI));
if (myList->GetListStyleImage())
myList->GetListStyleImage()->GetURI(getter_AddRefs(newURI));
bool equal;
if (newURI == oldURI || // handles null==null
(newURI && oldURI &&
NS_SUCCEEDED(newURI->Equals(oldURI, &equal)) && equal))
return;
UpdateImage();
} // DidSetStyleContext
void
nsImageBoxFrame::GetImageSize()
{
if (mIntrinsicSize.width > 0 && mIntrinsicSize.height > 0) {
mImageSize.width = mIntrinsicSize.width;
mImageSize.height = mIntrinsicSize.height;
} else {
mImageSize.width = 0;
mImageSize.height = 0;
}
}
/**
* Ok return our dimensions
*/
nsSize
nsImageBoxFrame::GetXULPrefSize(nsBoxLayoutState& aState)
{
nsSize size(0,0);
DISPLAY_PREF_SIZE(this, size);
if (DoesNeedRecalc(mImageSize))
GetImageSize();
if (!mUseSrcAttr && (mSubRect.width > 0 || mSubRect.height > 0))
size = mSubRect.Size();
else
size = mImageSize;
nsSize intrinsicSize = size;
nsMargin borderPadding(0,0,0,0);
GetXULBorderAndPadding(borderPadding);
size.width += borderPadding.LeftRight();
size.height += borderPadding.TopBottom();
bool widthSet, heightSet;
nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet);
NS_ASSERTION(size.width != NS_INTRINSICSIZE && size.height != NS_INTRINSICSIZE,
"non-intrinsic size expected");
nsSize minSize = GetXULMinSize(aState);
nsSize maxSize = GetXULMaxSize(aState);
if (!widthSet && !heightSet) {
if (minSize.width != NS_INTRINSICSIZE)
minSize.width -= borderPadding.LeftRight();
if (minSize.height != NS_INTRINSICSIZE)
minSize.height -= borderPadding.TopBottom();
if (maxSize.width != NS_INTRINSICSIZE)
maxSize.width -= borderPadding.LeftRight();
if (maxSize.height != NS_INTRINSICSIZE)
maxSize.height -= borderPadding.TopBottom();
size = nsLayoutUtils::ComputeAutoSizeWithIntrinsicDimensions(minSize.width, minSize.height,
maxSize.width, maxSize.height,
intrinsicSize.width, intrinsicSize.height);
NS_ASSERTION(size.width != NS_INTRINSICSIZE && size.height != NS_INTRINSICSIZE,
"non-intrinsic size expected");
size.width += borderPadding.LeftRight();
size.height += borderPadding.TopBottom();
return size;
}
if (!widthSet) {
if (intrinsicSize.height > 0) {
// Subtract off the border and padding from the height because the
// content-box needs to be used to determine the ratio
nscoord height = size.height - borderPadding.TopBottom();
size.width = nscoord(int64_t(height) * int64_t(intrinsicSize.width) /
int64_t(intrinsicSize.height));
}
else {
size.width = intrinsicSize.width;
}
size.width += borderPadding.LeftRight();
}
else if (!heightSet) {
if (intrinsicSize.width > 0) {
nscoord width = size.width - borderPadding.LeftRight();
size.height = nscoord(int64_t(width) * int64_t(intrinsicSize.height) /
int64_t(intrinsicSize.width));
}
else {
size.height = intrinsicSize.height;
}
size.height += borderPadding.TopBottom();
}
return BoundsCheck(minSize, size, maxSize);
}
nsSize
nsImageBoxFrame::GetXULMinSize(nsBoxLayoutState& aState)
{
// An image can always scale down to (0,0).
nsSize size(0,0);
DISPLAY_MIN_SIZE(this, size);
AddBorderAndPadding(size);
bool widthSet, heightSet;
nsIFrame::AddXULMinSize(aState, this, size, widthSet, heightSet);
return size;
}
nscoord
nsImageBoxFrame::GetXULBoxAscent(nsBoxLayoutState& aState)
{
return GetXULPrefSize(aState).height;
}
nsIAtom*
nsImageBoxFrame::GetType() const
{
return nsGkAtoms::imageBoxFrame;
}
#ifdef DEBUG_FRAME_DUMP
nsresult
nsImageBoxFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("ImageBox"), aResult);
}
#endif
nsresult
nsImageBoxFrame::Notify(imgIRequest* aRequest,
int32_t aType,
const nsIntRect* aData)
{
if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
nsCOMPtr<imgIContainer> image;
aRequest->GetImage(getter_AddRefs(image));
return OnSizeAvailable(aRequest, image);
}
if (aType == imgINotificationObserver::DECODE_COMPLETE) {
return OnDecodeComplete(aRequest);
}
if (aType == imgINotificationObserver::LOAD_COMPLETE) {
uint32_t imgStatus;
aRequest->GetImageStatus(&imgStatus);
nsresult status =
imgStatus & imgIRequest::STATUS_ERROR ? NS_ERROR_FAILURE : NS_OK;
return OnLoadComplete(aRequest, status);
}
if (aType == imgINotificationObserver::IS_ANIMATED) {
return OnImageIsAnimated(aRequest);
}
if (aType == imgINotificationObserver::FRAME_UPDATE) {
return OnFrameUpdate(aRequest);
}
return NS_OK;
}
nsresult
nsImageBoxFrame::OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage)
{
NS_ENSURE_ARG_POINTER(aImage);
// Ensure the animation (if any) is started. Note: There is no
// corresponding call to Decrement for this. This Increment will be
// 'cleaned up' by the Request when it is destroyed, but only then.
aRequest->IncrementAnimationConsumers();
nscoord w, h;
aImage->GetWidth(&w);
aImage->GetHeight(&h);
mIntrinsicSize.SizeTo(nsPresContext::CSSPixelsToAppUnits(w),
nsPresContext::CSSPixelsToAppUnits(h));
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
PresContext()->PresShell()->
FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
}
return NS_OK;
}
nsresult
nsImageBoxFrame::OnDecodeComplete(imgIRequest* aRequest)
{
nsBoxLayoutState state(PresContext());
this->XULRedraw(state);
return NS_OK;
}
nsresult
nsImageBoxFrame::OnLoadComplete(imgIRequest* aRequest, nsresult aStatus)
{
if (NS_SUCCEEDED(aStatus)) {
// Fire an onload DOM event.
FireImageDOMEvent(mContent, eLoad);
} else {
// Fire an onerror DOM event.
mIntrinsicSize.SizeTo(0, 0);
PresContext()->PresShell()->
FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
FireImageDOMEvent(mContent, eLoadError);
}
return NS_OK;
}
nsresult
nsImageBoxFrame::OnImageIsAnimated(imgIRequest* aRequest)
{
// Register with our refresh driver, if we're animated.
nsLayoutUtils::RegisterImageRequest(PresContext(), aRequest,
&mRequestRegistered);
return NS_OK;
}
nsresult
nsImageBoxFrame::OnFrameUpdate(imgIRequest* aRequest)
{
if ((0 == mRect.width) || (0 == mRect.height)) {
return NS_OK;
}
InvalidateLayer(nsDisplayItem::TYPE_XUL_IMAGE);
return NS_OK;
}
NS_IMPL_ISUPPORTS(nsImageBoxListener, imgINotificationObserver, imgIOnloadBlocker)
nsImageBoxListener::nsImageBoxListener()
{
}
nsImageBoxListener::~nsImageBoxListener()
{
}
NS_IMETHODIMP
nsImageBoxListener::Notify(imgIRequest *request, int32_t aType, const nsIntRect* aData)
{
if (!mFrame)
return NS_OK;
return mFrame->Notify(request, aType, aData);
}
NS_IMETHODIMP
nsImageBoxListener::BlockOnload(imgIRequest *aRequest)
{
if (mFrame && mFrame->GetContent() && mFrame->GetContent()->GetUncomposedDoc()) {
mFrame->GetContent()->GetUncomposedDoc()->BlockOnload();
}
return NS_OK;
}
NS_IMETHODIMP
nsImageBoxListener::UnblockOnload(imgIRequest *aRequest)
{
if (mFrame && mFrame->GetContent() && mFrame->GetContent()->GetUncomposedDoc()) {
mFrame->GetContent()->GetUncomposedDoc()->UnblockOnload(false);
}
return NS_OK;
}
Reference in New Issue View Git Blame Copy Permalink