2001-09-28 20:14:13 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2006-03-29 18:29:03 +00:00
|
|
|
|
|
|
|
/* rendering object that goes directly inside the document's scrollbars */
|
|
|
|
|
2009-10-08 06:18:18 +00:00
|
|
|
#include "nsCanvasFrame.h"
|
2014-10-19 12:22:22 +00:00
|
|
|
|
2015-11-16 10:16:43 +00:00
|
|
|
#include "AccessibleCaretEventHub.h"
|
2014-10-19 12:22:22 +00:00
|
|
|
#include "gfxUtils.h"
|
2011-12-27 20:18:48 +00:00
|
|
|
#include "nsContainerFrame.h"
|
1998-09-25 23:39:06 +00:00
|
|
|
#include "nsCSSRendering.h"
|
2004-07-31 23:15:21 +00:00
|
|
|
#include "nsPresContext.h"
|
2003-02-22 00:32:13 +00:00
|
|
|
#include "nsStyleContext.h"
|
2011-04-08 01:04:40 +00:00
|
|
|
#include "nsRenderingContext.h"
|
2007-01-30 00:06:41 +00:00
|
|
|
#include "nsGkAtoms.h"
|
2014-06-03 07:08:25 +00:00
|
|
|
#include "nsPresShell.h"
|
1999-07-27 14:15:42 +00:00
|
|
|
#include "nsIPresShell.h"
|
2006-01-26 02:29:17 +00:00
|
|
|
#include "nsDisplayList.h"
|
2009-09-18 11:09:35 +00:00
|
|
|
#include "nsCSSFrameConstructor.h"
|
2009-09-03 04:10:13 +00:00
|
|
|
#include "nsFrameManager.h"
|
2013-08-27 02:08:05 +00:00
|
|
|
#include "gfxPlatform.h"
|
2014-06-03 20:21:39 +00:00
|
|
|
#include "nsPrintfCString.h"
|
2014-10-28 10:15:25 +00:00
|
|
|
#include "mozilla/dom/AnonymousContent.h"
|
2001-05-22 23:52:17 +00:00
|
|
|
// for focus
|
|
|
|
#include "nsIScrollableFrame.h"
|
2013-08-22 18:32:52 +00:00
|
|
|
#ifdef DEBUG_CANVAS_FOCUS
|
2001-05-22 23:52:17 +00:00
|
|
|
#include "nsIDocShell.h"
|
2013-08-22 18:32:52 +00:00
|
|
|
#endif
|
2001-05-22 23:52:17 +00:00
|
|
|
|
|
|
|
//#define DEBUG_CANVAS_FOCUS
|
1998-10-19 00:44:28 +00:00
|
|
|
|
2013-10-02 03:46:04 +00:00
|
|
|
using namespace mozilla;
|
2014-10-28 10:15:25 +00:00
|
|
|
using namespace mozilla::dom;
|
2013-04-01 15:26:02 +00:00
|
|
|
using namespace mozilla::layout;
|
2013-10-02 09:12:34 +00:00
|
|
|
using namespace mozilla::gfx;
|
1998-09-08 22:34:40 +00:00
|
|
|
|
2014-05-24 22:20:40 +00:00
|
|
|
nsCanvasFrame*
|
2006-03-26 21:30:36 +00:00
|
|
|
NS_NewCanvasFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
1998-09-08 22:34:40 +00:00
|
|
|
{
|
2009-10-08 06:18:18 +00:00
|
|
|
return new (aPresShell) nsCanvasFrame(aContext);
|
1998-09-08 22:34:40 +00:00
|
|
|
}
|
|
|
|
|
2009-10-08 06:18:18 +00:00
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsCanvasFrame)
|
2009-09-12 16:49:24 +00:00
|
|
|
|
2009-10-08 06:18:18 +00:00
|
|
|
NS_QUERYFRAME_HEAD(nsCanvasFrame)
|
|
|
|
NS_QUERYFRAME_ENTRY(nsCanvasFrame)
|
2014-06-03 07:08:25 +00:00
|
|
|
NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
|
2011-12-27 20:18:48 +00:00
|
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
|
2001-05-22 23:52:17 +00:00
|
|
|
|
2015-01-20 18:20:04 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-03 07:08:25 +00:00
|
|
|
nsresult
|
|
|
|
nsCanvasFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
|
|
|
|
{
|
2014-06-04 20:58:00 +00:00
|
|
|
if (!mContent) {
|
2014-06-03 07:08:25 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc = mContent->OwnerDoc();
|
2014-06-04 20:58:00 +00:00
|
|
|
nsresult rv = NS_OK;
|
2014-06-03 07:08:25 +00:00
|
|
|
|
2014-10-28 10:15:25 +00:00
|
|
|
// Create the custom content container.
|
|
|
|
mCustomContentContainer = doc->CreateHTMLElement(nsGkAtoms::div);
|
2015-07-23 15:51:09 +00:00
|
|
|
#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
|
|
|
|
|
2014-10-28 10:15:25 +00:00
|
|
|
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.
|
2015-01-13 14:44:33 +00:00
|
|
|
size_t len = doc->GetAnonymousContents().Length();
|
|
|
|
for (size_t i = 0; i < len; ++i) {
|
2014-10-28 10:15:25 +00:00
|
|
|
nsCOMPtr<Element> node = doc->GetAnonymousContents()[i]->GetContentNode();
|
|
|
|
mCustomContentContainer->AppendChildTo(node->AsContent(), true);
|
|
|
|
}
|
|
|
|
|
2015-01-20 18:20:04 +00:00
|
|
|
// Only create a frame for mCustomContentContainer if it has some children.
|
|
|
|
if (len == 0) {
|
|
|
|
HideCustomContentContainer();
|
|
|
|
}
|
|
|
|
|
2015-11-16 10:16:43 +00:00
|
|
|
RefPtr<AccessibleCaretEventHub> eventHub =
|
|
|
|
PresContext()->GetPresShell()->GetAccessibleCaretEventHub();
|
|
|
|
if (eventHub) {
|
|
|
|
// AccessibleCaret will insert anonymous caret elements.
|
|
|
|
eventHub->Init();
|
|
|
|
}
|
|
|
|
|
2014-06-03 07:08:25 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-07-16 18:41:57 +00:00
|
|
|
nsCanvasFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements, uint32_t aFilter)
|
2014-06-03 07:08:25 +00:00
|
|
|
{
|
2014-10-28 10:15:25 +00:00
|
|
|
aElements.AppendElement(mCustomContentContainer);
|
2014-06-03 07:08:25 +00:00
|
|
|
}
|
|
|
|
|
2006-04-10 00:16:29 +00:00
|
|
|
void
|
2009-12-24 05:21:15 +00:00
|
|
|
nsCanvasFrame::DestroyFrom(nsIFrame* aDestructRoot)
|
2002-07-09 04:30:28 +00:00
|
|
|
{
|
2009-09-03 04:10:13 +00:00
|
|
|
nsIScrollableFrame* sf =
|
|
|
|
PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();
|
|
|
|
if (sf) {
|
|
|
|
sf->RemoveScrollPositionListener(this);
|
2002-07-09 04:30:28 +00:00
|
|
|
}
|
2001-05-22 23:52:17 +00:00
|
|
|
|
2014-10-28 10:15:25 +00:00
|
|
|
// 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;
|
|
|
|
|
2015-10-18 05:24:48 +00:00
|
|
|
nsTArray<RefPtr<mozilla::dom::AnonymousContent>>& docAnonContents =
|
2015-01-13 14:44:33 +00:00
|
|
|
doc->GetAnonymousContents();
|
|
|
|
for (size_t i = 0, len = docAnonContents.Length(); i < len; ++i) {
|
|
|
|
AnonymousContent* content = docAnonContents[i];
|
2014-10-28 10:15:25 +00:00
|
|
|
nsCOMPtr<nsINode> clonedElement = content->GetContentNode()->CloneNode(true, rv);
|
|
|
|
content->SetContentNode(clonedElement->AsElement());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nsContentUtils::DestroyAnonymousContent(&mCustomContentContainer);
|
|
|
|
|
2011-12-27 20:18:48 +00:00
|
|
|
nsContainerFrame::DestroyFrom(aDestructRoot);
|
2001-05-22 23:52:17 +00:00
|
|
|
}
|
|
|
|
|
2010-01-29 00:03:42 +00:00
|
|
|
void
|
2009-09-09 05:40:01 +00:00
|
|
|
nsCanvasFrame::ScrollPositionWillChange(nscoord aX, nscoord aY)
|
2001-05-22 23:52:17 +00:00
|
|
|
{
|
|
|
|
if (mDoPaintFocus) {
|
2011-10-17 14:59:28 +00:00
|
|
|
mDoPaintFocus = false;
|
2010-08-31 00:49:12 +00:00
|
|
|
PresContext()->FrameManager()->GetRootFrame()->InvalidateFrameSubtree();
|
2001-05-22 23:52:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-29 13:16:46 +00:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsCanvasFrame::SetHasFocus(bool aHasFocus)
|
2005-09-29 13:16:46 +00:00
|
|
|
{
|
|
|
|
if (mDoPaintFocus != aHasFocus) {
|
|
|
|
mDoPaintFocus = aHasFocus;
|
2010-08-31 00:49:12 +00:00
|
|
|
PresContext()->FrameManager()->GetRootFrame()->InvalidateFrameSubtree();
|
2010-03-05 00:10:41 +00:00
|
|
|
|
|
|
|
if (!mAddedScrollPositionListener) {
|
|
|
|
nsIScrollableFrame* sf =
|
|
|
|
PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();
|
2010-03-11 05:37:27 +00:00
|
|
|
if (sf) {
|
|
|
|
sf->AddScrollPositionListener(this);
|
2011-10-17 14:59:28 +00:00
|
|
|
mAddedScrollPositionListener = true;
|
2010-03-11 05:37:27 +00:00
|
|
|
}
|
2010-03-05 00:10:41 +00:00
|
|
|
}
|
2005-09-29 13:16:46 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-05-28 19:36:59 +00:00
|
|
|
#ifdef DEBUG
|
2014-05-28 19:36:58 +00:00
|
|
|
void
|
2011-08-24 20:54:30 +00:00
|
|
|
nsCanvasFrame::SetInitialChildList(ChildListID aListID,
|
2010-03-20 21:54:19 +00:00
|
|
|
nsFrameList& aChildList)
|
2008-09-08 08:13:17 +00:00
|
|
|
{
|
2011-08-24 20:54:30 +00:00
|
|
|
NS_ASSERTION(aListID != kPrincipalList ||
|
|
|
|
aChildList.IsEmpty() || aChildList.OnlyChild(),
|
2008-09-08 08:13:17 +00:00
|
|
|
"Primary child list can have at most one frame in it");
|
2014-05-28 19:36:58 +00:00
|
|
|
nsContainerFrame::SetInitialChildList(aListID, aChildList);
|
2008-09-08 08:13:17 +00:00
|
|
|
}
|
|
|
|
|
2014-05-28 19:36:58 +00:00
|
|
|
void
|
2011-08-24 20:54:30 +00:00
|
|
|
nsCanvasFrame::AppendFrames(ChildListID aListID,
|
2010-03-20 21:54:19 +00:00
|
|
|
nsFrameList& aFrameList)
|
1999-07-27 14:15:42 +00:00
|
|
|
{
|
2014-05-28 19:36:59 +00:00
|
|
|
MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
|
2014-06-03 07:08:25 +00:00
|
|
|
if (!mFrames.IsEmpty()) {
|
|
|
|
for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
|
2015-12-22 06:14:12 +00:00
|
|
|
// We only allow native anonymous child frames to be in principal child
|
|
|
|
// list in canvas frame.
|
2014-06-03 07:08:25 +00:00
|
|
|
MOZ_ASSERT(e.get()->GetContent()->IsInNativeAnonymousSubtree(),
|
|
|
|
"invalid child list");
|
|
|
|
}
|
|
|
|
}
|
2010-03-20 21:54:19 +00:00
|
|
|
nsFrame::VerifyDirtyBitSet(aFrameList);
|
2014-05-28 19:36:59 +00:00
|
|
|
nsContainerFrame::AppendFrames(aListID, aFrameList);
|
1999-07-27 14:15:42 +00:00
|
|
|
}
|
|
|
|
|
2014-05-28 19:36:58 +00:00
|
|
|
void
|
2011-08-24 20:54:30 +00:00
|
|
|
nsCanvasFrame::InsertFrames(ChildListID aListID,
|
2010-03-20 21:54:19 +00:00
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsFrameList& aFrameList)
|
1999-07-27 14:15:42 +00:00
|
|
|
{
|
|
|
|
// Because we only support a single child frame inserting is the same
|
|
|
|
// as appending
|
2014-05-28 19:36:58 +00:00
|
|
|
MOZ_ASSERT(!aPrevFrame, "unexpected previous sibling frame");
|
|
|
|
AppendFrames(aListID, aFrameList);
|
1999-07-27 14:15:42 +00:00
|
|
|
}
|
|
|
|
|
2014-05-28 19:36:58 +00:00
|
|
|
void
|
2011-08-24 20:54:30 +00:00
|
|
|
nsCanvasFrame::RemoveFrame(ChildListID aListID,
|
2010-03-20 21:54:19 +00:00
|
|
|
nsIFrame* aOldFrame)
|
1999-07-27 14:15:42 +00:00
|
|
|
{
|
2014-05-28 19:36:59 +00:00
|
|
|
MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
|
|
|
|
nsContainerFrame::RemoveFrame(aListID, aOldFrame);
|
1999-07-27 14:15:42 +00:00
|
|
|
}
|
2014-05-28 19:36:59 +00:00
|
|
|
#endif
|
1999-07-27 14:15:42 +00:00
|
|
|
|
2009-10-08 06:18:18 +00:00
|
|
|
nsRect nsCanvasFrame::CanvasArea() const
|
2006-01-26 02:29:17 +00:00
|
|
|
{
|
2010-10-07 04:25:47 +00:00
|
|
|
// Not clear which overflow rect we want here, but it probably doesn't
|
|
|
|
// matter.
|
|
|
|
nsRect result(GetVisualOverflowRect());
|
2006-03-15 16:55:19 +00:00
|
|
|
|
2009-01-12 19:20:59 +00:00
|
|
|
nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());
|
2006-03-15 16:55:19 +00:00
|
|
|
if (scrollableFrame) {
|
2009-09-03 04:26:00 +00:00
|
|
|
nsRect portRect = scrollableFrame->GetScrollPortRect();
|
|
|
|
result.UnionRect(result, nsRect(nsPoint(0, 0), portRect.Size()));
|
2006-03-15 16:55:19 +00:00
|
|
|
}
|
|
|
|
return result;
|
2006-01-26 02:29:17 +00:00
|
|
|
}
|
|
|
|
|
2012-12-13 01:15:55 +00:00
|
|
|
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) {
|
2014-10-19 12:22:22 +00:00
|
|
|
DrawTarget* drawTarget = aCtx->GetDrawTarget();
|
|
|
|
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
|
2014-10-22 11:29:06 +00:00
|
|
|
Rect devPxRect =
|
|
|
|
NSRectToSnappedRect(bgClipRect, appUnitsPerDevPixel, *drawTarget);
|
2014-10-19 12:22:22 +00:00
|
|
|
drawTarget->FillRect(devPxRect, ColorPattern(ToDeviceColor(mColor)));
|
2012-12-13 01:15:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-03 20:21:39 +00:00
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
|
|
void
|
2014-11-25 13:45:19 +00:00
|
|
|
nsDisplayCanvasBackgroundColor::WriteDebugInfo(std::stringstream& aStream)
|
2014-06-03 20:21:39 +00:00
|
|
|
{
|
2014-11-25 13:45:19 +00:00
|
|
|
aStream << " (rgba "
|
|
|
|
<< (int)NS_GET_R(mColor) << ","
|
|
|
|
<< (int)NS_GET_G(mColor) << ","
|
|
|
|
<< (int)NS_GET_B(mColor) << ","
|
|
|
|
<< (int)NS_GET_A(mColor) << ")";
|
2014-06-03 20:21:39 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-01-06 04:29:52 +00:00
|
|
|
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
|
2013-10-02 09:12:34 +00:00
|
|
|
static void BlitSurface(DrawTarget* aDest, const gfxRect& aRect, DrawTarget* aSource)
|
|
|
|
{
|
2015-10-18 05:24:48 +00:00
|
|
|
RefPtr<SourceSurface> source = aSource->Snapshot();
|
2013-10-02 09:12:34 +00:00
|
|
|
aDest->DrawSurface(source,
|
|
|
|
Rect(aRect.x, aRect.y, aRect.width, aRect.height),
|
|
|
|
Rect(0, 0, aRect.width, aRect.height));
|
|
|
|
}
|
2016-01-06 04:29:52 +00:00
|
|
|
#endif
|
2013-10-02 09:12:34 +00:00
|
|
|
|
2010-07-15 21:07:53 +00:00
|
|
|
void
|
2012-12-13 01:15:55 +00:00
|
|
|
nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
|
|
|
|
nsRenderingContext* aCtx)
|
2010-07-15 21:07:53 +00:00
|
|
|
{
|
|
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
2010-08-13 10:01:58 +00:00
|
|
|
nsPoint offset = ToReferenceFrame();
|
2010-07-15 21:07:53 +00:00
|
|
|
nsRect bgClipRect = frame->CanvasArea() + offset;
|
2006-03-15 16:55:19 +00:00
|
|
|
|
2016-01-06 04:29:52 +00:00
|
|
|
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
|
2015-10-18 05:24:48 +00:00
|
|
|
RefPtr<gfxContext> dest = aCtx->ThebesContext();
|
2012-11-15 01:35:18 +00:00
|
|
|
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
|
2016-01-06 04:29:52 +00:00
|
|
|
// to snap for this context, because we checked HasNonIntegerTranslation
|
|
|
|
// above.
|
2012-11-15 01:35:18 +00:00
|
|
|
destRect.Round();
|
2016-01-06 04:29:52 +00:00
|
|
|
RefPtr<DrawTarget> dt = static_cast<DrawTarget*>(
|
|
|
|
Frame()->Properties().Get(nsIFrame::CachedBackgroundImageDT()));
|
2014-07-07 08:05:16 +00:00
|
|
|
DrawTarget* destDT = dest->GetDrawTarget();
|
|
|
|
if (dt) {
|
|
|
|
BlitSurface(destDT, destRect, dt);
|
|
|
|
return;
|
2012-07-23 03:00:36 +00:00
|
|
|
}
|
2016-01-06 04:29:52 +00:00
|
|
|
|
|
|
|
dt = destDT->CreateSimilarDrawTarget(IntSize(ceil(destRect.width),
|
|
|
|
ceil(destRect.height)),
|
|
|
|
SurfaceFormat::B8G8R8A8);
|
2016-04-12 19:18:11 +00:00
|
|
|
if (dt && dt->IsValid()) {
|
|
|
|
RefPtr<gfxContext> ctx = gfxContext::ForDrawTarget(dt);
|
|
|
|
MOZ_ASSERT(ctx); // already checked draw target above
|
2016-01-06 04:29:52 +00:00
|
|
|
ctx->SetMatrix(ctx->CurrentMatrix().Translate(-destRect.x, -destRect.y));
|
|
|
|
nsRenderingContext context(ctx);
|
|
|
|
PaintInternal(aBuilder, &context, bgClipRect, &bgClipRect);
|
|
|
|
BlitSurface(dest->GetDrawTarget(), destRect, dt);
|
|
|
|
frame->Properties().Set(nsIFrame::CachedBackgroundImageDT(),
|
|
|
|
dt.forget().take());
|
|
|
|
return;
|
2012-07-23 03:00:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2016-01-06 04:29:52 +00:00
|
|
|
PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
|
2010-07-15 21:07:53 +00:00
|
|
|
}
|
2006-03-15 16:55:19 +00:00
|
|
|
|
2016-04-22 05:50:11 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-18 06:34:58 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-03-15 16:55:19 +00:00
|
|
|
/**
|
|
|
|
* 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:
|
2010-08-13 10:01:13 +00:00
|
|
|
nsDisplayCanvasFocus(nsDisplayListBuilder* aBuilder, nsCanvasFrame *aFrame)
|
|
|
|
: nsDisplayItem(aBuilder, aFrame)
|
2006-03-15 16:55:19 +00:00
|
|
|
{
|
2010-06-21 16:19:46 +00:00
|
|
|
MOZ_COUNT_CTOR(nsDisplayCanvasFocus);
|
|
|
|
}
|
|
|
|
virtual ~nsDisplayCanvasFocus() {
|
|
|
|
MOZ_COUNT_DTOR(nsDisplayCanvasFocus);
|
2006-03-15 16:55:19 +00:00
|
|
|
}
|
|
|
|
|
2014-02-24 14:41:56 +00:00
|
|
|
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
|
2015-03-21 16:28:04 +00:00
|
|
|
bool* aSnap) override
|
2006-03-15 16:55:19 +00:00
|
|
|
{
|
2012-04-10 11:24:18 +00:00
|
|
|
*aSnap = false;
|
2006-03-15 16:55:19 +00:00
|
|
|
// This is an overestimate, but that's not a problem.
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
2010-08-13 10:01:58 +00:00
|
|
|
return frame->CanvasArea() + ToReferenceFrame();
|
2006-03-15 16:55:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
2015-03-21 16:28:04 +00:00
|
|
|
nsRenderingContext* aCtx) override
|
2006-03-15 16:55:19 +00:00
|
|
|
{
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
|
2015-12-04 03:16:59 +00:00
|
|
|
frame->PaintFocus(aCtx->GetDrawTarget(), ToReferenceFrame());
|
2006-03-15 16:55:19 +00:00
|
|
|
}
|
|
|
|
|
2010-07-15 21:07:49 +00:00
|
|
|
NS_DISPLAY_DECL_NAME("CanvasFocus", TYPE_CANVAS_FOCUS)
|
2006-03-15 16:55:19 +00:00
|
|
|
};
|
|
|
|
|
2013-02-14 11:12:27 +00:00
|
|
|
void
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
2010-03-20 21:54:19 +00:00
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
const nsDisplayListSet& aLists)
|
2001-04-24 01:01:16 +00:00
|
|
|
{
|
2008-09-08 08:13:17 +00:00
|
|
|
if (GetPrevInFlow()) {
|
|
|
|
DisplayOverflowContainers(aBuilder, aDirtyRect, aLists);
|
|
|
|
}
|
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
// Force a background to be shown. We may have a background propagated to us,
|
2013-02-16 21:51:02 +00:00
|
|
|
// in which case StyleBackground wouldn't have the right background
|
2006-01-26 02:29:17 +00:00
|
|
|
// and the code in nsFrame::DisplayBorderBackgroundOutline might not give us
|
|
|
|
// a background.
|
2006-03-15 16:55:19 +00:00
|
|
|
// We don't have any border or outline, and our background draws over
|
|
|
|
// the overflow area, so just add nsDisplayCanvasBackground instead of
|
|
|
|
// calling DisplayBorderBackgroundOutline.
|
2012-09-13 10:34:23 +00:00
|
|
|
if (IsVisibleForPainting(aBuilder)) {
|
|
|
|
nsStyleContext* bgSC;
|
|
|
|
const nsStyleBackground* bg = nullptr;
|
2012-11-08 04:08:40 +00:00
|
|
|
bool isThemed = IsThemed();
|
2013-03-07 16:03:49 +00:00
|
|
|
if (!isThemed && nsCSSRendering::FindBackground(this, &bgSC)) {
|
2013-02-16 21:51:02 +00:00
|
|
|
bg = bgSC->StyleBackground();
|
2012-09-13 10:34:23 +00:00
|
|
|
}
|
2012-12-13 01:15:55 +00:00
|
|
|
aLists.BorderBackground()->AppendNewToTop(
|
|
|
|
new (aBuilder) nsDisplayCanvasBackgroundColor(aBuilder, this));
|
2012-12-13 22:16:14 +00:00
|
|
|
|
|
|
|
if (isThemed) {
|
2013-02-14 11:08:08 +00:00
|
|
|
aLists.BorderBackground()->AppendNewToTop(
|
2013-07-18 06:34:58 +00:00
|
|
|
new (aBuilder) nsDisplayCanvasThemedBackground(aBuilder, this));
|
2013-02-14 11:12:27 +00:00
|
|
|
return;
|
2012-12-13 22:16:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!bg) {
|
2013-02-14 11:12:27 +00:00
|
|
|
return;
|
2012-12-13 22:16:14 +00:00
|
|
|
}
|
2012-12-13 01:15:55 +00:00
|
|
|
|
2016-03-08 19:22:36 +00:00
|
|
|
const DisplayItemScrollClip* scrollClip =
|
|
|
|
aBuilder->ClipState().GetCurrentInnermostScrollClip();
|
|
|
|
|
2014-07-16 19:04:00 +00:00
|
|
|
bool needBlendContainer = false;
|
|
|
|
|
2012-09-13 10:34:23 +00:00
|
|
|
// Create separate items for each background layer.
|
2016-01-28 05:39:00 +00:00
|
|
|
const nsStyleImageLayers& layers = bg->mImage;
|
2016-01-28 05:24:00 +00:00
|
|
|
NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, layers) {
|
|
|
|
if (layers.mLayers[i].mImage.IsEmpty()) {
|
2012-12-13 22:16:14 +00:00
|
|
|
continue;
|
|
|
|
}
|
2016-01-28 05:24:00 +00:00
|
|
|
if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {
|
2014-07-16 19:04:00 +00:00
|
|
|
needBlendContainer = true;
|
|
|
|
}
|
2016-03-08 19:22:36 +00:00
|
|
|
|
|
|
|
nsDisplayList thisItemList;
|
2016-01-26 00:36:48 +00:00
|
|
|
nsDisplayCanvasBackgroundImage* bgItem =
|
|
|
|
new (aBuilder) nsDisplayCanvasBackgroundImage(aBuilder, this, i, bg);
|
|
|
|
if (bgItem->ShouldFixToViewport(aBuilder)) {
|
2016-03-08 19:22:36 +00:00
|
|
|
thisItemList.AppendNewToTop(
|
2016-01-26 00:36:48 +00:00
|
|
|
nsDisplayFixedPosition::CreateForFixedBackground(aBuilder, this, bgItem, i));
|
|
|
|
} else {
|
2016-03-08 19:22:36 +00:00
|
|
|
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));
|
2016-01-26 00:36:48 +00:00
|
|
|
}
|
2016-03-08 19:22:36 +00:00
|
|
|
aLists.BorderBackground()->AppendToTop(&thisItemList);
|
2012-09-13 10:34:23 +00:00
|
|
|
}
|
2014-07-16 19:04:00 +00:00
|
|
|
|
|
|
|
if (needBlendContainer) {
|
|
|
|
aLists.BorderBackground()->AppendNewToTop(
|
2016-05-10 00:48:59 +00:00
|
|
|
nsDisplayBlendContainer::CreateForBackgroundBlendMode(aBuilder, this,
|
|
|
|
aLists.BorderBackground(),
|
|
|
|
scrollClip));
|
2014-07-16 19:04:00 +00:00
|
|
|
}
|
2006-03-15 16:55:19 +00:00
|
|
|
}
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2016-01-29 14:42:15 +00:00
|
|
|
for (nsIFrame* kid : PrincipalChildList()) {
|
2006-01-26 02:29:17 +00:00
|
|
|
// Put our child into its own pseudo-stack.
|
2013-02-14 11:08:08 +00:00
|
|
|
BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists);
|
2002-12-11 04:00:18 +00:00
|
|
|
}
|
|
|
|
|
2001-05-22 23:52:17 +00:00
|
|
|
#ifdef DEBUG_CANVAS_FOCUS
|
2006-01-26 02:29:17 +00:00
|
|
|
nsCOMPtr<nsIContent> focusContent;
|
|
|
|
aPresContext->EventStateManager()->
|
|
|
|
GetFocusedContent(getter_AddRefs(focusContent));
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool hasFocus = false;
|
2006-01-26 02:29:17 +00:00
|
|
|
nsCOMPtr<nsISupports> container;
|
|
|
|
aPresContext->GetContainer(getter_AddRefs(container));
|
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));
|
|
|
|
if (docShell) {
|
|
|
|
docShell->GetHasFocus(&hasFocus);
|
2009-10-08 06:18:18 +00:00
|
|
|
printf("%p - nsCanvasFrame::Paint R:%d,%d,%d,%d DR: %d,%d,%d,%d\n", this,
|
2006-01-26 02:29:17 +00:00
|
|
|
mRect.x, mRect.y, mRect.width, mRect.height,
|
|
|
|
aDirtyRect.x, aDirtyRect.y, aDirtyRect.width, aDirtyRect.height);
|
|
|
|
}
|
|
|
|
printf("%p - Focus: %s c: %p DoPaint:%s\n", docShell.get(), hasFocus?"Y":"N",
|
|
|
|
focusContent.get(), mDoPaintFocus?"Y":"N");
|
2001-05-22 23:52:17 +00:00
|
|
|
#endif
|
|
|
|
|
2006-01-26 02:29:17 +00:00
|
|
|
if (!mDoPaintFocus)
|
2013-02-14 11:12:27 +00:00
|
|
|
return;
|
2006-01-26 02:29:17 +00:00
|
|
|
// Only paint the focus if we're visible
|
2013-02-16 21:51:02 +00:00
|
|
|
if (!StyleVisibility()->IsVisible())
|
2013-02-14 11:12:27 +00:00
|
|
|
return;
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2013-02-14 11:08:08 +00:00
|
|
|
aLists.Outlines()->AppendNewToTop(new (aBuilder)
|
|
|
|
nsDisplayCanvasFocus(aBuilder, this));
|
2006-01-26 02:29:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-12-04 03:16:59 +00:00
|
|
|
nsCanvasFrame::PaintFocus(DrawTarget* aDrawTarget, nsPoint aPt)
|
2006-01-26 02:29:17 +00:00
|
|
|
{
|
2006-03-15 16:55:19 +00:00
|
|
|
nsRect focusRect(aPt, GetSize());
|
|
|
|
|
2009-01-12 19:20:59 +00:00
|
|
|
nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());
|
2006-03-15 16:55:19 +00:00
|
|
|
if (scrollableFrame) {
|
2009-09-03 04:26:00 +00:00
|
|
|
nsRect portRect = scrollableFrame->GetScrollPortRect();
|
|
|
|
focusRect.width = portRect.width;
|
|
|
|
focusRect.height = portRect.height;
|
|
|
|
focusRect.MoveBy(scrollableFrame->GetScrollPosition());
|
2001-05-22 23:52:17 +00:00
|
|
|
}
|
2006-01-26 02:29:17 +00:00
|
|
|
|
2006-04-28 23:21:01 +00:00
|
|
|
// XXX use the root frame foreground color, but should we find BODY frame
|
|
|
|
// for HTML documents?
|
|
|
|
nsIFrame* root = mFrames.FirstChild();
|
2013-02-16 21:51:02 +00:00
|
|
|
const nsStyleColor* color = root ? root->StyleColor() : StyleColor();
|
2006-04-28 23:21:01 +00:00
|
|
|
if (!color) {
|
|
|
|
NS_ERROR("current color cannot be found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-12-04 03:16:59 +00:00
|
|
|
nsCSSRendering::PaintFocus(PresContext(), aDrawTarget,
|
2008-08-06 10:33:18 +00:00
|
|
|
focusRect, color->mColor);
|
2001-04-24 01:01:16 +00:00
|
|
|
}
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
/* virtual */ nscoord
|
2014-07-24 17:03:25 +00:00
|
|
|
nsCanvasFrame::GetMinISize(nsRenderingContext *aRenderingContext)
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
{
|
|
|
|
nscoord result;
|
|
|
|
DISPLAY_MIN_WIDTH(this, result);
|
|
|
|
if (mFrames.IsEmpty())
|
|
|
|
result = 0;
|
|
|
|
else
|
2014-07-24 17:03:25 +00:00
|
|
|
result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* virtual */ nscoord
|
2014-07-24 17:03:25 +00:00
|
|
|
nsCanvasFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
{
|
|
|
|
nscoord result;
|
|
|
|
DISPLAY_PREF_WIDTH(this, result);
|
|
|
|
if (mFrames.IsEmpty())
|
|
|
|
result = 0;
|
|
|
|
else
|
2014-07-24 17:03:25 +00:00
|
|
|
result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-05-13 00:47:52 +00:00
|
|
|
void
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame::Reflow(nsPresContext* aPresContext,
|
2012-11-27 09:05:10 +00:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
1998-09-08 22:34:40 +00:00
|
|
|
{
|
2015-03-29 22:38:40 +00:00
|
|
|
MarkInReflow();
|
2009-10-08 06:18:18 +00:00
|
|
|
DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame");
|
2002-04-03 04:21:20 +00:00
|
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
2009-10-08 06:18:18 +00:00
|
|
|
NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow");
|
1998-09-08 22:34:40 +00:00
|
|
|
|
1998-12-22 03:49:04 +00:00
|
|
|
// Initialize OUT parameter
|
1998-09-08 22:34:40 +00:00
|
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame* prevCanvasFrame = static_cast<nsCanvasFrame*>
|
2008-09-08 08:13:17 +00:00
|
|
|
(GetPrevInFlow());
|
|
|
|
if (prevCanvasFrame) {
|
2013-04-01 15:26:02 +00:00
|
|
|
AutoFrameListPtr overflow(aPresContext,
|
|
|
|
prevCanvasFrame->StealOverflowFrames());
|
2008-09-08 08:13:17 +00:00
|
|
|
if (overflow) {
|
2009-07-28 12:51:09 +00:00
|
|
|
NS_ASSERTION(overflow->OnlyChild(),
|
2008-09-08 08:13:17 +00:00
|
|
|
"must have doc root as canvas frame's only child");
|
2014-02-06 22:07:47 +00:00
|
|
|
nsContainerFrame::ReparentFrameViewList(*overflow, prevCanvasFrame, this);
|
2008-09-08 08:13:17 +00:00
|
|
|
// 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.
|
2012-07-30 14:20:58 +00:00
|
|
|
mFrames.InsertFrames(this, nullptr, *overflow);
|
2008-09-08 08:13:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-05 21:59:36 +00:00
|
|
|
// 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(aReflowState.ComputedWidth(), aReflowState.ComputedHeight()));
|
|
|
|
|
2008-09-08 08:13:17 +00:00
|
|
|
// 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.
|
2013-12-31 13:50:31 +00:00
|
|
|
nsHTMLReflowMetrics kidDesiredSize(aReflowState);
|
1999-01-31 18:46:22 +00:00
|
|
|
if (mFrames.IsEmpty()) {
|
1999-07-27 14:15:42 +00:00
|
|
|
// We have no child frame, so return an empty size
|
2013-12-27 17:59:52 +00:00
|
|
|
aDesiredSize.Width() = aDesiredSize.Height() = 0;
|
1999-01-31 18:46:22 +00:00
|
|
|
} else {
|
1999-01-26 00:05:21 +00:00
|
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
2011-09-29 06:19:26 +00:00
|
|
|
bool kidDirty = (kidFrame->GetStateBits() & NS_FRAME_IS_DIRTY) != 0;
|
1998-10-01 04:46:11 +00:00
|
|
|
|
2014-07-24 08:28:46 +00:00
|
|
|
nsHTMLReflowState
|
|
|
|
kidReflowState(aPresContext, aReflowState, kidFrame,
|
|
|
|
aReflowState.AvailableSize(kidFrame->GetWritingMode()));
|
2002-05-10 18:22:41 +00:00
|
|
|
|
2015-06-18 06:33:50 +00:00
|
|
|
if (aReflowState.IsBResize() &&
|
|
|
|
(kidFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
|
|
|
|
// Tell our kid it's being block-dir resized too. Bit of a
|
2007-10-19 03:45:30 +00:00
|
|
|
// hack for framesets.
|
2015-06-18 06:33:50 +00:00
|
|
|
kidReflowState.SetBResize(true);
|
2007-10-19 03:45:30 +00:00
|
|
|
}
|
2008-09-08 08:13:17 +00:00
|
|
|
|
2015-01-07 07:10:07 +00:00
|
|
|
WritingMode wm = aReflowState.GetWritingMode();
|
|
|
|
WritingMode kidWM = kidReflowState.GetWritingMode();
|
2015-07-16 09:07:57 +00:00
|
|
|
nsSize containerSize = aReflowState.ComputedPhysicalSize();
|
2015-01-07 07:10:07 +00:00
|
|
|
|
|
|
|
LogicalMargin margin = kidReflowState.ComputedLogicalMargin();
|
|
|
|
LogicalPoint kidPt(kidWM, margin.IStart(kidWM), margin.BStart(kidWM));
|
2013-07-16 00:28:09 +00:00
|
|
|
|
2015-07-16 09:07:57 +00:00
|
|
|
kidReflowState.ApplyRelativePositioning(&kidPt, containerSize);
|
2008-09-08 08:13:17 +00:00
|
|
|
|
1998-12-22 03:49:04 +00:00
|
|
|
// Reflow the frame
|
1999-10-30 02:52:11 +00:00
|
|
|
ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowState,
|
2015-07-16 09:07:57 +00:00
|
|
|
kidWM, kidPt, containerSize, 0, aStatus);
|
1999-10-30 02:52:11 +00:00
|
|
|
|
1999-11-19 15:33:29 +00:00
|
|
|
// Complete the reflow and position and size the child frame
|
2014-01-17 01:34:44 +00:00
|
|
|
FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, &kidReflowState,
|
2015-07-16 09:07:57 +00:00
|
|
|
kidWM, kidPt, containerSize, 0);
|
2008-09-08 08:13:17 +00:00
|
|
|
|
|
|
|
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) {
|
2013-03-20 01:47:49 +00:00
|
|
|
nextFrame = aPresContext->PresShell()->FrameConstructor()->
|
|
|
|
CreateContinuingFrame(aPresContext, kidFrame, this);
|
2014-02-06 22:07:47 +00:00
|
|
|
SetOverflowFrames(nsFrameList(nextFrame, nextFrame));
|
2008-09-08 08:13:17 +00:00
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
}
|
1999-07-27 14:15:42 +00:00
|
|
|
|
1999-10-30 02:52:11 +00:00
|
|
|
// If the child frame was just inserted, then we're responsible for making sure
|
|
|
|
// it repaints
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 05:38:33 +00:00
|
|
|
if (kidDirty) {
|
2005-01-21 04:42:30 +00:00
|
|
|
// 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
|
2010-10-07 04:25:47 +00:00
|
|
|
// (0, 0). We only want to invalidate GetRect() since Get*OverflowRect()
|
2005-01-21 04:42:30 +00:00
|
|
|
// could also include overflow to our top and left (out of the viewport)
|
|
|
|
// which doesn't need to be painted.
|
2007-07-20 20:14:43 +00:00
|
|
|
nsIFrame* viewport = PresContext()->GetPresShell()->GetRootFrame();
|
2012-08-29 05:39:31 +00:00
|
|
|
viewport->InvalidateFrame();
|
1998-10-01 04:46:11 +00:00
|
|
|
}
|
2008-09-08 08:13:17 +00:00
|
|
|
|
2008-12-09 00:33:46 +00:00
|
|
|
// 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.
|
2014-07-24 08:30:07 +00:00
|
|
|
LogicalSize finalSize(wm);
|
|
|
|
finalSize.ISize(wm) = aReflowState.ComputedISize();
|
|
|
|
if (aReflowState.ComputedBSize() == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
finalSize.BSize(wm) = kidFrame->GetLogicalSize(wm).BSize(wm) +
|
|
|
|
kidReflowState.ComputedLogicalMargin().BStartEnd(wm);
|
2008-12-09 00:33:46 +00:00
|
|
|
} else {
|
2014-07-24 08:30:07 +00:00
|
|
|
finalSize.BSize(wm) = aReflowState.ComputedBSize();
|
2008-12-09 00:33:46 +00:00
|
|
|
}
|
2006-03-15 16:55:19 +00:00
|
|
|
|
2014-07-24 08:30:07 +00:00
|
|
|
aDesiredSize.SetSize(wm, finalSize);
|
2010-10-07 04:25:46 +00:00
|
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
|
|
aDesiredSize.mOverflowAreas.UnionWith(
|
2015-01-07 07:10:07 +00:00
|
|
|
kidDesiredSize.mOverflowAreas + kidFrame->GetPosition());
|
1999-01-26 00:05:21 +00:00
|
|
|
}
|
1998-09-08 22:34:40 +00:00
|
|
|
|
2008-09-08 08:13:17 +00:00
|
|
|
if (prevCanvasFrame) {
|
|
|
|
ReflowOverflowContainerChildren(aPresContext, aReflowState,
|
2010-10-07 04:25:45 +00:00
|
|
|
aDesiredSize.mOverflowAreas, 0,
|
2008-09-08 08:13:17 +00:00
|
|
|
aStatus);
|
|
|
|
}
|
|
|
|
|
2011-04-29 23:02:33 +00:00
|
|
|
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus);
|
2008-09-08 08:13:17 +00:00
|
|
|
|
2009-10-08 06:18:18 +00:00
|
|
|
NS_FRAME_TRACE_REFLOW_OUT("nsCanvasFrame::Reflow", aStatus);
|
2002-05-28 22:50:43 +00:00
|
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
1998-09-08 22:34:40 +00:00
|
|
|
}
|
|
|
|
|
2003-10-31 20:19:18 +00:00
|
|
|
nsIAtom*
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame::GetType() const
|
1999-02-14 03:47:33 +00:00
|
|
|
{
|
2006-12-26 17:47:52 +00:00
|
|
|
return nsGkAtoms::canvasFrame;
|
1999-02-14 03:47:33 +00:00
|
|
|
}
|
|
|
|
|
2014-02-18 07:47:48 +00:00
|
|
|
nsresult
|
2013-10-02 03:46:04 +00:00
|
|
|
nsCanvasFrame::GetContentForEvent(WidgetEvent* aEvent,
|
2011-09-26 20:55:04 +00:00
|
|
|
nsIContent** aContent)
|
2001-05-18 23:08:00 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aContent);
|
2011-09-26 20:55:04 +00:00
|
|
|
nsresult rv = nsFrame::GetContentForEvent(aEvent,
|
2001-05-18 23:08:00 +00:00
|
|
|
aContent);
|
|
|
|
if (NS_FAILED(rv) || !*aContent) {
|
|
|
|
nsIFrame* kid = mFrames.FirstChild();
|
|
|
|
if (kid) {
|
2011-09-26 20:55:04 +00:00
|
|
|
rv = kid->GetContentForEvent(aEvent,
|
2001-05-18 23:08:00 +00:00
|
|
|
aContent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-01-05 23:31:14 +00:00
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
2014-02-18 07:47:48 +00:00
|
|
|
nsresult
|
2009-10-08 06:18:18 +00:00
|
|
|
nsCanvasFrame::GetFrameName(nsAString& aResult) const
|
1998-11-13 02:20:31 +00:00
|
|
|
{
|
2001-11-14 01:33:42 +00:00
|
|
|
return MakeFrameName(NS_LITERAL_STRING("Canvas"), aResult);
|
1998-11-13 02:20:31 +00:00
|
|
|
}
|
1999-09-01 01:02:16 +00:00
|
|
|
#endif
|