mirror of
https://github.com/ManchildProductions/UXP-Fixed.git
synced 2026-06-18 00:18:34 +00:00
win7-7
cbb61ab832
Part 1: Remove current table item, as it's never set. Part 2: Get rid of generic table painting code, and handle each class separately. Part 4: Hoist outline skipping into col(group) frame code. Part 5: Skip box-shadow for table column and column groups. Part 6: Store column and column group backgrounds separately, and then append them before the rest of the table contents. Part 7: Pass rects in display list coordinates to AppendBackgroundItemsToTop. Part 8: Create column and column group background display items as part of the cell's BuildDisplayList. Part 9: Used cached values instead of calling nsDisplayListBuilder::ToReferenceFrame when possible, since it can be expensive when the requested frame isn't the builder's current frame. Part 10: Make sure we build display items for table parts where only the normal position is visible, since we may need to create background items for ancestors at that position. Part 11: Create an AutoBuildingDisplayList when we create background items for table columns and column groups, so that we initialize the invalidation state correctly.
744 lines
25 KiB
C++
744 lines
25 KiB
C++
/* -*- 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/. */
|
|
|
|
/* rendering object that goes directly inside the document's scrollbars */
|
|
|
|
#include "nsCanvasFrame.h"
|
|
|
|
#include "AccessibleCaretEventHub.h"
|
|
#include "gfxUtils.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsStyleContext.h"
|
|
#include "nsRenderingContext.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsPresShell.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsCSSFrameConstructor.h"
|
|
#include "nsFrameManager.h"
|
|
#include "gfxPlatform.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "mozilla/dom/AnonymousContent.h"
|
|
// for focus
|
|
#include "nsIScrollableFrame.h"
|
|
#ifdef DEBUG_CANVAS_FOCUS
|
|
#include "nsIDocShell.h"
|
|
#endif
|
|
|
|
//#define DEBUG_CANVAS_FOCUS
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::layout;
|
|
using namespace mozilla::gfx;
|
|
|
|
nsCanvasFrame*
|
|
NS_NewCanvasFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsCanvasFrame(aContext);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsCanvasFrame)
|
|
|
|
NS_QUERYFRAME_HEAD(nsCanvasFrame)
|
|
NS_QUERYFRAME_ENTRY(nsCanvasFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
|
|
|
|
void
|
|
nsCanvasFrame::ShowCustomContentContainer()
|
|
{
|
|
if (mCustomContentContainer) {
|
|
mCustomContentContainer->UnsetAttr(kNameSpaceID_None, nsGkAtoms::hidden, true);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::HideCustomContentContainer()
|
|
{
|
|
if (mCustomContentContainer) {
|
|
mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::hidden,
|
|
NS_LITERAL_STRING("true"),
|
|
true);
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsCanvasFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
|
|
{
|
|
if (!mContent) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> doc = mContent->OwnerDoc();
|
|
nsresult rv = NS_OK;
|
|
|
|
// Create the custom content container.
|
|
mCustomContentContainer = doc->CreateHTMLElement(nsGkAtoms::div);
|
|
#ifdef DEBUG
|
|
// We restyle our mCustomContentContainer, even though it's root anonymous
|
|
// content. Normally that's not OK because the frame constructor doesn't know
|
|
// how to order the frame tree in such cases, but we make this work for this
|
|
// particular case, so it's OK.
|
|
mCustomContentContainer->SetProperty(nsGkAtoms::restylableAnonymousNode,
|
|
reinterpret_cast<void*>(true));
|
|
#endif // DEBUG
|
|
|
|
aElements.AppendElement(mCustomContentContainer);
|
|
|
|
// XXX add :moz-native-anonymous or will that be automatically set?
|
|
rv = mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::_class,
|
|
NS_LITERAL_STRING("moz-custom-content-container"),
|
|
true);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Append all existing AnonymousContent nodes stored at document level if any.
|
|
size_t len = doc->GetAnonymousContents().Length();
|
|
for (size_t i = 0; i < len; ++i) {
|
|
nsCOMPtr<Element> node = doc->GetAnonymousContents()[i]->GetContentNode();
|
|
mCustomContentContainer->AppendChildTo(node->AsContent(), true);
|
|
}
|
|
|
|
// Only create a frame for mCustomContentContainer if it has some children.
|
|
if (len == 0) {
|
|
HideCustomContentContainer();
|
|
}
|
|
|
|
RefPtr<AccessibleCaretEventHub> eventHub =
|
|
PresContext()->GetPresShell()->GetAccessibleCaretEventHub();
|
|
if (eventHub) {
|
|
// AccessibleCaret will insert anonymous caret elements.
|
|
eventHub->Init();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements, uint32_t aFilter)
|
|
{
|
|
aElements.AppendElement(mCustomContentContainer);
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::DestroyFrom(nsIFrame* aDestructRoot)
|
|
{
|
|
nsIScrollableFrame* sf =
|
|
PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();
|
|
if (sf) {
|
|
sf->RemoveScrollPositionListener(this);
|
|
}
|
|
|
|
// Elements inserted in the custom content container have the same lifetime as
|
|
// the document, so before destroying the container, make sure to keep a clone
|
|
// of each of them at document level so they can be re-appended on reframe.
|
|
if (mCustomContentContainer) {
|
|
nsCOMPtr<nsIDocument> doc = mContent->OwnerDoc();
|
|
ErrorResult rv;
|
|
|
|
nsTArray<RefPtr<mozilla::dom::AnonymousContent>>& docAnonContents =
|
|
doc->GetAnonymousContents();
|
|
for (size_t i = 0, len = docAnonContents.Length(); i < len; ++i) {
|
|
AnonymousContent* content = docAnonContents[i];
|
|
nsCOMPtr<nsINode> clonedElement = content->GetContentNode()->CloneNode(true, rv);
|
|
content->SetContentNode(clonedElement->AsElement());
|
|
}
|
|
}
|
|
nsContentUtils::DestroyAnonymousContent(&mCustomContentContainer);
|
|
|
|
nsContainerFrame::DestroyFrom(aDestructRoot);
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::ScrollPositionWillChange(nscoord aX, nscoord aY)
|
|
{
|
|
if (mDoPaintFocus) {
|
|
mDoPaintFocus = false;
|
|
PresContext()->FrameManager()->GetRootFrame()->InvalidateFrameSubtree();
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCanvasFrame::SetHasFocus(bool aHasFocus)
|
|
{
|
|
if (mDoPaintFocus != aHasFocus) {
|
|
mDoPaintFocus = aHasFocus;
|
|
PresContext()->FrameManager()->GetRootFrame()->InvalidateFrameSubtree();
|
|
|
|
if (!mAddedScrollPositionListener) {
|
|
nsIScrollableFrame* sf =
|
|
PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();
|
|
if (sf) {
|
|
sf->AddScrollPositionListener(this);
|
|
mAddedScrollPositionListener = true;
|
|
}
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsCanvasFrame::SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList)
|
|
{
|
|
NS_ASSERTION(aListID != kPrincipalList ||
|
|
aChildList.IsEmpty() || aChildList.OnlyChild(),
|
|
"Primary child list can have at most one frame in it");
|
|
nsContainerFrame::SetInitialChildList(aListID, aChildList);
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
|
|
if (!mFrames.IsEmpty()) {
|
|
for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
|
|
// We only allow native anonymous child frames to be in principal child
|
|
// list in canvas frame.
|
|
MOZ_ASSERT(e.get()->GetContent()->IsInNativeAnonymousSubtree(),
|
|
"invalid child list");
|
|
}
|
|
}
|
|
nsFrame::VerifyDirtyBitSet(aFrameList);
|
|
nsContainerFrame::AppendFrames(aListID, aFrameList);
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::InsertFrames(ChildListID aListID,
|
|
nsIFrame* aPrevFrame,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
// Because we only support a single child frame inserting is the same
|
|
// as appending
|
|
MOZ_ASSERT(!aPrevFrame, "unexpected previous sibling frame");
|
|
AppendFrames(aListID, aFrameList);
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::RemoveFrame(ChildListID aListID,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
|
|
nsContainerFrame::RemoveFrame(aListID, aOldFrame);
|
|
}
|
|
#endif
|
|
|
|
nsRect nsCanvasFrame::CanvasArea() const
|
|
{
|
|
// Not clear which overflow rect we want here, but it probably doesn't
|
|
// matter.
|
|
nsRect result(GetVisualOverflowRect());
|
|
|
|
nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());
|
|
if (scrollableFrame) {
|
|
nsRect portRect = scrollableFrame->GetScrollPortRect();
|
|
result.UnionRect(result, nsRect(nsPoint(0, 0), portRect.Size()));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void
|
|
nsDisplayCanvasBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx)
|
|
{
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
|
nsPoint offset = ToReferenceFrame();
|
|
nsRect bgClipRect = frame->CanvasArea() + offset;
|
|
if (NS_GET_A(mColor) > 0) {
|
|
DrawTarget* drawTarget = aCtx->GetDrawTarget();
|
|
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
|
|
Rect devPxRect =
|
|
NSRectToSnappedRect(bgClipRect, appUnitsPerDevPixel, *drawTarget);
|
|
drawTarget->FillRect(devPxRect, ColorPattern(ToDeviceColor(mColor)));
|
|
}
|
|
}
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
void
|
|
nsDisplayCanvasBackgroundColor::WriteDebugInfo(std::stringstream& aStream)
|
|
{
|
|
aStream << " (rgba "
|
|
<< (int)NS_GET_R(mColor) << ","
|
|
<< (int)NS_GET_G(mColor) << ","
|
|
<< (int)NS_GET_B(mColor) << ","
|
|
<< (int)NS_GET_A(mColor) << ")";
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
|
|
static void BlitSurface(DrawTarget* aDest, const gfxRect& aRect, DrawTarget* aSource)
|
|
{
|
|
RefPtr<SourceSurface> source = aSource->Snapshot();
|
|
aDest->DrawSurface(source,
|
|
Rect(aRect.x, aRect.y, aRect.width, aRect.height),
|
|
Rect(0, 0, aRect.width, aRect.height));
|
|
}
|
|
#endif
|
|
|
|
void
|
|
nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx)
|
|
{
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
|
nsPoint offset = ToReferenceFrame();
|
|
nsRect bgClipRect = frame->CanvasArea() + offset;
|
|
|
|
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
|
|
RefPtr<gfxContext> dest = aCtx->ThebesContext();
|
|
gfxRect destRect;
|
|
if (IsSingleFixedPositionImage(aBuilder, bgClipRect, &destRect) &&
|
|
aBuilder->IsPaintingToWindow() && !aBuilder->IsCompositingCheap() &&
|
|
!dest->CurrentMatrix().HasNonIntegerTranslation()) {
|
|
// Snap image rectangle to nearest pixel boundaries. This is the right way
|
|
// to snap for this context, because we checked HasNonIntegerTranslation
|
|
// above.
|
|
destRect.Round();
|
|
RefPtr<DrawTarget> dt =
|
|
Frame()->GetProperty(nsIFrame::CachedBackgroundImageDT());
|
|
DrawTarget* destDT = dest->GetDrawTarget();
|
|
if (dt) {
|
|
BlitSurface(destDT, destRect, dt);
|
|
return;
|
|
}
|
|
|
|
dt = destDT->CreateSimilarDrawTarget(IntSize::Ceil(destRect.width,
|
|
destRect.height),
|
|
SurfaceFormat::B8G8R8A8);
|
|
if (dt && dt->IsValid()) {
|
|
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(dt);
|
|
MOZ_ASSERT(ctx); // already checked draw target above
|
|
ctx->SetMatrix(ctx->CurrentMatrix().Translate(-destRect.x, -destRect.y));
|
|
nsRenderingContext context(ctx);
|
|
PaintInternal(aBuilder, &context, bgClipRect, &bgClipRect);
|
|
BlitSurface(dest->GetDrawTarget(), destRect, dt);
|
|
frame->SetProperty(nsIFrame::CachedBackgroundImageDT(),
|
|
dt.forget().take());
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
|
|
}
|
|
|
|
bool
|
|
nsDisplayCanvasBackgroundImage::IsSingleFixedPositionImage(nsDisplayListBuilder* aBuilder,
|
|
const nsRect& aClipRect,
|
|
gfxRect* aDestRect)
|
|
{
|
|
if (!mBackgroundStyle)
|
|
return false;
|
|
|
|
if (mBackgroundStyle->mImage.mLayers.Length() != 1)
|
|
return false;
|
|
|
|
|
|
nsPresContext* presContext = mFrame->PresContext();
|
|
uint32_t flags = aBuilder->GetBackgroundPaintFlags();
|
|
nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());
|
|
const nsStyleImageLayers::Layer &layer = mBackgroundStyle->mImage.mLayers[mLayer];
|
|
|
|
if (layer.mAttachment != NS_STYLE_IMAGELAYER_ATTACHMENT_FIXED)
|
|
return false;
|
|
|
|
nsBackgroundLayerState state =
|
|
nsCSSRendering::PrepareImageLayer(presContext, mFrame, flags,
|
|
borderArea, aClipRect, layer);
|
|
|
|
|
|
// We only care about images here, not gradients.
|
|
if (!mIsRasterImage)
|
|
return false;
|
|
|
|
int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
|
|
*aDestRect = nsLayoutUtils::RectToGfxRect(state.mFillArea, appUnitsPerDevPixel);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
nsDisplayCanvasThemedBackground::Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx)
|
|
{
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
|
nsPoint offset = ToReferenceFrame();
|
|
nsRect bgClipRect = frame->CanvasArea() + offset;
|
|
|
|
PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
|
|
}
|
|
|
|
/**
|
|
* A display item to paint the focus ring for the document.
|
|
*
|
|
* The only reason this can't use nsDisplayGeneric is overriding GetBounds.
|
|
*/
|
|
class nsDisplayCanvasFocus : public nsDisplayItem {
|
|
public:
|
|
nsDisplayCanvasFocus(nsDisplayListBuilder* aBuilder, nsCanvasFrame *aFrame)
|
|
: nsDisplayItem(aBuilder, aFrame)
|
|
{
|
|
MOZ_COUNT_CTOR(nsDisplayCanvasFocus);
|
|
}
|
|
virtual ~nsDisplayCanvasFocus() {
|
|
MOZ_COUNT_DTOR(nsDisplayCanvasFocus);
|
|
}
|
|
|
|
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
|
|
bool* aSnap) override
|
|
{
|
|
*aSnap = false;
|
|
// This is an overestimate, but that's not a problem.
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
|
return frame->CanvasArea() + ToReferenceFrame();
|
|
}
|
|
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx) override
|
|
{
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
|
frame->PaintFocus(aCtx->GetDrawTarget(), ToReferenceFrame());
|
|
}
|
|
|
|
NS_DISPLAY_DECL_NAME("CanvasFocus", TYPE_CANVAS_FOCUS)
|
|
};
|
|
|
|
void
|
|
nsCanvasFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists)
|
|
{
|
|
if (GetPrevInFlow()) {
|
|
DisplayOverflowContainers(aBuilder, aLists);
|
|
}
|
|
|
|
// Force a background to be shown. We may have a background propagated to us,
|
|
// in which case StyleBackground wouldn't have the right background
|
|
// and the code in nsFrame::DisplayBorderBackgroundOutline might not give us
|
|
// a background.
|
|
// We don't have any border or outline, and our background draws over
|
|
// the overflow area, so just add nsDisplayCanvasBackground instead of
|
|
// calling DisplayBorderBackgroundOutline.
|
|
if (IsVisibleForPainting(aBuilder)) {
|
|
nsStyleContext* bgSC;
|
|
const nsStyleBackground* bg = nullptr;
|
|
bool isThemed = IsThemed();
|
|
if (!isThemed && nsCSSRendering::FindBackground(this, &bgSC)) {
|
|
bg = bgSC->StyleBackground();
|
|
}
|
|
aLists.BorderBackground()->AppendNewToTop(
|
|
new (aBuilder) nsDisplayCanvasBackgroundColor(aBuilder, this));
|
|
|
|
if (isThemed) {
|
|
aLists.BorderBackground()->AppendNewToTop(
|
|
new (aBuilder) nsDisplayCanvasThemedBackground(aBuilder, this));
|
|
return;
|
|
}
|
|
|
|
if (!bg) {
|
|
return;
|
|
}
|
|
|
|
const DisplayItemScrollClip* scrollClip =
|
|
aBuilder->ClipState().GetCurrentInnermostScrollClip();
|
|
|
|
bool needBlendContainer = false;
|
|
|
|
// Create separate items for each background layer.
|
|
const nsStyleImageLayers& layers = bg->mImage;
|
|
NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, layers) {
|
|
if (layers.mLayers[i].mImage.IsEmpty()) {
|
|
continue;
|
|
}
|
|
if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {
|
|
needBlendContainer = true;
|
|
}
|
|
|
|
nsDisplayList thisItemList;
|
|
nsDisplayCanvasBackgroundImage* bgItem =
|
|
new (aBuilder) nsDisplayCanvasBackgroundImage(aBuilder, this, i, bg);
|
|
if (bgItem->ShouldFixToViewport(aBuilder)) {
|
|
thisItemList.AppendNewToTop(
|
|
nsDisplayFixedPosition::CreateForFixedBackground(aBuilder, this, bgItem, i));
|
|
} else {
|
|
thisItemList.AppendNewToTop(bgItem);
|
|
}
|
|
|
|
if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {
|
|
thisItemList.AppendNewToTop(
|
|
new (aBuilder) nsDisplayBlendMode(aBuilder, this, &thisItemList,
|
|
layers.mLayers[i].mBlendMode,
|
|
scrollClip, i + 1));
|
|
}
|
|
aLists.BorderBackground()->AppendToTop(&thisItemList);
|
|
}
|
|
|
|
if (needBlendContainer) {
|
|
aLists.BorderBackground()->AppendNewToTop(
|
|
nsDisplayBlendContainer::CreateForBackgroundBlendMode(aBuilder, this,
|
|
aLists.BorderBackground(),
|
|
scrollClip));
|
|
}
|
|
}
|
|
|
|
for (nsIFrame* kid : PrincipalChildList()) {
|
|
// Put our child into its own pseudo-stack.
|
|
BuildDisplayListForChild(aBuilder, kid, aLists);
|
|
}
|
|
|
|
#ifdef DEBUG_CANVAS_FOCUS
|
|
nsCOMPtr<nsIContent> focusContent;
|
|
aPresContext->EventStateManager()->
|
|
GetFocusedContent(getter_AddRefs(focusContent));
|
|
|
|
bool hasFocus = false;
|
|
nsCOMPtr<nsISupports> container;
|
|
aPresContext->GetContainer(getter_AddRefs(container));
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
|
|
if (docShell) {
|
|
docShell->GetHasFocus(&hasFocus);
|
|
printf("%p - nsCanvasFrame::Paint R:%d,%d,%d,%d DR: %d,%d,%d,%d\n", this,
|
|
mRect.x, mRect.y, mRect.width, mRect.height,
|
|
dirty.x, dirty.y, dirty.width, dirty.height);
|
|
}
|
|
printf("%p - Focus: %s c: %p DoPaint:%s\n", docShell.get(), hasFocus?"Y":"N",
|
|
focusContent.get(), mDoPaintFocus?"Y":"N");
|
|
#endif
|
|
|
|
if (!mDoPaintFocus)
|
|
return;
|
|
// Only paint the focus if we're visible
|
|
if (!StyleVisibility()->IsVisible())
|
|
return;
|
|
|
|
aLists.Outlines()->AppendNewToTop(new (aBuilder)
|
|
nsDisplayCanvasFocus(aBuilder, this));
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::PaintFocus(DrawTarget* aDrawTarget, nsPoint aPt)
|
|
{
|
|
nsRect focusRect(aPt, GetSize());
|
|
|
|
nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());
|
|
if (scrollableFrame) {
|
|
nsRect portRect = scrollableFrame->GetScrollPortRect();
|
|
focusRect.width = portRect.width;
|
|
focusRect.height = portRect.height;
|
|
focusRect.MoveBy(scrollableFrame->GetScrollPosition());
|
|
}
|
|
|
|
// XXX use the root frame foreground color, but should we find BODY frame
|
|
// for HTML documents?
|
|
nsIFrame* root = mFrames.FirstChild();
|
|
const nsStyleColor* color = root ? root->StyleColor() : StyleColor();
|
|
if (!color) {
|
|
NS_ERROR("current color cannot be found");
|
|
return;
|
|
}
|
|
|
|
nsCSSRendering::PaintFocus(PresContext(), aDrawTarget,
|
|
focusRect, color->mColor);
|
|
}
|
|
|
|
/* virtual */ nscoord
|
|
nsCanvasFrame::GetMinISize(nsRenderingContext *aRenderingContext)
|
|
{
|
|
nscoord result;
|
|
DISPLAY_MIN_WIDTH(this, result);
|
|
if (mFrames.IsEmpty())
|
|
result = 0;
|
|
else
|
|
result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
|
|
return result;
|
|
}
|
|
|
|
/* virtual */ nscoord
|
|
nsCanvasFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
|
|
{
|
|
nscoord result;
|
|
DISPLAY_PREF_WIDTH(this, result);
|
|
if (mFrames.IsEmpty())
|
|
result = 0;
|
|
else
|
|
result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
|
|
return result;
|
|
}
|
|
|
|
void
|
|
nsCanvasFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
|
|
NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow");
|
|
|
|
// Initialize OUT parameter
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
nsCanvasFrame* prevCanvasFrame = static_cast<nsCanvasFrame*>
|
|
(GetPrevInFlow());
|
|
if (prevCanvasFrame) {
|
|
AutoFrameListPtr overflow(aPresContext,
|
|
prevCanvasFrame->StealOverflowFrames());
|
|
if (overflow) {
|
|
NS_ASSERTION(overflow->OnlyChild(),
|
|
"must have doc root as canvas frame's only child");
|
|
nsContainerFrame::ReparentFrameViewList(*overflow, prevCanvasFrame, this);
|
|
// Prepend overflow to the our child list. There may already be
|
|
// children placeholders for fixed-pos elements, which don't get
|
|
// reflowed but must not be lost until the canvas frame is destroyed.
|
|
mFrames.InsertFrames(this, nullptr, *overflow);
|
|
}
|
|
}
|
|
|
|
// Set our size up front, since some parts of reflow depend on it
|
|
// being already set. Note that the computed height may be
|
|
// unconstrained; that's ok. Consumers should watch out for that.
|
|
SetSize(nsSize(aReflowInput.ComputedWidth(), aReflowInput.ComputedHeight()));
|
|
|
|
// Reflow our one and only normal child frame. It's either the root
|
|
// element's frame or a placeholder for that frame, if the root element
|
|
// is abs-pos or fixed-pos. We may have additional children which
|
|
// are placeholders for continuations of fixed-pos content, but those
|
|
// don't need to be reflowed. The normal child is always comes before
|
|
// the fixed-pos placeholders, because we insert it at the start
|
|
// of the child list, above.
|
|
ReflowOutput kidDesiredSize(aReflowInput);
|
|
if (mFrames.IsEmpty()) {
|
|
// We have no child frame, so return an empty size
|
|
aDesiredSize.Width() = aDesiredSize.Height() = 0;
|
|
} else {
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
|
bool kidDirty = (kidFrame->GetStateBits() & NS_FRAME_IS_DIRTY) != 0;
|
|
|
|
ReflowInput
|
|
kidReflowInput(aPresContext, aReflowInput, kidFrame,
|
|
aReflowInput.AvailableSize(kidFrame->GetWritingMode()));
|
|
|
|
if (aReflowInput.IsBResizeForWM(kidReflowInput.GetWritingMode()) &&
|
|
(kidFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
|
|
// Tell our kid it's being block-dir resized too. Bit of a
|
|
// hack for framesets.
|
|
kidReflowInput.SetBResize(true);
|
|
}
|
|
|
|
WritingMode wm = aReflowInput.GetWritingMode();
|
|
WritingMode kidWM = kidReflowInput.GetWritingMode();
|
|
nsSize containerSize = aReflowInput.ComputedPhysicalSize();
|
|
|
|
LogicalMargin margin = kidReflowInput.ComputedLogicalMargin();
|
|
LogicalPoint kidPt(kidWM, margin.IStart(kidWM), margin.BStart(kidWM));
|
|
|
|
kidReflowInput.ApplyRelativePositioning(&kidPt, containerSize);
|
|
|
|
// Reflow the frame
|
|
ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowInput,
|
|
kidWM, kidPt, containerSize, 0, aStatus);
|
|
|
|
// Complete the reflow and position and size the child frame
|
|
FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, &kidReflowInput,
|
|
kidWM, kidPt, containerSize, 0);
|
|
|
|
if (!NS_FRAME_IS_FULLY_COMPLETE(aStatus)) {
|
|
nsIFrame* nextFrame = kidFrame->GetNextInFlow();
|
|
NS_ASSERTION(nextFrame || aStatus & NS_FRAME_REFLOW_NEXTINFLOW,
|
|
"If it's incomplete and has no nif yet, it must flag a nif reflow.");
|
|
if (!nextFrame) {
|
|
nextFrame = aPresContext->PresShell()->FrameConstructor()->
|
|
CreateContinuingFrame(aPresContext, kidFrame, this);
|
|
SetOverflowFrames(nsFrameList(nextFrame, nextFrame));
|
|
// Root overflow containers will be normal children of
|
|
// the canvas frame, but that's ok because there
|
|
// aren't any other frames we need to isolate them from
|
|
// during reflow.
|
|
}
|
|
if (NS_FRAME_OVERFLOW_IS_INCOMPLETE(aStatus)) {
|
|
nextFrame->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
|
|
}
|
|
}
|
|
|
|
// If the child frame was just inserted, then we're responsible for making sure
|
|
// it repaints
|
|
if (kidDirty) {
|
|
// But we have a new child, which will affect our background, so
|
|
// invalidate our whole rect.
|
|
// Note: Even though we request to be sized to our child's size, our
|
|
// scroll frame ensures that we are always the size of the viewport.
|
|
// Also note: GetPosition() on a CanvasFrame is always going to return
|
|
// (0, 0). We only want to invalidate GetRect() since Get*OverflowRect()
|
|
// could also include overflow to our top and left (out of the viewport)
|
|
// which doesn't need to be painted.
|
|
nsIFrame* viewport = PresContext()->GetPresShell()->GetRootFrame();
|
|
viewport->InvalidateFrame();
|
|
}
|
|
|
|
// Return our desired size. Normally it's what we're told, but
|
|
// sometimes we can be given an unconstrained height (when a window
|
|
// is sizing-to-content), and we should compute our desired height.
|
|
LogicalSize finalSize(wm);
|
|
finalSize.ISize(wm) = aReflowInput.ComputedISize();
|
|
if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE) {
|
|
finalSize.BSize(wm) = kidFrame->GetLogicalSize(wm).BSize(wm) +
|
|
kidReflowInput.ComputedLogicalMargin().BStartEnd(wm);
|
|
} else {
|
|
finalSize.BSize(wm) = aReflowInput.ComputedBSize();
|
|
}
|
|
|
|
aDesiredSize.SetSize(wm, finalSize);
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
aDesiredSize.mOverflowAreas.UnionWith(
|
|
kidDesiredSize.mOverflowAreas + kidFrame->GetPosition());
|
|
}
|
|
|
|
if (prevCanvasFrame) {
|
|
ReflowOverflowContainerChildren(aPresContext, aReflowInput,
|
|
aDesiredSize.mOverflowAreas, 0,
|
|
aStatus);
|
|
}
|
|
|
|
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);
|
|
|
|
NS_FRAME_TRACE_REFLOW_OUT("nsCanvasFrame::Reflow", aStatus);
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
|
|
}
|
|
|
|
nsIAtom*
|
|
nsCanvasFrame::GetType() const
|
|
{
|
|
return nsGkAtoms::canvasFrame;
|
|
}
|
|
|
|
nsresult
|
|
nsCanvasFrame::GetContentForEvent(WidgetEvent* aEvent,
|
|
nsIContent** aContent)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aContent);
|
|
nsresult rv = nsFrame::GetContentForEvent(aEvent,
|
|
aContent);
|
|
if (NS_FAILED(rv) || !*aContent) {
|
|
nsIFrame* kid = mFrames.FirstChild();
|
|
if (kid) {
|
|
rv = kid->GetContentForEvent(aEvent,
|
|
aContent);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult
|
|
nsCanvasFrame::GetFrameName(nsAString& aResult) const
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("Canvas"), aResult);
|
|
}
|
|
#endif
|