nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/layout/base/nsCSSFrameConstructor.cpp

12569 lines
460 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
// vim:cindent:ts=2:et:sw=2:
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Dan Rosen <dr@netscape.com>
* Mats Palmgren <mats.palmgren@bredband.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* construction of a frame tree that is nearly isomorphic to the content
* tree and updating of that tree in response to dynamic changes
*/
#include "nsCSSFrameConstructor.h"
#include "nsCRT.h"
#include "nsIAtom.h"
#include "nsIURL.h"
#include "nsISupportsArray.h"
#include "nsHashtable.h"
#include "nsIHTMLDocument.h"
#include "nsIStyleRule.h"
#include "nsIFrame.h"
#include "nsGkAtoms.h"
#include "nsPresContext.h"
#include "nsILinkHandler.h"
#include "nsIDocument.h"
#include "nsTableFrame.h"
#include "nsTableColGroupFrame.h"
#include "nsTableColFrame.h"
#include "nsIDOMHTMLDocument.h"
#include "nsIDOMHTMLTableColElement.h"
#include "nsIDOMHTMLTableCaptionElem.h"
#include "nsHTMLParts.h"
#include "nsIPresShell.h"
#include "nsStyleSet.h"
#include "nsIViewManager.h"
#include "nsIEventStateManager.h"
#include "nsIScrollableView.h"
#include "nsStyleConsts.h"
#include "nsTableOuterFrame.h"
#include "nsIDOMXULElement.h"
#include "nsHTMLContainerFrame.h"
#include "nsINameSpaceManager.h"
#include "nsIDOMHTMLSelectElement.h"
#include "nsIDOMHTMLLegendElement.h"
#include "nsIComboboxControlFrame.h"
#include "nsIListControlFrame.h"
#include "nsISelectControlFrame.h"
#include "nsIRadioControlFrame.h"
#include "nsICheckboxControlFrame.h"
#include "nsIDOMCharacterData.h"
#include "nsIDOMHTMLImageElement.h"
#include "nsPlaceholderFrame.h"
#include "nsTableRowGroupFrame.h"
#include "nsStyleChangeList.h"
#include "nsIFormControl.h"
#include "nsCSSAnonBoxes.h"
#include "nsCSSPseudoElements.h"
#include "nsIDeviceContext.h"
#include "nsTextFragment.h"
#include "nsISupportsArray.h"
#include "nsIAnonymousContentCreator.h"
#include "nsFrameManager.h"
#include "nsLegendFrame.h"
#include "nsIContentIterator.h"
#include "nsBoxLayoutState.h"
#include "nsBindingManager.h"
#include "nsXBLBinding.h"
#include "nsITheme.h"
#include "nsContentCID.h"
#include "nsContentUtils.h"
#include "nsIScriptError.h"
#include "nsIDocShell.h"
#include "nsIDocShellTreeItem.h"
#include "nsObjectFrame.h"
#include "nsRuleNode.h"
#include "nsIDOMMutationEvent.h"
#include "nsChildIterator.h"
#include "nsCSSRendering.h"
#include "nsISelectElement.h"
#include "nsLayoutErrors.h"
#include "nsLayoutUtils.h"
#include "nsAutoPtr.h"
#include "nsBoxFrame.h"
#include "nsIBoxLayout.h"
#include "nsImageFrame.h"
#include "nsIObjectLoadingContent.h"
#include "nsContentErrors.h"
#include "nsIPrincipal.h"
#include "nsIDOMWindowInternal.h"
#include "nsStyleUtil.h"
#include "nsIFocusEventSuppressor.h"
#include "nsBox.h"
#include "nsTArray.h"
#ifdef MOZ_XUL
#include "nsIRootBox.h"
#include "nsIDOMXULCommandDispatcher.h"
#include "nsIDOMXULDocument.h"
#include "nsIXULDocument.h"
#endif
#ifdef ACCESSIBILITY
#include "nsIAccessibilityService.h"
#include "nsIAccessibleEvent.h"
#endif
#include "nsInlineFrame.h"
#include "nsBlockFrame.h"
#include "nsIScrollableFrame.h"
#include "nsIXBLService.h"
#undef NOISY_FIRST_LETTER
#ifdef MOZ_MATHML
#include "nsMathMLParts.h"
#endif
#ifdef MOZ_SVG
#include "nsSVGEffects.h"
#include "nsSVGUtils.h"
#include "nsSVGOuterSVGFrame.h"
#endif
nsIFrame*
NS_NewHTMLCanvasFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
#if defined(MOZ_MEDIA)
nsIFrame*
NS_NewHTMLVideoFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
#endif
#ifdef MOZ_SVG
#include "nsISVGTextContentMetrics.h"
PRBool
NS_SVGEnabled();
nsIFrame*
NS_NewSVGOuterSVGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGInnerSVGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGPathGeometryFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGGenericContainerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGForeignObjectFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGAFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGGlyphFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGTextFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGTSpanFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGContainerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGUseFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
PRBool
NS_SVG_PassesConditionalProcessingTests(nsIContent *aContent);
extern nsIFrame*
NS_NewSVGLinearGradientFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);
extern nsIFrame*
NS_NewSVGRadialGradientFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);
extern nsIFrame*
NS_NewSVGStopFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGMarkerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
extern nsIFrame*
NS_NewSVGImageFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGClipPathFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGTextPathFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGFilterFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGPatternFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGMaskFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSVGLeafFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
#endif
#include "nsIDocument.h"
#include "nsIDOMElement.h"
#include "nsIDOMNodeList.h"
#include "nsIDOMDocument.h"
#include "nsIDOMDocumentXBL.h"
#include "nsIScrollable.h"
#include "nsINodeInfo.h"
#include "prenv.h"
#include "nsWidgetsCID.h"
#include "nsNodeInfoManager.h"
#include "nsContentCreatorFunctions.h"
#include "nsIServiceManager.h"
// Global object maintenance
nsIXBLService * nsCSSFrameConstructor::gXBLService = nsnull;
#ifdef DEBUG
// Set the environment variable GECKO_FRAMECTOR_DEBUG_FLAGS to one or
// more of the following flags (comma separated) for handy debug
// output.
static PRBool gNoisyContentUpdates = PR_FALSE;
static PRBool gReallyNoisyContentUpdates = PR_FALSE;
static PRBool gNoisyInlineConstruction = PR_FALSE;
static PRBool gVerifyFastFindFrame = PR_FALSE;
static PRBool gTablePseudoFrame = PR_FALSE;
struct FrameCtorDebugFlags {
const char* name;
PRBool* on;
};
static FrameCtorDebugFlags gFlags[] = {
{ "content-updates", &gNoisyContentUpdates },
{ "really-noisy-content-updates", &gReallyNoisyContentUpdates },
{ "noisy-inline", &gNoisyInlineConstruction },
{ "fast-find-frame", &gVerifyFastFindFrame },
{ "table-pseudo", &gTablePseudoFrame },
};
#define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
#endif
#ifdef MOZ_XUL
#include "nsMenuFrame.h"
#include "nsPopupSetFrame.h"
#include "nsTreeColFrame.h"
#include "nsIBoxObject.h"
#include "nsPIListBoxObject.h"
#include "nsListBoxBodyFrame.h"
#include "nsListItemFrame.h"
#include "nsXULLabelFrame.h"
//------------------------------------------------------------------
nsIFrame*
NS_NewAutoRepeatBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewRootBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewDocElementBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewThumbFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewDeckFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewLeafBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewStackFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewProgressMeterFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewImageBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewTextBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewGroupBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewButtonBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewSplitterFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewMenuPopupFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewPopupSetFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewMenuFrame (nsIPresShell* aPresShell, nsStyleContext* aContext, PRUint32 aFlags);
nsIFrame*
NS_NewMenuBarFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewTreeBodyFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
// grid
nsresult
NS_NewGridLayout2 ( nsIPresShell* aPresShell, nsIBoxLayout** aNewLayout );
nsIFrame*
NS_NewGridRowLeafFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewGridRowGroupFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
// end grid
nsIFrame*
NS_NewTitleBarFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewResizerFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
#endif
nsIFrame*
NS_NewHTMLScrollFrame (nsIPresShell* aPresShell, nsStyleContext* aContext, PRBool aIsRoot);
nsIFrame*
NS_NewXULScrollFrame (nsIPresShell* aPresShell, nsStyleContext* aContext, PRBool aIsRoot);
nsIFrame*
NS_NewSliderFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewScrollbarFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
nsIFrame*
NS_NewScrollbarButtonFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);
#ifdef NOISY_FINDFRAME
static PRInt32 FFWC_totalCount=0;
static PRInt32 FFWC_doLoop=0;
static PRInt32 FFWC_doSibling=0;
static PRInt32 FFWC_recursions=0;
static PRInt32 FFWC_nextInFlows=0;
#endif
static nsresult
DeletingFrameSubtree(nsFrameManager* aFrameManager,
nsIFrame* aFrame);
static inline nsIFrame*
GetFieldSetBlockFrame(nsIFrame* aFieldsetFrame)
{
// Depends on the fieldset child frame order - see ConstructFieldSetFrame() below.
nsIFrame* firstChild = aFieldsetFrame->GetFirstChild(nsnull);
return firstChild && firstChild->GetNextSibling() ? firstChild->GetNextSibling() : firstChild;
}
//----------------------------------------------------------------------
static PRBool
IsInlineOutside(nsIFrame* aFrame)
{
return aFrame->GetStyleDisplay()->IsInlineOutside();
}
/**
* True if aFrame is an actual inline frame in the sense of non-replaced
* display:inline CSS boxes. In other words, it can be affected by {ib}
* splitting and can contain first-letter frames. Basically, this is either an
* inline frame (positioned or otherwise) or an line frame (this last because
* it can contain first-letter and because inserting blocks in the middle of it
* needs to terminate it).
*/
static PRBool
IsInlineFrame(const nsIFrame* aFrame)
{
return aFrame->IsFrameOfType(nsIFrame::eLineParticipant);
}
/**
* If any children require a block parent, return the first such child.
* Otherwise return null.
*/
static nsIContent*
AnyKidsNeedBlockParent(nsIFrame *aFrameList)
{
for (nsIFrame *k = aFrameList; k; k = k->GetNextSibling()) {
// Line participants, such as text and inline frames, can't be
// directly inside a XUL box; they must be wrapped in an
// intermediate block.
if (k->IsFrameOfType(nsIFrame::eLineParticipant)) {
return k->GetContent();
}
}
return nsnull;
}
// Reparent a frame into a wrapper frame that is a child of its old parent.
static void
ReparentFrame(nsFrameManager* aFrameManager,
nsIFrame* aNewParentFrame,
nsIFrame* aFrame)
{
aFrame->SetParent(aNewParentFrame);
aFrameManager->ReParentStyleContext(aFrame);
if (aFrame->GetStateBits() &
(NS_FRAME_HAS_VIEW | NS_FRAME_HAS_CHILD_WITH_VIEW)) {
// No need to walk up the tree, since the bits are already set
// right on the parent of aNewParentFrame.
NS_ASSERTION(aNewParentFrame->GetParent()->GetStateBits() &
NS_FRAME_HAS_CHILD_WITH_VIEW,
"aNewParentFrame's parent should have this bit set!");
aNewParentFrame->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
}
}
//----------------------------------------------------------------------
//
// When inline frames get weird and have block frames in them, we
// annotate them to help us respond to incremental content changes
// more easily.
static inline PRBool
IsFrameSpecial(nsIFrame* aFrame)
{
return (aFrame->GetStateBits() & NS_FRAME_IS_SPECIAL) != 0;
}
static nsIFrame* GetSpecialSibling(nsIFrame* aFrame)
{
// We only store the "special sibling" annotation with the first
// frame in the continuation chain. Walk back to find that frame now.
aFrame = aFrame->GetFirstContinuation();
void* value = aFrame->GetProperty(nsGkAtoms::IBSplitSpecialSibling);
return static_cast<nsIFrame*>(value);
}
static nsIFrame*
GetIBSplitSpecialPrevSiblingForAnonymousBlock(nsIFrame* aFrame)
{
NS_PRECONDITION(IsFrameSpecial(aFrame) && !IsInlineFrame(aFrame),
"Shouldn't call this");
// We only store the "special sibling" annotation with the first
// frame in the continuation chain. Walk back to find that frame now.
return
static_cast<nsIFrame*>
(aFrame->GetFirstContinuation()->
GetProperty(nsGkAtoms::IBSplitSpecialPrevSibling));
}
static nsIFrame*
GetLastSpecialSibling(nsIFrame* aFrame, PRBool aIgnoreEmpty)
{
for (nsIFrame *frame = aFrame, *next; ; frame = next) {
next = GetSpecialSibling(frame);
if (!next ||
(aIgnoreEmpty && !next->GetFirstChild(nsnull)))
return frame;
}
NS_NOTREACHED("unreachable code");
return nsnull;
}
static void
SetFrameIsSpecial(nsIFrame* aFrame, nsIFrame* aSpecialSibling)
{
NS_PRECONDITION(aFrame, "bad args!");
// Mark the frame and all of its siblings as "special".
for (nsIFrame* frame = aFrame; frame != nsnull; frame = frame->GetNextContinuation()) {
frame->AddStateBits(NS_FRAME_IS_SPECIAL);
}
if (aSpecialSibling) {
// We should be the first-in-flow
NS_ASSERTION(!aFrame->GetPrevInFlow(),
"assigning special sibling to other than first-in-flow!");
// Store the "special sibling" (if we were given one) with the
// first frame in the flow.
aFrame->SetProperty(nsGkAtoms::IBSplitSpecialSibling, aSpecialSibling);
}
}
static nsIFrame*
GetIBContainingBlockFor(nsIFrame* aFrame)
{
NS_PRECONDITION(IsFrameSpecial(aFrame),
"GetIBContainingBlockFor() should only be called on known IB frames");
// Get the first "normal" ancestor of the target frame.
nsIFrame* parentFrame;
do {
parentFrame = aFrame->GetParent();
if (! parentFrame) {
NS_ERROR("no unsplit block frame in IB hierarchy");
return aFrame;
}
// Note that we ignore non-special frames which have a pseudo on their
// style context -- they're not the frames we're looking for! In
// particular, they may be hiding a real parent that _is_ special.
if (!IsFrameSpecial(parentFrame) &&
!parentFrame->GetStyleContext()->GetPseudoType())
break;
aFrame = parentFrame;
} while (1);
// post-conditions
NS_ASSERTION(parentFrame, "no normal ancestor found for special frame in GetIBContainingBlockFor");
NS_ASSERTION(parentFrame != aFrame, "parentFrame is actually the child frame - bogus reslt");
return parentFrame;
}
//----------------------------------------------------------------------
// Block/inline frame construction logic. We maintain a few invariants here:
//
// 1. Block frames contain block and inline frames.
//
// 2. Inline frames only contain inline frames. If an inline parent has a block
// child then the block child is migrated upward until it lands in a block
// parent (the inline frames containing block is where it will end up).
static nsIFrame*
FindFirstBlock(nsIFrame* aKid, nsIFrame** aPrevKid)
{
nsIFrame* prevKid = nsnull;
while (aKid) {
if (!IsInlineOutside(aKid)) {
*aPrevKid = prevKid;
return aKid;
}
prevKid = aKid;
aKid = aKid->GetNextSibling();
}
*aPrevKid = nsnull;
return nsnull;
}
static nsIFrame*
FindLastBlock(nsIFrame* aKid)
{
nsIFrame* lastBlock = nsnull;
while (aKid) {
if (!IsInlineOutside(aKid)) {
lastBlock = aKid;
}
aKid = aKid->GetNextSibling();
}
return lastBlock;
}
/*
* The special-prev-sibling is useful for
* finding the "special parent" of a frame (i.e., a frame from which a
* good parent style context can be obtained), one looks at the
* special previous sibling annotation of the real parent of the frame
* (if the real parent has NS_FRAME_IS_SPECIAL).
*/
inline void
MarkIBSpecialPrevSibling(nsIFrame *aAnonymousFrame,
nsIFrame *aSpecialParent)
{
aAnonymousFrame->SetProperty(nsGkAtoms::IBSplitSpecialPrevSibling,
aSpecialParent, nsnull, nsnull);
}
// -----------------------------------------------------------
static PRBool
IsOutOfFlowList(nsIAtom* aListName)
{
return
aListName == nsGkAtoms::floatList ||
aListName == nsGkAtoms::absoluteList ||
aListName == nsGkAtoms::overflowOutOfFlowList ||
aListName == nsGkAtoms::fixedList;
}
// Helper function that recursively removes content to frame mappings and
// undisplayed content mappings.
// This differs from DeletingFrameSubtree() because the frames have not yet been
// added to the frame hierarchy.
// XXXbz it would really help if we merged the two methods somehow... :(
static void
DoCleanupFrameReferences(nsFrameManager* aFrameManager,
nsIFrame* aFrameIn)
{
nsIContent* content = aFrameIn->GetContent();
if (aFrameIn->GetType() == nsGkAtoms::placeholderFrame) {
nsPlaceholderFrame* placeholder = static_cast<nsPlaceholderFrame*>
(aFrameIn);
// if the frame is a placeholder use the out of flow frame
aFrameIn = nsPlaceholderFrame::GetRealFrameForPlaceholder(placeholder);
// And don't forget to unregister the placeholder mapping. Note that this
// means it's the caller's responsibility to actually destroy the
// out-of-flow pointed to by the placeholder, since after this point the
// out-of-flow is not reachable via the placeholder.
aFrameManager->UnregisterPlaceholderFrame(placeholder);
}
// Remove the mapping from the content object to its frame
aFrameManager->RemoveAsPrimaryFrame(content, aFrameIn);
aFrameManager->ClearAllUndisplayedContentIn(content);
// Recursively walk the child frames.
nsIAtom* childListName = nsnull;
PRInt32 childListIndex = 0;
do {
nsIFrame* childFrame = aFrameIn->GetFirstChild(childListName);
while (childFrame) {
DoCleanupFrameReferences(aFrameManager, childFrame);
// Get the next sibling child frame
childFrame = childFrame->GetNextSibling();
}
childListName = aFrameIn->GetAdditionalChildListName(childListIndex++);
} while (childListName);
}
// Helper function that walks a frame list and calls DoCleanupFrameReference()
static void
CleanupFrameReferences(nsFrameManager* aFrameManager,
nsIFrame* aFrameList)
{
while (aFrameList) {
DoCleanupFrameReferences(aFrameManager, aFrameList);
// Get the sibling frame
aFrameList = aFrameList->GetNextSibling();
}
}
// -----------------------------------------------------------
// Structure used when constructing formatting object trees.
struct nsFrameItems {
nsIFrame* childList;
nsIFrame* lastChild;
nsFrameItems(nsIFrame* aFrame = nsnull);
// Appends the frame to the end of the list
void AddChild(nsIFrame* aChild);
// Inserts the frame somewhere in the list
void InsertChildAfter(nsIFrame* aChild, nsIFrame* aAfter);
// Remove the frame from the list, return PR_FALSE if not found. If
// aPrevSibling is given, it must have aChild as its GetNextSibling().
// aPrevSibling may be null to indicate that the list should be searched.
PRBool RemoveChild(nsIFrame* aChild, nsIFrame* aPrevSibling);
};
nsFrameItems::nsFrameItems(nsIFrame* aFrame)
: childList(aFrame), lastChild(aFrame)
{
}
void
nsFrameItems::AddChild(nsIFrame* aChild)
{
#ifdef DEBUG
nsIFrame* oldLastChild = lastChild;
#endif
if (childList == nsnull) {
childList = lastChild = aChild;
}
else
{
NS_ASSERTION(aChild != lastChild,
"Same frame being added to frame list twice?");
lastChild->SetNextSibling(aChild);
lastChild = aChild;
}
// if aChild has siblings, lastChild needs to be the last one
for (nsIFrame* sib = lastChild->GetNextSibling(); sib;
sib = sib->GetNextSibling()) {
NS_ASSERTION(oldLastChild != sib, "Loop in frame list");
lastChild = sib;
}
}
void
nsFrameItems::InsertChildAfter(nsIFrame* aChild, nsIFrame* aAfter)
{
if (!childList || (aAfter && !aAfter->GetNextSibling())) {
// Appending to the end of the list
AddChild(aChild);
return;
}
if (!aAfter) {
// Inserting at beginning of list
aChild->SetNextSibling(childList);
childList = aChild;
return;
}
aChild->SetNextSibling(aAfter->GetNextSibling());
aAfter->SetNextSibling(aChild);
}
PRBool
nsFrameItems::RemoveChild(nsIFrame* aFrame, nsIFrame* aPrevSibling)
{
NS_PRECONDITION(aFrame, "null ptr");
nsIFrame* prev;
if (aPrevSibling) {
prev = aPrevSibling;
} else {
prev = nsnull;
nsIFrame* sib;
for (sib = childList; sib && sib != aFrame; sib = sib->GetNextSibling()) {
prev = sib;
}
if (!sib) {
return PR_FALSE;
}
}
NS_ASSERTION(!prev || prev->GetNextSibling() == aFrame,
"Unexpected prevsibling");
if (aFrame == childList) {
childList = aFrame->GetNextSibling();
} else {
prev->SetNextSibling(aFrame->GetNextSibling());
}
if (aFrame == lastChild) {
lastChild = prev;
}
aFrame->SetNextSibling(nsnull);
return PR_TRUE;
}
// -----------------------------------------------------------
// Structure used when constructing formatting object trees. Contains
// state information needed for absolutely positioned elements
struct nsAbsoluteItems : nsFrameItems {
// containing block for absolutely positioned elements
nsIFrame* containingBlock;
nsAbsoluteItems(nsIFrame* aContainingBlock);
#ifdef DEBUG
// XXXbz Does this need a debug-only assignment operator that nulls out the
// childList in the nsAbsoluteItems we're copying? Introducing a difference
// between debug and non-debug behavior seems bad, so I guess not...
~nsAbsoluteItems() {
NS_ASSERTION(!childList,
"Dangling child list. Someone forgot to insert it?");
}
#endif
// Appends the frame to the end of the list
void AddChild(nsIFrame* aChild);
};
nsAbsoluteItems::nsAbsoluteItems(nsIFrame* aContainingBlock)
: containingBlock(aContainingBlock)
{
}
// Additional behavior is that it sets the frame's NS_FRAME_OUT_OF_FLOW flag
void
nsAbsoluteItems::AddChild(nsIFrame* aChild)
{
NS_ASSERTION(aChild->PresContext()->FrameManager()->
GetPlaceholderFrameFor(aChild),
"Child without placeholder being added to nsAbsoluteItems?");
aChild->AddStateBits(NS_FRAME_OUT_OF_FLOW);
nsFrameItems::AddChild(aChild);
}
// Structures used to record the creation of pseudo table frames where
// the content belongs to some ancestor.
// PseudoFrames are necessary when the childframe cannot be the direct
// ancestor of the content based parent frame. The amount of necessary pseudo
// frames is limited as the worst case would be table frame nested directly
// into another table frame. So the member structures of nsPseudoFrames can be
// viewed as a ring buffer where you start with the necessary frame type and
// add higher frames as long as necessary to fit into the initial parent frame.
// mLowestType is some sort of stack pointer which shows the start of the
// ringbuffer. The insertion of pseudo frames can happen between every
// two frames so we need to push and pop the pseudo frame data when children
// of a frame are created.
// The colgroup frame is special as it can harbour only col children.
// Once all children of given frame are known, the pseudo frames can be
// processed that means attached to the corresponding parent frames.
// The behaviour is in general described at
// http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
// however there are implementation details that extend the CSS 2.1
// specification:
// 1. every table frame is wrapped in an outer table frame, which is always a
// pseudo frame.
// 2. the outer table frame will be also created to hold a caption.
// 3. each table cell will have a pseudo inner table cell frame.
// 4. a colgroup frame is created between a column and a table
// 5. a rowgroup frame is created between a row and a table
// A table frame can only have rowgroups or column groups as children.
// A outer table frame can only have one caption and one table frame
// as children.
// Every table even if all table frames are specified will require the
// creation of two types of pseudo frames: the outer table frame and the inner
// table cell frames.
struct nsPseudoFrameData {
nsIFrame* mFrame; // created pseudo frame
nsFrameItems mChildList; // child frames pending to be added to the pseudo
nsFrameItems mChildList2; // child frames pending to be added to the pseudo
nsPseudoFrameData();
nsPseudoFrameData(nsPseudoFrameData& aOther);
void Reset();
#ifdef DEBUG
void Dump();
#endif
};
struct nsPseudoFrames {
nsPseudoFrameData mTableOuter;
nsPseudoFrameData mTableInner;
nsPseudoFrameData mRowGroup;
nsPseudoFrameData mColGroup;
nsPseudoFrameData mRow;
nsPseudoFrameData mCellOuter;
nsPseudoFrameData mCellInner;
// the frame type of the most descendant pseudo frame, no AddRef
nsIAtom* mLowestType;
nsPseudoFrames();
nsPseudoFrames& operator=(const nsPseudoFrames& aOther);
void Reset(nsPseudoFrames* aSave = nsnull);
PRBool IsEmpty() { return (!mLowestType && !mColGroup.mFrame); }
#ifdef DEBUG
void Dump();
#endif
};
nsPseudoFrameData::nsPseudoFrameData()
: mFrame(nsnull), mChildList(), mChildList2()
{}
nsPseudoFrameData::nsPseudoFrameData(nsPseudoFrameData& aOther)
: mFrame(aOther.mFrame), mChildList(aOther.mChildList),
mChildList2(aOther.mChildList2)
{}
void
nsPseudoFrameData::Reset()
{
mFrame = nsnull;
mChildList.childList = mChildList.lastChild = nsnull;
mChildList2.childList = mChildList2.lastChild = nsnull;
}
#ifdef DEBUG
void
nsPseudoFrameData::Dump()
{
nsIFrame* main = nsnull;
nsIFrame* second = nsnull;
printf(" %p\n", static_cast<void*>(mFrame));
main = mChildList.childList;
second = mChildList2.childList;
while (main || second) {
printf(" %p %p\n", static_cast<void*>(main),
static_cast<void*>(second));
if (main)
main = main->GetNextSibling();
if (second)
second = second->GetNextSibling();
}
}
#endif
nsPseudoFrames::nsPseudoFrames()
: mTableOuter(), mTableInner(), mRowGroup(), mColGroup(),
mRow(), mCellOuter(), mCellInner(), mLowestType(nsnull)
{}
nsPseudoFrames& nsPseudoFrames::operator=(const nsPseudoFrames& aOther)
{
mTableOuter = aOther.mTableOuter;
mTableInner = aOther.mTableInner;
mColGroup = aOther.mColGroup;
mRowGroup = aOther.mRowGroup;
mRow = aOther.mRow;
mCellOuter = aOther.mCellOuter;
mCellInner = aOther.mCellInner;
mLowestType = aOther.mLowestType;
return *this;
}
void
nsPseudoFrames::Reset(nsPseudoFrames* aSave)
{
if (aSave) {
*aSave = *this;
}
mTableOuter.Reset();
mTableInner.Reset();
mColGroup.Reset();
mRowGroup.Reset();
mRow.Reset();
mCellOuter.Reset();
mCellInner.Reset();
mLowestType = nsnull;
}
#ifdef DEBUG
void
nsPseudoFrames::Dump()
{
if (IsEmpty()) {
// check that it is really empty, warn otherwise
NS_ASSERTION(!mTableOuter.mFrame, "Pseudo Outer Table Frame not empty");
NS_ASSERTION(!mTableOuter.mChildList.childList, "Pseudo Outer Table Frame has primary children");
NS_ASSERTION(!mTableOuter.mChildList2.childList,"Pseudo Outer Table Frame has secondary children");
NS_ASSERTION(!mTableInner.mFrame, "Pseudo Inner Table Frame not empty");
NS_ASSERTION(!mTableInner.mChildList.childList, "Pseudo Inner Table Frame has primary children");
NS_ASSERTION(!mTableInner.mChildList2.childList,"Pseudo Inner Table Frame has secondary children");
NS_ASSERTION(!mColGroup.mFrame, "Pseudo Colgroup Frame not empty");
NS_ASSERTION(!mColGroup.mChildList.childList, "Pseudo Colgroup Table Frame has primary children");
NS_ASSERTION(!mColGroup.mChildList2.childList, "Pseudo Colgroup Table Frame has secondary children");
NS_ASSERTION(!mRowGroup.mFrame, "Pseudo Rowgroup Frame not empty");
NS_ASSERTION(!mRowGroup.mChildList.childList, "Pseudo Rowgroup Frame has primary children");
NS_ASSERTION(!mRowGroup.mChildList2.childList, "Pseudo Rowgroup Frame has secondary children");
NS_ASSERTION(!mRow.mFrame, "Pseudo Row Frame not empty");
NS_ASSERTION(!mRow.mChildList.childList, "Pseudo Row Frame has primary children");
NS_ASSERTION(!mRow.mChildList2.childList, "Pseudo Row Frame has secondary children");
NS_ASSERTION(!mCellOuter.mFrame, "Pseudo Outer Cell Frame not empty");
NS_ASSERTION(!mCellOuter.mChildList.childList, "Pseudo Outer Cell Frame has primary children");
NS_ASSERTION(!mCellOuter.mChildList2.childList, "Pseudo Outer Cell Frame has secondary children");
NS_ASSERTION(!mCellInner.mFrame, "Pseudo Inner Cell Frame not empty");
NS_ASSERTION(!mCellInner.mChildList.childList, "Pseudo Inner Cell Frame has primary children");
NS_ASSERTION(!mCellInner.mChildList2.childList, "Pseudo inner Cell Frame has secondary children");
}
else {
if (mTableOuter.mFrame || mTableOuter.mChildList.childList || mTableOuter.mChildList2.childList) {
if (nsGkAtoms::tableOuterFrame == mLowestType) {
printf("LOW OuterTable\n");
}
else {
printf(" OuterTable\n");
}
mTableOuter.Dump();
}
if (mTableInner.mFrame || mTableInner.mChildList.childList || mTableInner.mChildList2.childList) {
if (nsGkAtoms::tableFrame == mLowestType) {
printf("LOW InnerTable\n");
}
else {
printf(" InnerTable\n");
}
mTableInner.Dump();
}
if (mColGroup.mFrame || mColGroup.mChildList.childList || mColGroup.mChildList2.childList) {
if (nsGkAtoms::tableColGroupFrame == mLowestType) {
printf("LOW ColGroup\n");
}
else {
printf(" ColGroup\n");
}
mColGroup.Dump();
}
if (mRowGroup.mFrame || mRowGroup.mChildList.childList || mRowGroup.mChildList2.childList) {
if (nsGkAtoms::tableRowGroupFrame == mLowestType) {
printf("LOW RowGroup\n");
}
else {
printf(" RowGroup\n");
}
mRowGroup.Dump();
}
if (mRow.mFrame || mRow.mChildList.childList || mRow.mChildList2.childList) {
if (nsGkAtoms::tableRowFrame == mLowestType) {
printf("LOW Row\n");
}
else {
printf(" Row\n");
}
mRow.Dump();
}
if (mCellOuter.mFrame || mCellOuter.mChildList.childList || mCellOuter.mChildList2.childList) {
if (IS_TABLE_CELL(mLowestType)) {
printf("LOW OuterCell\n");
}
else {
printf(" OuterCell\n");
}
mCellOuter.Dump();
}
if (mCellInner.mFrame || mCellInner.mChildList.childList || mCellInner.mChildList2.childList) {
printf(" InnerCell\n");
mCellInner.Dump();
}
}
}
#endif
// -----------------------------------------------------------
// Structure for saving the existing state when pushing/poping containing
// blocks. The destructor restores the state to its previous state
class NS_STACK_CLASS nsFrameConstructorSaveState {
public:
nsFrameConstructorSaveState();
~nsFrameConstructorSaveState();
private:
nsAbsoluteItems* mItems; // pointer to struct whose data we save/restore
PRPackedBool* mFixedPosIsAbsPos;
nsAbsoluteItems mSavedItems; // copy of original data
PRPackedBool mSavedFixedPosIsAbsPos;
// The name of the child list in which our frames would belong
nsIAtom* mChildListName;
nsFrameConstructorState* mState;
friend class nsFrameConstructorState;
};
// Structure used for maintaining state information during the
// frame construction process
class NS_STACK_CLASS nsFrameConstructorState {
public:
nsPresContext *mPresContext;
nsIPresShell *mPresShell;
nsFrameManager *mFrameManager;
#ifdef MOZ_XUL
// Frames destined for the nsGkAtoms::popupList.
nsAbsoluteItems mPopupItems;
#endif
// Containing block information for out-of-flow frames.
nsAbsoluteItems mFixedItems;
nsAbsoluteItems mAbsoluteItems;
nsAbsoluteItems mFloatedItems;
// When working with the -moz-transform property, we want to hook
// the abs-pos and fixed-pos lists together, since transformed
// elements are fixed-pos containing blocks. This flag determines
// whether or not we want to wire the fixed-pos and abs-pos lists
// together.
PRPackedBool mFixedPosIsAbsPos;
// A boolean to indicate whether we have a "pending" popupgroup. That is, we
// have already created the FrameConstructionItem for the root popupgroup but
// we have not yet created the relevant frame.
PRPackedBool mHavePendingPopupgroup;
nsCOMPtr<nsILayoutHistoryState> mFrameState;
nsPseudoFrames mPseudoFrames;
// These bits will be added to the state bits of any frame we construct
// using this state.
nsFrameState mAdditionalStateBits;
// Constructor
// Use the passed-in history state.
nsFrameConstructorState(nsIPresShell* aPresShell,
nsIFrame* aFixedContainingBlock,
nsIFrame* aAbsoluteContainingBlock,
nsIFrame* aFloatContainingBlock,
nsILayoutHistoryState* aHistoryState);
// Get the history state from the pres context's pres shell.
nsFrameConstructorState(nsIPresShell* aPresShell,
nsIFrame* aFixedContainingBlock,
nsIFrame* aAbsoluteContainingBlock,
nsIFrame* aFloatContainingBlock);
~nsFrameConstructorState();
// Function to push the existing absolute containing block state and
// create a new scope. Code that uses this function should get matching
// logic in GetAbsoluteContainingBlock.
void PushAbsoluteContainingBlock(nsIFrame* aNewAbsoluteContainingBlock,
nsFrameConstructorSaveState& aSaveState);
// Function to push the existing float containing block state and
// create a new scope. Code that uses this function should get matching
// logic in GetFloatContainingBlock.
// Pushing a null float containing block forbids any frames from being
// floated until a new float containing block is pushed.
// XXX we should get rid of null float containing blocks and teach the
// various frame classes to deal with floats instead.
void PushFloatContainingBlock(nsIFrame* aNewFloatContainingBlock,
nsFrameConstructorSaveState& aSaveState);
// Function to return the proper geometric parent for a frame with display
// struct given by aStyleDisplay and parent's frame given by
// aContentParentFrame.
nsIFrame* GetGeometricParent(const nsStyleDisplay* aStyleDisplay,
nsIFrame* aContentParentFrame);
/**
* Function to add a new frame to the right frame list. This MUST be called
* on frames before their children have been processed if the frames might
* conceivably be out-of-flow; otherwise cleanup in error cases won't work
* right. Also, this MUST be called on frames after they have been
* initialized.
* @param aNewFrame the frame to add
* @param aFrameItems the list to add in-flow frames to
* @param aContent the content pointer for aNewFrame
* @param aStyleContext the style context resolved for aContent
* @param aParentFrame the parent frame for the content if it were in-flow
* @param aCanBePositioned pass false if the frame isn't allowed to be
* positioned
* @param aCanBeFloated pass false if the frame isn't allowed to be
* floated
* @param aIsOutOfFlowPopup pass true if the frame is an out-of-flow popup
* (XUL-only)
* @throws NS_ERROR_OUT_OF_MEMORY if it happens.
* @note If this method throws, that means that aNewFrame was not inserted
* into any frame lists. Furthermore, this method will handle cleanup
* of aNewFrame (via calling CleanupFrameReferences() and Destroy() on
* it).
*/
nsresult AddChild(nsIFrame* aNewFrame,
nsFrameItems& aFrameItems,
nsIContent* aContent,
nsStyleContext* aStyleContext,
nsIFrame* aParentFrame,
PRBool aCanBePositioned = PR_TRUE,
PRBool aCanBeFloated = PR_TRUE,
PRBool aIsOutOfFlowPopup = PR_FALSE,
PRBool aInsertAfter = PR_FALSE,
nsIFrame* aInsertAfterFrame = nsnull);
/**
* Function to return the fixed-pos element list. Normally this will just hand back the
* fixed-pos element list, but in case we're dealing with a transformed element that's
* acting as an abs-pos and fixed-pos container, we'll hand back the abs-pos list. Callers should
* use this function if they want to get the list acting as the fixed-pos item parent.
*/
nsAbsoluteItems& GetFixedItems()
{
return mFixedPosIsAbsPos ? mAbsoluteItems : mFixedItems;
}
const nsAbsoluteItems& GetFixedItems() const
{
return mFixedPosIsAbsPos ? mAbsoluteItems : mFixedItems;
}
protected:
friend class nsFrameConstructorSaveState;
/**
* ProcessFrameInsertions takes the frames in aFrameItems and adds them as
* kids to the aChildListName child list of |aFrameItems.containingBlock|.
*/
void ProcessFrameInsertions(nsAbsoluteItems& aFrameItems,
nsIAtom* aChildListName);
};
nsFrameConstructorState::nsFrameConstructorState(nsIPresShell* aPresShell,
nsIFrame* aFixedContainingBlock,
nsIFrame* aAbsoluteContainingBlock,
nsIFrame* aFloatContainingBlock,
nsILayoutHistoryState* aHistoryState)
: mPresContext(aPresShell->GetPresContext()),
mPresShell(aPresShell),
mFrameManager(aPresShell->FrameManager()),
#ifdef MOZ_XUL
mPopupItems(nsnull),
#endif
mFixedItems(aFixedContainingBlock),
mAbsoluteItems(aAbsoluteContainingBlock),
mFloatedItems(aFloatContainingBlock),
// See PushAbsoluteContaningBlock below
mFixedPosIsAbsPos(aAbsoluteContainingBlock &&
aAbsoluteContainingBlock->GetStyleDisplay()->
HasTransform()),
mHavePendingPopupgroup(PR_FALSE),
mFrameState(aHistoryState),
mPseudoFrames(),
mAdditionalStateBits(0)
{
#ifdef MOZ_XUL
nsIRootBox* rootBox = nsIRootBox::GetRootBox(aPresShell);
if (rootBox) {
mPopupItems.containingBlock = rootBox->GetPopupSetFrame();
}
#endif
MOZ_COUNT_CTOR(nsFrameConstructorState);
}
nsFrameConstructorState::nsFrameConstructorState(nsIPresShell* aPresShell,
nsIFrame* aFixedContainingBlock,
nsIFrame* aAbsoluteContainingBlock,
nsIFrame* aFloatContainingBlock)
: mPresContext(aPresShell->GetPresContext()),
mPresShell(aPresShell),
mFrameManager(aPresShell->FrameManager()),
#ifdef MOZ_XUL
mPopupItems(nsnull),
#endif
mFixedItems(aFixedContainingBlock),
mAbsoluteItems(aAbsoluteContainingBlock),
mFloatedItems(aFloatContainingBlock),
// See PushAbsoluteContaningBlock below
mFixedPosIsAbsPos(aAbsoluteContainingBlock &&
aAbsoluteContainingBlock->GetStyleDisplay()->
HasTransform()),
mHavePendingPopupgroup(PR_FALSE),
mPseudoFrames(),
mAdditionalStateBits(0)
{
#ifdef MOZ_XUL
nsIRootBox* rootBox = nsIRootBox::GetRootBox(aPresShell);
if (rootBox) {
mPopupItems.containingBlock = rootBox->GetPopupSetFrame();
}
#endif
MOZ_COUNT_CTOR(nsFrameConstructorState);
mFrameState = aPresShell->GetDocument()->GetLayoutHistoryState();
}
nsFrameConstructorState::~nsFrameConstructorState()
{
// Frame order comparison functions only work properly when the placeholders
// have been inserted into the frame tree. So for example if we have a new float
// containing the placeholder for a new abs-pos frame, and we process the abs-pos
// insertion first, then we won't be able to find the right place to insert in
// in the abs-pos list. So put floats in first, because they can contain placeholders
// for abs-pos and fixed-pos items whose containing blocks are outside the floats.
// Then put abs-pos frames in, because they can contain placeholders for fixed-pos
// items whose containing block is outside the abs-pos frames.
MOZ_COUNT_DTOR(nsFrameConstructorState);
ProcessFrameInsertions(mFloatedItems, nsGkAtoms::floatList);
ProcessFrameInsertions(mAbsoluteItems, nsGkAtoms::absoluteList);
ProcessFrameInsertions(mFixedItems, nsGkAtoms::fixedList);
#ifdef MOZ_XUL
ProcessFrameInsertions(mPopupItems, nsGkAtoms::popupList);
#endif
}
static nsIFrame*
AdjustAbsoluteContainingBlock(nsIFrame* aContainingBlockIn)
{
if (!aContainingBlockIn) {
return nsnull;
}
// Always use the container's first continuation. (Inline frames can have
// non-fluid bidi continuations...)
return aContainingBlockIn->GetFirstContinuation();
}
void
nsFrameConstructorState::PushAbsoluteContainingBlock(nsIFrame* aNewAbsoluteContainingBlock,
nsFrameConstructorSaveState& aSaveState)
{
aSaveState.mItems = &mAbsoluteItems;
aSaveState.mSavedItems = mAbsoluteItems;
aSaveState.mChildListName = nsGkAtoms::absoluteList;
aSaveState.mState = this;
/* Store whether we're wiring the abs-pos and fixed-pos lists together. */
aSaveState.mFixedPosIsAbsPos = &mFixedPosIsAbsPos;
aSaveState.mSavedFixedPosIsAbsPos = mFixedPosIsAbsPos;
mAbsoluteItems =
nsAbsoluteItems(AdjustAbsoluteContainingBlock(aNewAbsoluteContainingBlock));
/* See if we're wiring the fixed-pos and abs-pos lists together. This happens iff
* we're a transformed element.
*/
mFixedPosIsAbsPos = (aNewAbsoluteContainingBlock &&
aNewAbsoluteContainingBlock->GetStyleDisplay()->HasTransform());
}
void
nsFrameConstructorState::PushFloatContainingBlock(nsIFrame* aNewFloatContainingBlock,
nsFrameConstructorSaveState& aSaveState)
{
NS_PRECONDITION(!aNewFloatContainingBlock ||
aNewFloatContainingBlock->IsFloatContainingBlock(),
"Please push a real float containing block!");
aSaveState.mItems = &mFloatedItems;
aSaveState.mSavedItems = mFloatedItems;
aSaveState.mChildListName = nsGkAtoms::floatList;
aSaveState.mState = this;
mFloatedItems = nsAbsoluteItems(aNewFloatContainingBlock);
}
nsIFrame*
nsFrameConstructorState::GetGeometricParent(const nsStyleDisplay* aStyleDisplay,
nsIFrame* aContentParentFrame)
{
NS_PRECONDITION(aStyleDisplay, "Must have display struct!");
// If there is no container for a fixed, absolute, or floating root
// frame, we will ignore the positioning. This hack is originally
// brought to you by the letter T: tables, since other roots don't
// even call into this code. See bug 178855.
//
// XXX Disabling positioning in this case is a hack. If one was so inclined,
// one could support this either by (1) inserting a dummy block between the
// table and the canvas or (2) teaching the canvas how to reflow positioned
// elements. (1) has the usual problems when multiple frames share the same
// content (notice all the special cases in this file dealing with inner
// tables and outer tables which share the same content). (2) requires some
// work and possible factoring.
//
// XXXbz couldn't we just force position to "static" on roots and
// float to "none"? That's OK per CSS 2.1, as far as I can tell.
if (aStyleDisplay->IsFloating() && mFloatedItems.containingBlock) {
NS_ASSERTION(!aStyleDisplay->IsAbsolutelyPositioned(),
"Absolutely positioned _and_ floating?");
return mFloatedItems.containingBlock;
}
if (aStyleDisplay->mPosition == NS_STYLE_POSITION_ABSOLUTE &&
mAbsoluteItems.containingBlock) {
return mAbsoluteItems.containingBlock;
}
if (aStyleDisplay->mPosition == NS_STYLE_POSITION_FIXED &&
GetFixedItems().containingBlock) {
return GetFixedItems().containingBlock;
}
return aContentParentFrame;
}
nsresult
nsFrameConstructorState::AddChild(nsIFrame* aNewFrame,
nsFrameItems& aFrameItems,
nsIContent* aContent,
nsStyleContext* aStyleContext,
nsIFrame* aParentFrame,
PRBool aCanBePositioned,
PRBool aCanBeFloated,
PRBool aIsOutOfFlowPopup,
PRBool aInsertAfter,
nsIFrame* aInsertAfterFrame)
{
const nsStyleDisplay* disp = aNewFrame->GetStyleDisplay();
// The comments in GetGeometricParent regarding root table frames
// all apply here, unfortunately.
PRBool needPlaceholder = PR_FALSE;
nsFrameItems* frameItems = &aFrameItems;
#ifdef MOZ_XUL
if (NS_UNLIKELY(aIsOutOfFlowPopup)) {
NS_ASSERTION(aNewFrame->GetParent() == mPopupItems.containingBlock,
"Popup whose parent is not the popup containing block?");
NS_ASSERTION(mPopupItems.containingBlock, "Must have a popup set frame!");
needPlaceholder = PR_TRUE;
frameItems = &mPopupItems;
}
else
#endif // MOZ_XUL
if (aCanBeFloated && disp->IsFloating() &&
mFloatedItems.containingBlock) {
NS_ASSERTION(aNewFrame->GetParent() == mFloatedItems.containingBlock,
"Float whose parent is not the float containing block?");
needPlaceholder = PR_TRUE;
frameItems = &mFloatedItems;
}
else if (aCanBePositioned) {
if (disp->mPosition == NS_STYLE_POSITION_ABSOLUTE &&
mAbsoluteItems.containingBlock) {
NS_ASSERTION(aNewFrame->GetParent() == mAbsoluteItems.containingBlock,
"Abs pos whose parent is not the abs pos containing block?");
needPlaceholder = PR_TRUE;
frameItems = &mAbsoluteItems;
}
if (disp->mPosition == NS_STYLE_POSITION_FIXED &&
GetFixedItems().containingBlock) {
NS_ASSERTION(aNewFrame->GetParent() == GetFixedItems().containingBlock,
"Fixed pos whose parent is not the fixed pos containing block?");
needPlaceholder = PR_TRUE;
frameItems = &GetFixedItems();
}
}
if (needPlaceholder) {
NS_ASSERTION(frameItems != &aFrameItems,
"Putting frame in-flow _and_ want a placeholder?");
nsIFrame* placeholderFrame;
nsresult rv =
nsCSSFrameConstructor::CreatePlaceholderFrameFor(mPresShell,
aContent,
aNewFrame,
aStyleContext,
aParentFrame,
nsnull,
&placeholderFrame);
if (NS_FAILED(rv)) {
// Note that aNewFrame could be the top frame for a scrollframe setup,
// hence already set as the primary frame. So we have to clean up here.
// But it shouldn't have any out-of-flow kids.
// XXXbz Maybe add a utility function to assert that?
CleanupFrameReferences(mFrameManager, aNewFrame);
aNewFrame->Destroy();
return rv;
}
placeholderFrame->AddStateBits(mAdditionalStateBits);
// Add the placeholder frame to the flow
aFrameItems.AddChild(placeholderFrame);
}
#ifdef DEBUG
else {
NS_ASSERTION(aNewFrame->GetParent() == aParentFrame,
"In-flow frame has wrong parent");
}
#endif
if (aInsertAfter) {
frameItems->InsertChildAfter(aNewFrame, aInsertAfterFrame);
} else {
frameItems->AddChild(aNewFrame);
}
// Now add the special siblings too.
nsIFrame* specialSibling = aNewFrame;
while (specialSibling && IsFrameSpecial(specialSibling)) {
specialSibling = GetSpecialSibling(specialSibling);
if (specialSibling) {
NS_ASSERTION(frameItems == &aFrameItems,
"IB split ending up in an out-of-flow childlist?");
frameItems->AddChild(specialSibling);
}
}
return NS_OK;
}
void
nsFrameConstructorState::ProcessFrameInsertions(nsAbsoluteItems& aFrameItems,
nsIAtom* aChildListName)
{
#define NS_NONXUL_LIST_TEST (&aFrameItems == &mFloatedItems && \
aChildListName == nsGkAtoms::floatList) || \
(&aFrameItems == &mAbsoluteItems && \
aChildListName == nsGkAtoms::absoluteList) || \
(&aFrameItems == &mFixedItems && \
aChildListName == nsGkAtoms::fixedList)
#ifdef MOZ_XUL
NS_PRECONDITION(NS_NONXUL_LIST_TEST ||
(&aFrameItems == &mPopupItems &&
aChildListName == nsGkAtoms::popupList),
"Unexpected aFrameItems/aChildListName combination");
#else
NS_PRECONDITION(NS_NONXUL_LIST_TEST,
"Unexpected aFrameItems/aChildListName combination");
#endif
nsIFrame* firstNewFrame = aFrameItems.childList;
if (!firstNewFrame) {
return;
}
nsIFrame* containingBlock = aFrameItems.containingBlock;
NS_ASSERTION(containingBlock,
"Child list without containing block?");
// Insert the frames hanging out in aItems. We can use SetInitialChildList()
// if the containing block hasn't been reflown yet (so NS_FRAME_FIRST_REFLOW
// is set) and doesn't have any frames in the aChildListName child list yet.
nsIFrame* firstChild = containingBlock->GetFirstChild(aChildListName);
nsresult rv = NS_OK;
if (!firstChild && (containingBlock->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
rv = containingBlock->SetInitialChildList(aChildListName, firstNewFrame);
} else {
// Note that whether the frame construction context is doing an append or
// not is not helpful here, since it could be appending to some frame in
// the middle of the document, which means we're not necessarily
// appending to the children of the containing block.
//
// We need to make sure the 'append to the end of document' case is fast.
// So first test the last child of the containing block
nsIFrame* lastChild = nsLayoutUtils::GetLastSibling(firstChild);
// CompareTreePosition uses placeholder hierarchy for out of flow frames,
// so this will make out-of-flows respect the ordering of placeholders,
// which is great because it takes care of anonymous content.
if (!lastChild ||
nsLayoutUtils::CompareTreePosition(lastChild, firstNewFrame, containingBlock) < 0) {
// no lastChild, or lastChild comes before the new children, so just append
rv = containingBlock->AppendFrames(aChildListName, firstNewFrame);
} else {
nsIFrame* insertionPoint = nsnull;
// try the other children
for (nsIFrame* f = firstChild; f != lastChild; f = f->GetNextSibling()) {
PRInt32 compare =
nsLayoutUtils::CompareTreePosition(f, firstNewFrame, containingBlock);
if (compare > 0) {
// f comes after the new children, so stop here and insert after
// the previous frame
break;
}
insertionPoint = f;
}
rv = containingBlock->InsertFrames(aChildListName, insertionPoint,
firstNewFrame);
}
}
aFrameItems.childList = nsnull;
// XXXbz And if NS_FAILED(rv), what? I guess we need to clean up the list
// and deal with all the placeholders... but what if the placeholders aren't
// in the document yet? Could that happen?
NS_ASSERTION(NS_SUCCEEDED(rv), "Frames getting lost!");
}
nsFrameConstructorSaveState::nsFrameConstructorSaveState()
: mItems(nsnull),
mFixedPosIsAbsPos(nsnull),
mSavedItems(nsnull),
mSavedFixedPosIsAbsPos(PR_FALSE),
mChildListName(nsnull),
mState(nsnull)
{
}
nsFrameConstructorSaveState::~nsFrameConstructorSaveState()
{
// Restore the state
if (mItems) {
NS_ASSERTION(mState, "Can't have mItems set without having a state!");
mState->ProcessFrameInsertions(*mItems, mChildListName);
*mItems = mSavedItems;
#ifdef DEBUG
// We've transferred the child list, so drop the pointer we held to it.
// Note that this only matters for the assert in ~nsAbsoluteItems.
mSavedItems.childList = nsnull;
#endif
}
if (mFixedPosIsAbsPos) {
*mFixedPosIsAbsPos = mSavedFixedPosIsAbsPos;
}
}
static
PRBool IsBorderCollapse(nsIFrame* aFrame)
{
for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
if (nsGkAtoms::tableFrame == frame->GetType()) {
return ((nsTableFrame*)frame)->IsBorderCollapse();
}
}
NS_ASSERTION(PR_FALSE, "program error");
return PR_FALSE;
}
/**
* Utility method, called from MoveChildrenTo(), that recursively
* descends down the frame hierarchy looking for floating frames that
* need parent pointer adjustments to account for the containment block
* changes that could occur as the result of the reparenting done in
* MoveChildrenTo().
*/
static void
AdjustFloatParentPtrs(nsIFrame* aFrame,
nsFrameConstructorState& aState,
nsFrameConstructorState& aOuterState)
{
NS_PRECONDITION(aFrame, "must have frame to work with");
nsIFrame *outOfFlowFrame = nsPlaceholderFrame::GetRealFrameFor(aFrame);
if (outOfFlowFrame != aFrame) {
if (outOfFlowFrame->GetStyleDisplay()->IsFloating()) {
// Update the parent pointer for outOfFlowFrame since its
// containing block has changed as the result of reparenting
// and move it from the outer state to the inner, bug 307277.
nsIFrame *parent = aState.mFloatedItems.containingBlock;
NS_ASSERTION(parent, "Should have float containing block here!");
NS_ASSERTION(outOfFlowFrame->GetParent() == aOuterState.mFloatedItems.containingBlock,
"expected the float to be a child of the outer CB");
if (aOuterState.mFloatedItems.RemoveChild(outOfFlowFrame, nsnull)) {
aState.mFloatedItems.AddChild(outOfFlowFrame);
} else {
NS_NOTREACHED("float wasn't in the outer state float list");
}
outOfFlowFrame->SetParent(parent);
if (outOfFlowFrame->GetStateBits() &
(NS_FRAME_HAS_VIEW | NS_FRAME_HAS_CHILD_WITH_VIEW)) {
// We don't need to walk up the tree, since we're doing this
// recursively.
parent->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
}
}
// All out-of-flows are automatically float containing blocks, so we're
// done here.
return;
}
if (aFrame->IsFloatContainingBlock()) {
// No need to recurse further; floats whose placeholders are
// inside a block already have the right parent.
return;
}
// Dive down into children to see if any of their
// placeholders need adjusting.
nsIFrame *childFrame = aFrame->GetFirstChild(nsnull);
while (childFrame) {
// XXX_kin: Do we need to prevent descent into anonymous content here?
AdjustFloatParentPtrs(childFrame, aState, aOuterState);
childFrame = childFrame->GetNextSibling();
}
}
/**
* Moves frames to a new parent, updating the style context and propagating
* relevant frame state bits. |aState| may be null, in which case the parent
* pointers of out-of-flow frames will remain untouched.
*/
static void
MoveChildrenTo(nsFrameManager* aFrameManager,
nsIFrame* aNewParent,
nsIFrame* aFrameList,
nsIFrame* aFrameListEnd,
nsFrameConstructorState* aState,
nsFrameConstructorState* aOuterState)
{
PRBool setHasChildWithView = PR_FALSE;
while (aFrameList && aFrameList != aFrameListEnd) {
if (!setHasChildWithView
&& (aFrameList->GetStateBits() & (NS_FRAME_HAS_VIEW | NS_FRAME_HAS_CHILD_WITH_VIEW))) {
setHasChildWithView = PR_TRUE;
}
aFrameList->SetParent(aNewParent);
// If aState is not null, the caller expects us to make adjustments so that
// floats whose placeholders are descendants of frames in aFrameList point
// to the correct parent.
if (aState) {
NS_ASSERTION(aOuterState, "need an outer state too");
AdjustFloatParentPtrs(aFrameList, *aState, *aOuterState);
}
aFrameList = aFrameList->GetNextSibling();
}
if (setHasChildWithView) {
do {
aNewParent->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
aNewParent = aNewParent->GetParent();
} while (aNewParent &&
!(aNewParent->GetStateBits() & NS_FRAME_HAS_CHILD_WITH_VIEW));
}
}
// -----------------------------------------------------------
// Structure used to ensure that bindings are properly enqueued in the
// binding manager's attached queue.
struct NS_STACK_CLASS nsAutoEnqueueBinding
{
nsAutoEnqueueBinding(nsIDocument* aDocument) :
mDocument(aDocument)
{}
~nsAutoEnqueueBinding();
nsRefPtr<nsXBLBinding> mBinding;
private:
nsIDocument* mDocument;
};
nsAutoEnqueueBinding::~nsAutoEnqueueBinding()
{
if (mBinding) {
mDocument->BindingManager()->AddToAttachedQueue(mBinding);
}
}
// Helper function that determines the child list name that aChildFrame
// is contained in
static nsIAtom*
GetChildListNameFor(nsIFrame* aChildFrame)
{
nsIAtom* listName;
if (aChildFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER) {
listName = nsGkAtoms::overflowContainersList;
}
// See if the frame is moved out of the flow
else if (aChildFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
// Look at the style information to tell
const nsStyleDisplay* disp = aChildFrame->GetStyleDisplay();
if (NS_STYLE_POSITION_ABSOLUTE == disp->mPosition) {
listName = nsGkAtoms::absoluteList;
} else if (NS_STYLE_POSITION_FIXED == disp->mPosition) {
if (nsLayoutUtils::IsReallyFixedPos(aChildFrame)) {
listName = nsGkAtoms::fixedList;
} else {
listName = nsGkAtoms::absoluteList;
}
#ifdef MOZ_XUL
} else if (NS_STYLE_DISPLAY_POPUP == disp->mDisplay) {
// Out-of-flows that are DISPLAY_POPUP must be kids of the root popup set
#ifdef DEBUG
nsIFrame* parent = aChildFrame->GetParent();
NS_ASSERTION(parent && parent->GetType() == nsGkAtoms::popupSetFrame,
"Unexpected parent");
#endif // DEBUG
// XXX FIXME: Bug 350740
// Return here, because the postcondition for this function actually
// fails for this case, since the popups are not in a "real" frame list
// in the popup set.
return nsGkAtoms::popupList;
#endif // MOZ_XUL
} else {
NS_ASSERTION(aChildFrame->GetStyleDisplay()->IsFloating(),
"not a floated frame");
listName = nsGkAtoms::floatList;
}
} else {
listName = nsnull;
}
#ifdef NS_DEBUG
// Verify that the frame is actually in that child list or in the
// corresponding overflow list.
nsIFrame* parent = aChildFrame->GetParent();
PRBool found = nsFrameList(parent->GetFirstChild(listName))
.ContainsFrame(aChildFrame);
if (!found) {
if (!(aChildFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
found = nsFrameList(parent->GetFirstChild(nsGkAtoms::overflowList))
.ContainsFrame(aChildFrame);
}
else if (aChildFrame->GetStyleDisplay()->IsFloating()) {
found = nsFrameList(parent->GetFirstChild(nsGkAtoms::overflowOutOfFlowList))
.ContainsFrame(aChildFrame);
}
// else it's positioned and should have been on the 'listName' child list.
NS_POSTCONDITION(found, "not in child list");
}
#endif
return listName;
}
//----------------------------------------------------------------------
nsCSSFrameConstructor::nsCSSFrameConstructor(nsIDocument *aDocument,
nsIPresShell *aPresShell)
: mDocument(aDocument)
, mPresShell(aPresShell)
, mRootElementFrame(nsnull)
, mRootElementStyleFrame(nsnull)
, mFixedContainingBlock(nsnull)
, mDocElementContainingBlock(nsnull)
, mGfxScrollFrame(nsnull)
, mPageSequenceFrame(nsnull)
, mUpdateCount(0)
, mFocusSuppressCount(0)
, mQuotesDirty(PR_FALSE)
, mCountersDirty(PR_FALSE)
, mIsDestroyingFrameTree(PR_FALSE)
, mRebuildAllStyleData(PR_FALSE)
, mHasRootAbsPosContainingBlock(PR_FALSE)
, mHoverGeneration(0)
, mRebuildAllExtraHint(nsChangeHint(0))
{
// XXXbz this should be in Init() or something!
if (!mPendingRestyles.Init()) {
// now what?
}
#ifdef DEBUG
static PRBool gFirstTime = PR_TRUE;
if (gFirstTime) {
gFirstTime = PR_FALSE;
char* flags = PR_GetEnv("GECKO_FRAMECTOR_DEBUG_FLAGS");
if (flags) {
PRBool error = PR_FALSE;
for (;;) {
char* comma = PL_strchr(flags, ',');
if (comma)
*comma = '\0';
PRBool found = PR_FALSE;
FrameCtorDebugFlags* flag = gFlags;
FrameCtorDebugFlags* limit = gFlags + NUM_DEBUG_FLAGS;
while (flag < limit) {
if (PL_strcasecmp(flag->name, flags) == 0) {
*(flag->on) = PR_TRUE;
printf("nsCSSFrameConstructor: setting %s debug flag on\n", flag->name);
found = PR_TRUE;
break;
}
++flag;
}
if (! found)
error = PR_TRUE;
if (! comma)
break;
*comma = ',';
flags = comma + 1;
}
if (error) {
printf("Here are the available GECKO_FRAMECTOR_DEBUG_FLAGS:\n");
FrameCtorDebugFlags* flag = gFlags;
FrameCtorDebugFlags* limit = gFlags + NUM_DEBUG_FLAGS;
while (flag < limit) {
printf(" %s\n", flag->name);
++flag;
}
printf("Note: GECKO_FRAMECTOR_DEBUG_FLAGS is a comma separated list of flag\n");
printf("names (no whitespace)\n");
}
}
}
#endif
}
nsIXBLService * nsCSSFrameConstructor::GetXBLService()
{
if (!gXBLService) {
nsresult rv = CallGetService("@mozilla.org/xbl;1", &gXBLService);
if (NS_FAILED(rv))
gXBLService = nsnull;
}
return gXBLService;
}
void
nsCSSFrameConstructor::NotifyDestroyingFrame(nsIFrame* aFrame)
{
NS_PRECONDITION(mUpdateCount != 0,
"Should be in an update while destroying frames");
if (aFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT) {
if (mQuoteList.DestroyNodesFor(aFrame))
QuotesDirty();
}
if (mCounterManager.DestroyNodesFor(aFrame)) {
// Technically we don't need to update anything if we destroyed only
// USE nodes. However, this is unlikely to happen in the real world
// since USE nodes generally go along with INCREMENT nodes.
CountersDirty();
}
}
struct nsGenConInitializer {
nsAutoPtr<nsGenConNode> mNode;
nsGenConList* mList;
void (nsCSSFrameConstructor::*mDirtyAll)();
nsGenConInitializer(nsGenConNode* aNode, nsGenConList* aList,
void (nsCSSFrameConstructor::*aDirtyAll)())
: mNode(aNode), mList(aList), mDirtyAll(aDirtyAll) {}
};
static void
DestroyGenConInitializer(void* aFrame,
nsIAtom* aPropertyName,
void* aPropertyValue,
void* aDtorData)
{
delete static_cast<nsGenConInitializer*>(aPropertyValue);
}
already_AddRefed<nsIContent>
nsCSSFrameConstructor::CreateGenConTextNode(const nsString& aString,
nsCOMPtr<nsIDOMCharacterData>* aText,
nsGenConInitializer* aInitializer)
{
nsCOMPtr<nsIContent> content;
NS_NewTextNode(getter_AddRefs(content), mDocument->NodeInfoManager());
if (!content) {
// XXX The quotes/counters code doesn't like the text pointer
// being null in case of dynamic changes!
NS_ASSERTION(!aText, "this OOM case isn't handled very well");
return nsnull;
}
content->SetText(aString, PR_FALSE);
if (aText) {
*aText = do_QueryInterface(content);
}
if (aInitializer) {
content->SetProperty(nsGkAtoms::genConInitializerProperty, aInitializer,
DestroyGenConInitializer);
}
return content.forget();
}
already_AddRefed<nsIContent>
nsCSSFrameConstructor::CreateGeneratedContent(nsIContent* aParentContent,
nsStyleContext* aStyleContext,
PRUint32 aContentIndex)
{
// Get the content value
const nsStyleContentData &data =
aStyleContext->GetStyleContent()->ContentAt(aContentIndex);
nsStyleContentType type = data.mType;
if (eStyleContentType_Image == type) {
if (!data.mContent.mImage) {
// CSS had something specified that couldn't be converted to an
// image object
return nsnull;
}
// Create an image content object and pass it the image request.
// XXX Check if it's an image type we can handle...
nsCOMPtr<nsINodeInfo> nodeInfo;
nodeInfo = mDocument->NodeInfoManager()->GetNodeInfo(nsGkAtoms::mozgeneratedcontentimage, nsnull,
kNameSpaceID_XHTML);
nsCOMPtr<nsIContent> content;
NS_NewGenConImageContent(getter_AddRefs(content), nodeInfo,
data.mContent.mImage);
return content.forget();
}
switch (type) {
case eStyleContentType_String:
return CreateGenConTextNode(nsDependentString(data.mContent.mString), nsnull,
nsnull);
case eStyleContentType_Attr:
{
nsCOMPtr<nsIAtom> attrName;
PRInt32 attrNameSpace = kNameSpaceID_None;
nsAutoString contentString(data.mContent.mString);
PRInt32 barIndex = contentString.FindChar('|'); // CSS namespace delimiter
if (-1 != barIndex) {
nsAutoString nameSpaceVal;
contentString.Left(nameSpaceVal, barIndex);
PRInt32 error;
attrNameSpace = nameSpaceVal.ToInteger(&error, 10);
contentString.Cut(0, barIndex + 1);
if (contentString.Length()) {
attrName = do_GetAtom(contentString);
}
}
else {
attrName = do_GetAtom(contentString);
}
if (!attrName) {
return nsnull;
}
nsCOMPtr<nsIContent> content;
NS_NewAttributeContent(mDocument->NodeInfoManager(),
attrNameSpace, attrName, getter_AddRefs(content));
return content.forget();
}
case eStyleContentType_Counter:
case eStyleContentType_Counters:
{
nsCSSValue::Array* counters = data.mContent.mCounters;
nsCounterList* counterList = mCounterManager.CounterListFor(
nsDependentString(counters->Item(0).GetStringBufferValue()));
if (!counterList)
return nsnull;
nsCounterUseNode* node =
new nsCounterUseNode(counters, aContentIndex,
type == eStyleContentType_Counters);
if (!node)
return nsnull;
nsGenConInitializer* initializer =
new nsGenConInitializer(node, counterList,
&nsCSSFrameConstructor::CountersDirty);
return CreateGenConTextNode(EmptyString(), &node->mText, initializer);
}
case eStyleContentType_Image:
NS_NOTREACHED("handled by if above");
return nsnull;
case eStyleContentType_OpenQuote:
case eStyleContentType_CloseQuote:
case eStyleContentType_NoOpenQuote:
case eStyleContentType_NoCloseQuote:
{
nsQuoteNode* node =
new nsQuoteNode(type, aContentIndex);
if (!node)
return nsnull;
nsGenConInitializer* initializer =
new nsGenConInitializer(node, &mQuoteList,
&nsCSSFrameConstructor::QuotesDirty);
return CreateGenConTextNode(EmptyString(), &node->mText, initializer);
}
case eStyleContentType_AltContent:
{
// Use the "alt" attribute; if that fails and the node is an HTML
// <input>, try the value attribute and then fall back to some default
// localized text we have.
// XXX what if the 'alt' attribute is added later, how will we
// detect that and do the right thing here?
if (aParentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::alt)) {
nsCOMPtr<nsIContent> content;
NS_NewAttributeContent(mDocument->NodeInfoManager(),
kNameSpaceID_None, nsGkAtoms::alt, getter_AddRefs(content));
return content.forget();
}
if (aParentContent->IsNodeOfType(nsINode::eHTML) &&
aParentContent->NodeInfo()->Equals(nsGkAtoms::input)) {
if (aParentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::value)) {
nsCOMPtr<nsIContent> content;
NS_NewAttributeContent(mDocument->NodeInfoManager(),
kNameSpaceID_None, nsGkAtoms::value, getter_AddRefs(content));
return content.forget();
}
nsXPIDLString temp;
nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES,
"Submit", temp);
return CreateGenConTextNode(temp, nsnull, nsnull);
}
break;
}
} // switch
return nsnull;
}
/*
* aParentFrame - the frame that should be the parent of the generated
* content. This is the frame for the corresponding content node,
* which must not be a leaf frame.
*
* Any items created are added to aItems.
*
* We create an XML element (tag _moz_generated_content_before or
* _moz_generated_content_after) representing the pseudoelement. We
* create a DOM node for each 'content' item and make those nodes the
* children of the XML element. Then we create a frame subtree for
* the XML element as if it were a regular child of
* aParentFrame/aParentContent, giving the XML element the ::before or
* ::after style.
*/
void
nsCSSFrameConstructor::CreateGeneratedContentItem(nsFrameConstructorState& aState,
nsIFrame* aParentFrame,
nsIContent* aParentContent,
nsStyleContext* aStyleContext,
nsIAtom* aPseudoElement,
FrameConstructionItemList& aItems)
{
// XXXbz is this ever true?
if (!aParentContent->IsNodeOfType(nsINode::eELEMENT))
return;
nsStyleSet *styleSet = mPresShell->StyleSet();
// Probe for the existence of the pseudo-element
nsRefPtr<nsStyleContext> pseudoStyleContext;
pseudoStyleContext = styleSet->ProbePseudoStyleFor(aParentContent,
aPseudoElement,
aStyleContext);
if (!pseudoStyleContext)
return;
// |ProbePseudoStyleFor| checked the 'display' property and the
// |ContentCount()| of the 'content' property for us.
nsCOMPtr<nsINodeInfo> nodeInfo;
nsIAtom* elemName = aPseudoElement == nsCSSPseudoElements::before ?
nsGkAtoms::mozgeneratedcontentbefore : nsGkAtoms::mozgeneratedcontentafter;
nodeInfo = mDocument->NodeInfoManager()->GetNodeInfo(elemName, nsnull,
kNameSpaceID_None);
nsCOMPtr<nsIContent> container;
nsresult rv = NS_NewXMLElement(getter_AddRefs(container), nodeInfo);
if (NS_FAILED(rv))
return;
container->SetNativeAnonymous();
rv = container->BindToTree(mDocument, aParentContent, aParentContent, PR_TRUE);
if (NS_FAILED(rv)) {
container->UnbindFromTree();
return;
}
PRUint32 contentCount = pseudoStyleContext->GetStyleContent()->ContentCount();
for (PRUint32 contentIndex = 0; contentIndex < contentCount; contentIndex++) {
nsCOMPtr<nsIContent> content =
CreateGeneratedContent(aParentContent, pseudoStyleContext, contentIndex);
if (content) {
container->AppendChildTo(content, PR_FALSE);
}
}
AddFrameConstructionItemsInternal(aState, container, aParentFrame, elemName,
kNameSpaceID_None, pseudoStyleContext,
ITEM_IS_GENERATED_CONTENT, aItems);
}
static PRBool
TextIsOnlyWhitespace(nsIContent* aContent)
{
return aContent->IsNodeOfType(nsINode::eTEXT) &&
aContent->TextIsOnlyWhitespace();
}
/****************************************************
** BEGIN TABLE SECTION
****************************************************/
// The term pseudo frame is being used instead of anonymous frame, since anonymous
// frame has been used elsewhere to refer to frames that have generated content
// aIncludeSpecial applies to captions, col groups, cols and cells.
// These do not generate pseudo frame wrappers for foreign children.
// In fact, colgroups never have any children that are not cols and
// cols never have any children at all.
static PRBool
IsTableRelated(nsIAtom* aParentType,
PRBool aIncludeSpecial)
{
if ((nsGkAtoms::tableFrame == aParentType) ||
(nsGkAtoms::tableRowGroupFrame == aParentType) ||
(nsGkAtoms::tableRowFrame == aParentType)) {
return PR_TRUE;
}
else if (aIncludeSpecial &&
((nsGkAtoms::tableCaptionFrame == aParentType) ||
(nsGkAtoms::tableColGroupFrame == aParentType) ||
(nsGkAtoms::tableColFrame == aParentType) ||
IS_TABLE_CELL(aParentType))) {
return PR_TRUE;
}
else return PR_FALSE;
}
static nsIFrame*
AdjustCaptionParentFrame(nsIFrame* aParentFrame)
{
if (nsGkAtoms::tableFrame == aParentFrame->GetType()) {
return aParentFrame->GetParent();;
}
return aParentFrame;
}
/**
* If the parent frame is a |tableFrame| and the child is a
* |captionFrame|, then we want to insert the frames beneath the
* |tableFrame|'s parent frame. Returns |PR_TRUE| if the parent frame
* needed to be fixed up.
*/
static PRBool
GetCaptionAdjustedParent(nsIFrame* aParentFrame,
const nsIFrame* aChildFrame,
nsIFrame** aAdjParentFrame)
{
*aAdjParentFrame = aParentFrame;
PRBool haveCaption = PR_FALSE;
if (nsGkAtoms::tableCaptionFrame == aChildFrame->GetType()) {
haveCaption = PR_TRUE;
*aAdjParentFrame = AdjustCaptionParentFrame(aParentFrame);
}
return haveCaption;
}
static nsresult
ProcessPseudoFrame(nsPseudoFrameData& aPseudoData,
nsIFrame*& aParent)
{
nsresult rv = NS_OK;
aParent = aPseudoData.mFrame;
nsFrameItems* items = &aPseudoData.mChildList;
if (items && items->childList) {
rv = aParent->SetInitialChildList(nsnull, items->childList);
if (NS_FAILED(rv)) return rv;
}
aPseudoData.Reset();
return rv;
}
static nsresult
ProcessPseudoRowGroupFrame(nsPseudoFrameData& aPseudoData,
nsIFrame*& aParent)
{
nsresult rv = NS_OK;
aParent = aPseudoData.mFrame;
nsFrameItems* items = &aPseudoData.mChildList;
if (items && items->childList) {
nsTableRowGroupFrame* rgFrame = nsTableFrame::GetRowGroupFrame(aParent);
rv = rgFrame->SetInitialChildList(nsnull, items->childList);
if (NS_FAILED(rv)) return rv;
}
aPseudoData.Reset();
return rv;
}
static nsresult
ProcessPseudoTableFrame(nsPseudoFrames& aPseudoFrames,
nsIFrame*& aParent)
{
nsresult rv = NS_OK;
// process the col group frame, if it exists
if (aPseudoFrames.mColGroup.mFrame) {
rv = ProcessPseudoFrame(aPseudoFrames.mColGroup, aParent);
}
// process the inner table frame
rv = ProcessPseudoFrame(aPseudoFrames.mTableInner, aParent);
// process the outer table frame
aParent = aPseudoFrames.mTableOuter.mFrame;
nsFrameItems* items = &aPseudoFrames.mTableOuter.mChildList;
if (items && items->childList) {
rv = aParent->SetInitialChildList(nsnull, items->childList);
if (NS_FAILED(rv)) return rv;
}
nsFrameItems* captions = &aPseudoFrames.mTableOuter.mChildList2;
if (captions && captions->childList) {
rv = aParent->SetInitialChildList(nsGkAtoms::captionList, captions->childList);
}
aPseudoFrames.mTableOuter.Reset();
return rv;
}
static nsresult
ProcessPseudoCellFrame(nsPseudoFrames& aPseudoFrames,
nsIFrame*& aParent)
{
nsresult rv = NS_OK;
rv = ProcessPseudoFrame(aPseudoFrames.mCellInner, aParent);
if (NS_FAILED(rv)) return rv;
rv = ProcessPseudoFrame(aPseudoFrames.mCellOuter, aParent);
return rv;
}
// limit the processing up to the frame type indicated by aHighestType.
// make a complete processing when aHighestType is null
static nsresult
ProcessPseudoFrames(nsFrameConstructorState& aState,
nsIAtom* aHighestType,
nsIFrame*& aHighestFrame)
{
nsresult rv = NS_OK;
aHighestFrame = nsnull;
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** ProcessPseudoFrames enter***\n");
aState.mPseudoFrames.Dump();
}
#endif
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
if (nsGkAtoms::tableFrame == pseudoFrames.mLowestType) {
if (pseudoFrames.mColGroup.mFrame) {
rv = ProcessPseudoFrame(pseudoFrames.mColGroup, aHighestFrame);
if (nsGkAtoms::tableColGroupFrame == aHighestType) return rv;
}
rv = ProcessPseudoTableFrame(pseudoFrames, aHighestFrame);
if (nsGkAtoms::tableOuterFrame == aHighestType) return rv;
if (pseudoFrames.mCellOuter.mFrame) {
rv = ProcessPseudoCellFrame(pseudoFrames, aHighestFrame);
if (IS_TABLE_CELL(aHighestType)) return rv;
}
if (pseudoFrames.mRow.mFrame) {
rv = ProcessPseudoFrame(pseudoFrames.mRow, aHighestFrame);
if (nsGkAtoms::tableRowFrame == aHighestType) return rv;
}
if (pseudoFrames.mRowGroup.mFrame) {
rv = ProcessPseudoRowGroupFrame(pseudoFrames.mRowGroup, aHighestFrame);
if (nsGkAtoms::tableRowGroupFrame == aHighestType) return rv;
}
}
else if (nsGkAtoms::tableRowGroupFrame == pseudoFrames.mLowestType) {
rv = ProcessPseudoRowGroupFrame(pseudoFrames.mRowGroup, aHighestFrame);
if (nsGkAtoms::tableRowGroupFrame == aHighestType) return rv;
if (pseudoFrames.mColGroup.mFrame) {
nsIFrame* colGroupHigh;
rv = ProcessPseudoFrame(pseudoFrames.mColGroup, colGroupHigh);
if (aHighestFrame &&
nsGkAtoms::tableRowGroupFrame == aHighestFrame->GetType() &&
!pseudoFrames.mTableInner.mFrame) {
// table frames are special they can have two types of pseudo frames as
// children that need to be processed in one pass, we only need to link
// them if the parent is not a pseudo where the link is already done
// We sort this later out inside nsTableFrame.
colGroupHigh->SetNextSibling(aHighestFrame);
}
aHighestFrame = colGroupHigh;
if (nsGkAtoms::tableColGroupFrame == aHighestType) return rv;
}
if (pseudoFrames.mTableOuter.mFrame) {
rv = ProcessPseudoTableFrame(pseudoFrames, aHighestFrame);
if (nsGkAtoms::tableOuterFrame == aHighestType) return rv;
}
if (pseudoFrames.mCellOuter.mFrame) {
rv = ProcessPseudoCellFrame(pseudoFrames, aHighestFrame);
if (IS_TABLE_CELL(aHighestType)) return rv;
}
if (pseudoFrames.mRow.mFrame) {
rv = ProcessPseudoFrame(pseudoFrames.mRow, aHighestFrame);
if (nsGkAtoms::tableRowFrame == aHighestType) return rv;
}
}
else if (nsGkAtoms::tableRowFrame == pseudoFrames.mLowestType) {
rv = ProcessPseudoFrame(pseudoFrames.mRow, aHighestFrame);
if (nsGkAtoms::tableRowFrame == aHighestType) return rv;
if (pseudoFrames.mRowGroup.mFrame) {
rv = ProcessPseudoRowGroupFrame(pseudoFrames.mRowGroup, aHighestFrame);
if (nsGkAtoms::tableRowGroupFrame == aHighestType) return rv;
}
if (pseudoFrames.mColGroup.mFrame) {
nsIFrame* colGroupHigh;
rv = ProcessPseudoFrame(pseudoFrames.mColGroup, colGroupHigh);
if (aHighestFrame &&
nsGkAtoms::tableRowGroupFrame == aHighestFrame->GetType() &&
!pseudoFrames.mTableInner.mFrame) {
// table frames are special they can have two types of pseudo frames as
// children that need to be processed in one pass, we only need to link
// them if the parent is not a pseudo where the link is already done
// We sort this later out inside nsTableFrame.
colGroupHigh->SetNextSibling(aHighestFrame);
}
aHighestFrame = colGroupHigh;
if (nsGkAtoms::tableColGroupFrame == aHighestType) return rv;
}
if (pseudoFrames.mTableOuter.mFrame) {
rv = ProcessPseudoTableFrame(pseudoFrames, aHighestFrame);
if (nsGkAtoms::tableOuterFrame == aHighestType) return rv;
}
if (pseudoFrames.mCellOuter.mFrame) {
rv = ProcessPseudoCellFrame(pseudoFrames, aHighestFrame);
if (IS_TABLE_CELL(aHighestType)) return rv;
}
}
else if (IS_TABLE_CELL(pseudoFrames.mLowestType)) {
rv = ProcessPseudoCellFrame(pseudoFrames, aHighestFrame);
if (IS_TABLE_CELL(aHighestType)) return rv;
if (pseudoFrames.mRow.mFrame) {
rv = ProcessPseudoFrame(pseudoFrames.mRow, aHighestFrame);
if (nsGkAtoms::tableRowFrame == aHighestType) return rv;
}
if (pseudoFrames.mRowGroup.mFrame) {
rv = ProcessPseudoRowGroupFrame(pseudoFrames.mRowGroup, aHighestFrame);
if (nsGkAtoms::tableRowGroupFrame == aHighestType) return rv;
}
if (pseudoFrames.mColGroup.mFrame) {
nsIFrame* colGroupHigh;
rv = ProcessPseudoFrame(pseudoFrames.mColGroup, colGroupHigh);
if (aHighestFrame &&
nsGkAtoms::tableRowGroupFrame == aHighestFrame->GetType() &&
!pseudoFrames.mTableInner.mFrame) {
// table frames are special they can have two types of pseudo frames as
// children that need to be processed in one pass, we only need to link
// them if the parent is not a pseudo where the link is already done
// We sort this later out inside nsTableFrame.
colGroupHigh->SetNextSibling(aHighestFrame);
}
aHighestFrame = colGroupHigh;
if (nsGkAtoms::tableColGroupFrame == aHighestType) return rv;
}
if (pseudoFrames.mTableOuter.mFrame) {
rv = ProcessPseudoTableFrame(pseudoFrames, aHighestFrame);
}
}
else if (pseudoFrames.mColGroup.mFrame) {
// process the col group frame
rv = ProcessPseudoFrame(pseudoFrames.mColGroup, aHighestFrame);
}
return rv;
}
static nsresult
ProcessPseudoFrames(nsFrameConstructorState& aState,
nsFrameItems& aItems)
{
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** ProcessPseudoFrames complete enter***\n");
aState.mPseudoFrames.Dump();
}
#endif
nsIFrame* highestFrame;
nsresult rv = ProcessPseudoFrames(aState, nsnull, highestFrame);
if (highestFrame) {
aItems.AddChild(highestFrame);
}
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** ProcessPseudoFrames complete leave, highestframe:%p***\n",
static_cast<void*>(highestFrame));
aState.mPseudoFrames.Dump();
}
#endif
aState.mPseudoFrames.Reset();
return rv;
}
static nsresult
ProcessPseudoFrames(nsFrameConstructorState& aState,
nsIAtom* aHighestType)
{
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** ProcessPseudoFrames limited enter highest:");
if (nsGkAtoms::tableOuterFrame == aHighestType)
printf("OuterTable");
else if (nsGkAtoms::tableFrame == aHighestType)
printf("InnerTable");
else if (nsGkAtoms::tableColGroupFrame == aHighestType)
printf("ColGroup");
else if (nsGkAtoms::tableRowGroupFrame == aHighestType)
printf("RowGroup");
else if (nsGkAtoms::tableRowFrame == aHighestType)
printf("Row");
else if (IS_TABLE_CELL(aHighestType))
printf("Cell");
else
NS_ASSERTION(PR_FALSE, "invalid call to ProcessPseudoFrames ");
printf("***\n");
aState.mPseudoFrames.Dump();
}
#endif
nsIFrame* highestFrame;
nsresult rv = ProcessPseudoFrames(aState, aHighestType, highestFrame);
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** ProcessPseudoFrames limited leave:%p***\n",
static_cast<void*>(highestFrame));
aState.mPseudoFrames.Dump();
}
#endif
return rv;
}
nsresult
nsCSSFrameConstructor::CreatePseudoTableFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame* aParentFrameIn)
{
nsresult rv = NS_OK;
nsIFrame* parentFrame = (aState.mPseudoFrames.mCellInner.mFrame)
? aState.mPseudoFrames.mCellInner.mFrame : aParentFrameIn;
if (!parentFrame) return rv;
nsStyleContext *parentStyle;
nsRefPtr<nsStyleContext> childStyle;
parentStyle = parentFrame->GetStyleContext();
nsIContent* parentContent = parentFrame->GetContent();
// Thankfully, the parent can't change display type without causing
// frame reconstruction, so this won't need to change.
nsIAtom *pseudoType;
if (parentStyle->GetStyleDisplay()->mDisplay == NS_STYLE_DISPLAY_INLINE)
pseudoType = nsCSSAnonBoxes::inlineTable;
else
pseudoType = nsCSSAnonBoxes::table;
// create the SC for the inner table which will be the parent of the outer table's SC
childStyle = mPresShell->StyleSet()->ResolvePseudoStyleFor(parentContent,
pseudoType,
parentStyle);
nsPseudoFrameData& pseudoOuter = aState.mPseudoFrames.mTableOuter;
nsPseudoFrameData& pseudoInner = aState.mPseudoFrames.mTableInner;
// construct the pseudo outer and inner as part of the pseudo frames
nsFrameItems items;
rv = ConstructTableFrame(aState, parentContent,
parentFrame, childStyle, aNameSpaceID,
PR_TRUE, items, pseudoOuter.mFrame,
pseudoInner.mFrame);
if (NS_FAILED(rv)) return rv;
// set pseudo data for the newly created frames
pseudoOuter.mChildList.AddChild(pseudoInner.mFrame);
aState.mPseudoFrames.mLowestType = nsGkAtoms::tableFrame;
// set pseudo data for the parent
if (aState.mPseudoFrames.mCellInner.mFrame) {
aState.mPseudoFrames.mCellInner.mChildList.AddChild(pseudoOuter.mFrame);
}
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** CreatePseudoTableFrame ***\n");
aState.mPseudoFrames.Dump();
}
#endif
return rv;
}
nsresult
nsCSSFrameConstructor::CreatePseudoRowGroupFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame* aParentFrameIn)
{
nsresult rv = NS_OK;
nsIFrame* parentFrame = (aState.mPseudoFrames.mTableInner.mFrame)
? aState.mPseudoFrames.mTableInner.mFrame : aParentFrameIn;
if (!parentFrame) return rv;
nsStyleContext *parentStyle;
nsRefPtr<nsStyleContext> childStyle;
parentStyle = parentFrame->GetStyleContext();
nsIContent* parentContent = parentFrame->GetContent();
childStyle = mPresShell->StyleSet()->ResolvePseudoStyleFor(parentContent,
nsCSSAnonBoxes::tableRowGroup,
parentStyle);
nsPseudoFrameData& pseudo = aState.mPseudoFrames.mRowGroup;
// construct the pseudo row group as part of the pseudo frames
PRBool pseudoParent;
nsFrameItems items;
rv = ConstructTableRowGroupFrame(aState, parentContent,
parentFrame, childStyle, aNameSpaceID,
PR_TRUE, items, pseudo.mFrame, &pseudoParent);
if (NS_FAILED(rv)) return rv;
// set pseudo data for the newly created frames
aState.mPseudoFrames.mLowestType = nsGkAtoms::tableRowGroupFrame;
// set pseudo data for the parent
if (aState.mPseudoFrames.mTableInner.mFrame) {
aState.mPseudoFrames.mTableInner.mChildList.AddChild(pseudo.mFrame);
}
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** CreatePseudoRowGroupFrame ***\n");
aState.mPseudoFrames.Dump();
}
#endif
return rv;
}
nsresult
nsCSSFrameConstructor::CreatePseudoColGroupFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame* aParentFrameIn)
{
nsresult rv = NS_OK;
nsIFrame* parentFrame = (aState.mPseudoFrames.mTableInner.mFrame)
? aState.mPseudoFrames.mTableInner.mFrame : aParentFrameIn;
if (!parentFrame) return rv;
nsStyleContext *parentStyle;
nsRefPtr<nsStyleContext> childStyle;
parentStyle = parentFrame->GetStyleContext();
nsIContent* parentContent = parentFrame->GetContent();
childStyle = mPresShell->StyleSet()->ResolvePseudoStyleFor(parentContent,
nsCSSAnonBoxes::tableColGroup,
parentStyle);
nsPseudoFrameData& pseudo = aState.mPseudoFrames.mColGroup;
// construct the pseudo col group as part of the pseudo frames
PRBool pseudoParent;
nsFrameItems items;
rv = ConstructTableColGroupFrame(aState, parentContent,
parentFrame, childStyle, aNameSpaceID,
PR_TRUE, items, pseudo.mFrame, &pseudoParent);
if (NS_FAILED(rv)) return rv;
((nsTableColGroupFrame*)pseudo.mFrame)->SetColType(eColGroupAnonymousCol);
// Do not set aState.mPseudoFrames.mLowestType here as colgroup frame will
// be always below a table frame but we can not descent any further as col
// frames can not have children and will not wrap table foreign frames.
// set pseudo data for the parent
if (aState.mPseudoFrames.mTableInner.mFrame) {
aState.mPseudoFrames.mTableInner.mChildList.AddChild(pseudo.mFrame);
}
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** CreatePseudoColGroupFrame ***\n");
aState.mPseudoFrames.Dump();
}
#endif
return rv;
}
nsresult
nsCSSFrameConstructor::CreatePseudoRowFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame* aParentFrameIn)
{
nsresult rv = NS_OK;
nsIFrame* parentFrame = aParentFrameIn;
if (aState.mPseudoFrames.mRowGroup.mFrame) {
parentFrame = (nsIFrame*) nsTableFrame::GetRowGroupFrame(aState.mPseudoFrames.mRowGroup.mFrame);
}
if (!parentFrame) return rv;
nsStyleContext *parentStyle;
nsRefPtr<nsStyleContext> childStyle;
parentStyle = parentFrame->GetStyleContext();
nsIContent* parentContent = parentFrame->GetContent();
childStyle = mPresShell->StyleSet()->ResolvePseudoStyleFor(parentContent,
nsCSSAnonBoxes::tableRow,
parentStyle);
nsPseudoFrameData& pseudo = aState.mPseudoFrames.mRow;
// construct the pseudo row as part of the pseudo frames
PRBool pseudoParent;
nsFrameItems items;
rv = ConstructTableRowFrame(aState, parentContent,
parentFrame, childStyle, aNameSpaceID,
PR_TRUE, items, pseudo.mFrame, &pseudoParent);
if (NS_FAILED(rv)) return rv;
aState.mPseudoFrames.mLowestType = nsGkAtoms::tableRowFrame;
// set pseudo data for the parent
if (aState.mPseudoFrames.mRowGroup.mFrame) {
aState.mPseudoFrames.mRowGroup.mChildList.AddChild(pseudo.mFrame);
}
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** CreatePseudoRowFrame ***\n");
aState.mPseudoFrames.Dump();
}
#endif
return rv;
}
nsresult
nsCSSFrameConstructor::CreatePseudoCellFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame* aParentFrameIn)
{
nsresult rv = NS_OK;
nsIFrame* parentFrame = (aState.mPseudoFrames.mRow.mFrame)
? aState.mPseudoFrames.mRow.mFrame : aParentFrameIn;
if (!parentFrame) return rv;
nsStyleContext *parentStyle;
nsRefPtr<nsStyleContext> childStyle;
parentStyle = parentFrame->GetStyleContext();
nsIContent* parentContent = parentFrame->GetContent();
childStyle = mPresShell->StyleSet()->ResolvePseudoStyleFor(parentContent,
nsCSSAnonBoxes::tableCell,
parentStyle);
nsPseudoFrameData& pseudoOuter = aState.mPseudoFrames.mCellOuter;
nsPseudoFrameData& pseudoInner = aState.mPseudoFrames.mCellInner;
// construct the pseudo outer and inner as part of the pseudo frames
PRBool pseudoParent;
nsFrameItems items;
rv = ConstructTableCellFrame(aState, parentContent, parentFrame, childStyle,
aNameSpaceID, PR_TRUE, items,
pseudoOuter.mFrame, pseudoInner.mFrame,
&pseudoParent);
if (NS_FAILED(rv)) return rv;
// set pseudo data for the newly created frames
pseudoOuter.mChildList.AddChild(pseudoInner.mFrame);
// give it nsGkAtoms::tableCellFrame, if it is really nsGkAtoms::bcTableCellFrame, it will match later
aState.mPseudoFrames.mLowestType = nsGkAtoms::tableCellFrame;
// set pseudo data for the parent
if (aState.mPseudoFrames.mRow.mFrame) {
aState.mPseudoFrames.mRow.mChildList.AddChild(pseudoOuter.mFrame);
}
#ifdef DEBUG
if (gTablePseudoFrame) {
printf("*** CreatePseudoCellFrame ***\n");
aState.mPseudoFrames.Dump();
}
#endif
return rv;
}
// called if the parent is not a table
nsresult
nsCSSFrameConstructor::GetPseudoTableFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame& aParentFrameIn)
{
nsresult rv = NS_OK;
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
nsIAtom* parentFrameType = aParentFrameIn.GetType();
if (pseudoFrames.IsEmpty()) {
PRBool created = PR_FALSE;
if (nsGkAtoms::tableRowGroupFrame == parentFrameType) { // row group parent
rv = CreatePseudoRowFrame(aNameSpaceID, aState, &aParentFrameIn);
if (NS_FAILED(rv)) return rv;
created = PR_TRUE;
}
if (created || (nsGkAtoms::tableRowFrame == parentFrameType)) { // row parent
rv = CreatePseudoCellFrame(aNameSpaceID, aState, &aParentFrameIn);
if (NS_FAILED(rv)) return rv;
}
rv = CreatePseudoTableFrame(aNameSpaceID, aState, &aParentFrameIn);
}
else {
if (!pseudoFrames.mTableInner.mFrame) {
if (pseudoFrames.mRowGroup.mFrame && !(pseudoFrames.mRow.mFrame)) {
rv = CreatePseudoRowFrame(aNameSpaceID, aState);
if (NS_FAILED(rv)) return rv;
}
if (pseudoFrames.mRow.mFrame && !(pseudoFrames.mCellOuter.mFrame)) {
rv = CreatePseudoCellFrame(aNameSpaceID, aState);
if (NS_FAILED(rv)) return rv;
}
CreatePseudoTableFrame(aNameSpaceID, aState);
}
}
return rv;
}
// called if the parent is not a col group
nsresult
nsCSSFrameConstructor::GetPseudoColGroupFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame& aParentFrameIn)
{
nsresult rv = NS_OK;
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
nsIAtom* parentFrameType = aParentFrameIn.GetType();
if (pseudoFrames.IsEmpty()) {
PRBool created = PR_FALSE;
if (nsGkAtoms::tableRowGroupFrame == parentFrameType) { // row group parent
rv = CreatePseudoRowFrame(aNameSpaceID, aState, &aParentFrameIn);
created = PR_TRUE;
}
if (created || (nsGkAtoms::tableRowFrame == parentFrameType)) { // row parent
rv = CreatePseudoCellFrame(aNameSpaceID, aState, &aParentFrameIn);
created = PR_TRUE;
}
if (created || IS_TABLE_CELL(parentFrameType) || // cell parent
(nsGkAtoms::tableCaptionFrame == parentFrameType) || // caption parent
!IsTableRelated(parentFrameType, PR_TRUE)) { // block parent
rv = CreatePseudoTableFrame(aNameSpaceID, aState, &aParentFrameIn);
}
rv = CreatePseudoColGroupFrame(aNameSpaceID, aState, &aParentFrameIn);
}
else {
if (!pseudoFrames.mColGroup.mFrame) {
if (!pseudoFrames.mTableInner.mFrame) {
if (pseudoFrames.mRowGroup.mFrame && !(pseudoFrames.mRow.mFrame)) {
rv = CreatePseudoRowFrame(aNameSpaceID, aState);
}
if (pseudoFrames.mRow.mFrame && !(pseudoFrames.mCellOuter.mFrame)) {
rv = CreatePseudoCellFrame(aNameSpaceID, aState);
}
if (pseudoFrames.mCellOuter.mFrame && !(pseudoFrames.mTableOuter.mFrame)) {
rv = CreatePseudoTableFrame(aNameSpaceID, aState);
}
}
rv = CreatePseudoColGroupFrame(aNameSpaceID, aState);
}
}
return rv;
}
// called if the parent is not a row group
nsresult
nsCSSFrameConstructor::GetPseudoRowGroupFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame& aParentFrameIn)
{
nsresult rv = NS_OK;
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
nsIAtom* parentFrameType = aParentFrameIn.GetType();
if (!pseudoFrames.mLowestType) {
PRBool created = PR_FALSE;
if (nsGkAtoms::tableRowFrame == parentFrameType) { // row parent
rv = CreatePseudoCellFrame(aNameSpaceID, aState, &aParentFrameIn);
created = PR_TRUE;
}
if (created || IS_TABLE_CELL(parentFrameType) || // cell parent
(nsGkAtoms::tableCaptionFrame == parentFrameType) || // caption parent
!IsTableRelated(parentFrameType, PR_TRUE)) { // block parent
rv = CreatePseudoTableFrame(aNameSpaceID, aState, &aParentFrameIn);
}
rv = CreatePseudoRowGroupFrame(aNameSpaceID, aState, &aParentFrameIn);
}
else {
if (!pseudoFrames.mRowGroup.mFrame) {
if (pseudoFrames.mRow.mFrame && !(pseudoFrames.mCellOuter.mFrame)) {
rv = CreatePseudoCellFrame(aNameSpaceID, aState);
}
if (pseudoFrames.mCellOuter.mFrame && !(pseudoFrames.mTableOuter.mFrame)) {
rv = CreatePseudoTableFrame(aNameSpaceID, aState);
}
rv = CreatePseudoRowGroupFrame(aNameSpaceID, aState);
}
}
return rv;
}
// called if the parent is not a row
nsresult
nsCSSFrameConstructor::GetPseudoRowFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame& aParentFrameIn)
{
nsresult rv = NS_OK;
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
nsIAtom* parentFrameType = aParentFrameIn.GetType();
if (!pseudoFrames.mLowestType) {
PRBool created = PR_FALSE;
if (IS_TABLE_CELL(parentFrameType) || // cell parent
(nsGkAtoms::tableCaptionFrame == parentFrameType) || // caption parent
!IsTableRelated(parentFrameType, PR_TRUE)) { // block parent
rv = CreatePseudoTableFrame(aNameSpaceID, aState, &aParentFrameIn);
created = PR_TRUE;
}
if (created || (nsGkAtoms::tableFrame == parentFrameType)) { // table parent
rv = CreatePseudoRowGroupFrame(aNameSpaceID, aState, &aParentFrameIn);
}
rv = CreatePseudoRowFrame(aNameSpaceID, aState, &aParentFrameIn);
}
else {
if (!pseudoFrames.mRow.mFrame) {
if (pseudoFrames.mCellOuter.mFrame && !pseudoFrames.mTableOuter.mFrame) {
rv = CreatePseudoTableFrame(aNameSpaceID, aState);
}
if (pseudoFrames.mTableInner.mFrame && !(pseudoFrames.mRowGroup.mFrame)) {
rv = CreatePseudoRowGroupFrame(aNameSpaceID, aState);
}
rv = CreatePseudoRowFrame(aNameSpaceID, aState);
}
}
return rv;
}
// called if the parent is not a cell or block
nsresult
nsCSSFrameConstructor::GetPseudoCellFrame(PRInt32 aNameSpaceID,
nsFrameConstructorState& aState,
nsIFrame& aParentFrameIn)
{
nsresult rv = NS_OK;
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
nsIAtom* parentFrameType = aParentFrameIn.GetType();
if (!pseudoFrames.mLowestType) {
PRBool created = PR_FALSE;
if (nsGkAtoms::tableFrame == parentFrameType) { // table parent
rv = CreatePseudoRowGroupFrame(aNameSpaceID, aState, &aParentFrameIn);
created = PR_TRUE;
}
if (created || (nsGkAtoms::tableRowGroupFrame == parentFrameType)) { // row group parent
rv = CreatePseudoRowFrame(aNameSpaceID, aState, &aParentFrameIn);
created = PR_TRUE;
}
rv = CreatePseudoCellFrame(aNameSpaceID, aState, &aParentFrameIn);
}
else if (!pseudoFrames.mCellOuter.mFrame) {
if (pseudoFrames.mTableInner.mFrame && !(pseudoFrames.mRowGroup.mFrame)) {
rv = CreatePseudoRowGroupFrame(aNameSpaceID, aState);
}
if (pseudoFrames.mRowGroup.mFrame && !(pseudoFrames.mRow.mFrame)) {
rv = CreatePseudoRowFrame(aNameSpaceID, aState);
}
rv = CreatePseudoCellFrame(aNameSpaceID, aState);
}
return rv;
}
nsresult
nsCSSFrameConstructor::CreateRequiredPseudoFrames(PRInt32 aNameSpaceID,
nsIFrame& aParentFrameIn,
nsIAtom* aChildFrameType,
nsFrameConstructorState& aState,
nsIFrame*& aParentFrame,
PRBool& aIsPseudoParent)
{
nsresult rv = NS_OK;
nsIAtom* parentFrameType = aParentFrameIn.GetType();
nsIFrame* pseudoParentFrame = nsnull;
nsPseudoFrames& pseudoFrames = aState.mPseudoFrames;
aParentFrame = &aParentFrameIn;
aIsPseudoParent = PR_FALSE;
nsFrameState savedStateBits = aState.mAdditionalStateBits;
aState.mAdditionalStateBits &= ~NS_FRAME_GENERATED_CONTENT;
if (nsGkAtoms::tableCaptionFrame == aChildFrameType) { // caption child
if (nsGkAtoms::tableOuterFrame != parentFrameType) { // need pseudo table parent
rv = GetPseudoTableFrame(aNameSpaceID, aState, aParentFrameIn);
if (NS_FAILED(rv)) return rv;
pseudoParentFrame = pseudoFrames.mTableOuter.mFrame;
}
}
else if (nsGkAtoms::tableColGroupFrame == aChildFrameType) { // col group child
if (nsGkAtoms::tableFrame != parentFrameType) { // need pseudo table parent
rv = GetPseudoTableFrame(aNameSpaceID, aState, aParentFrameIn);
if (NS_FAILED(rv)) return rv;
pseudoParentFrame = pseudoFrames.mTableInner.mFrame;
}
}
else if (nsGkAtoms::tableColFrame == aChildFrameType) { // col child
if (nsGkAtoms::tableColGroupFrame != parentFrameType) { // need pseudo col group parent
rv = GetPseudoColGroupFrame(aNameSpaceID, aState, aParentFrameIn);
if (NS_FAILED(rv)) return rv;
pseudoParentFrame = pseudoFrames.mColGroup.mFrame;
}
}
else if (nsGkAtoms::tableRowGroupFrame == aChildFrameType) { // row group child
// XXX can this go away?
if (nsGkAtoms::tableFrame != parentFrameType) {
// trees allow row groups to contain row groups, so don't create pseudo frames
rv = GetPseudoTableFrame(aNameSpaceID, aState, aParentFrameIn);
if (NS_FAILED(rv)) return rv;
pseudoParentFrame = pseudoFrames.mTableInner.mFrame;
}
}
else if (nsGkAtoms::tableRowFrame == aChildFrameType) { // row child
if (nsGkAtoms::tableRowGroupFrame != parentFrameType) { // need pseudo row group parent
rv = GetPseudoRowGroupFrame(aNameSpaceID, aState, aParentFrameIn);
if (NS_FAILED(rv)) return rv;
pseudoParentFrame = pseudoFrames.mRowGroup.mFrame;
}
}
else if (IS_TABLE_CELL(aChildFrameType)) { // cell child
if (nsGkAtoms::tableRowFrame != parentFrameType) { // need pseudo row parent
rv = GetPseudoRowFrame(aNameSpaceID, aState, aParentFrameIn);
if (NS_FAILED(rv)) return rv;
pseudoParentFrame = pseudoFrames.mRow.mFrame;
}
}
#ifdef DEBUG
else {
NS_ERROR("Unexpected frame type in CreateRequiredPseudoFrames");
}
#endif
if (pseudoParentFrame) {
aParentFrame = pseudoParentFrame;
aIsPseudoParent = PR_TRUE;
}
aState.mAdditionalStateBits = savedStateBits;
return rv;
}
nsresult
nsCSSFrameConstructor::AdjustParentFrame(nsFrameConstructorState& aState,
nsIContent* aChildContent,
nsIFrame* & aParentFrame,
const FrameConstructionData* aFCData,
PRInt32 aNameSpaceID,
nsStyleContext* aStyleContext,
nsFrameItems* & aFrameItems,
nsFrameConstructorSaveState& aSaveState,
PRBool& aCreatedPseudo)
{
NS_PRECONDITION(aStyleContext, "Must have child's style context");
NS_PRECONDITION(aFrameItems, "Must have frame items to work with");
NS_PRECONDITION(aFCData, "Must have frame construction data");
aCreatedPseudo = PR_FALSE;
if (!aParentFrame) {
// Nothing to do here
return NS_OK;
}
PRBool tablePart = ((aFCData->mBits & FCDATA_IS_TABLE_PART) != 0);
nsIAtom* parentType = aParentFrame->GetType();
NS_ASSERTION(parentType != nsGkAtoms::tableOuterFrame,
"Shouldn't be happening");
// If our parent is a table, table-row-group, or table-row, and
// we're not table-related in any way, we have to create table
// pseudo-frames so that we have a table cell to live in.
if (IsTableRelated(parentType, PR_FALSE) && !tablePart) {
nsFrameState savedStateBits = aState.mAdditionalStateBits;
aState.mAdditionalStateBits &= ~NS_FRAME_GENERATED_CONTENT;
nsresult rv = GetPseudoCellFrame(aNameSpaceID, aState, *aParentFrame);
if (NS_FAILED(rv)) {
return rv;
}
aState.mAdditionalStateBits = savedStateBits;
NS_ASSERTION(aState.mPseudoFrames.mCellInner.mFrame,
"Must have inner cell frame now!");
aParentFrame = aState.mPseudoFrames.mCellInner.mFrame;
aFrameItems = &aState.mPseudoFrames.mCellInner.mChildList;
// We pushed an anonymous table cell. The inner block of this
// needs to become the float containing block.
aState.PushFloatContainingBlock(aParentFrame, aSaveState);
aCreatedPseudo = PR_TRUE;
// Now it might be that we had existing pseudo-frames and in particular an
// existing pseudo-cell (so that the pseudo cell we just got is not the
// lowest pseudo-frame). If that's the case, we need to process everythign
// below that cell, so that our later siblings don't see those
// pseudo-frames.
if (aState.mPseudoFrames.mTableOuter.mFrame) {
ProcessPseudoFrames(aState, nsGkAtoms::tableOuterFrame);
}
}
return NS_OK;
}
// Pull all the captions present in aItems out into aCaptions
static void
PullOutCaptionFrames(nsFrameItems& aItems, nsFrameItems& aCaptions)
{
nsIFrame *child = aItems.childList;
nsIFrame* prev = nsnull;
while (child) {
nsIFrame *nextSibling = child->GetNextSibling();
if (nsGkAtoms::tableCaptionFrame == child->GetType()) {
aItems.RemoveChild(child, prev);
aCaptions.AddChild(child);
} else {
prev = child;
}
child = nextSibling;
}
}
// Construct the outer, inner table frames and the children frames for the table.
// XXX Page break frames for pseudo table frames are not constructed to avoid the risk
// associated with revising the pseudo frame mechanism. The long term solution
// of having frames handle page-break-before/after will solve the problem.
nsresult
nsCSSFrameConstructor::ConstructTableFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aContentParent,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
PRBool aIsPseudo,
nsFrameItems& aChildItems,
nsIFrame*& aNewOuterFrame,
nsIFrame*& aNewInnerFrame)
{
nsresult rv = NS_OK;
// create the pseudo SC for the outer table as a child of the inner SC
nsRefPtr<nsStyleContext> outerStyleContext;
outerStyleContext = mPresShell->StyleSet()->
ResolvePseudoStyleFor(aContent, nsCSSAnonBoxes::tableOuter, aStyleContext);
// Create the outer table frame which holds the caption and inner table frame
#ifdef MOZ_MATHML
if (kNameSpaceID_MathML == aNameSpaceID)
aNewOuterFrame = NS_NewMathMLmtableOuterFrame(mPresShell,
outerStyleContext);
else
#endif
aNewOuterFrame = NS_NewTableOuterFrame(mPresShell, outerStyleContext);
NS_ASSERTION(!IsTableRelated(aContentParent->GetType(), PR_TRUE) ||
aContentParent->GetType() == nsGkAtoms::tableCaptionFrame,
"Unexpected parent frame for table");
nsIFrame* geometricParent = aState.GetGeometricParent
(outerStyleContext->GetStyleDisplay(),
aContentParent);
// Init the table outer frame and see if we need to create a view, e.g.
// the frame is absolutely positioned
InitAndRestoreFrame(aState, aContent, geometricParent, nsnull, aNewOuterFrame);
nsHTMLContainerFrame::CreateViewForFrame(aNewOuterFrame, PR_FALSE);
// Create the inner table frame
#ifdef MOZ_MATHML
if (kNameSpaceID_MathML == aNameSpaceID)
aNewInnerFrame = NS_NewMathMLmtableFrame(mPresShell, aStyleContext);
else
#endif
aNewInnerFrame = NS_NewTableFrame(mPresShell, aStyleContext);
InitAndRestoreFrame(aState, aContent, aNewOuterFrame, nsnull,
aNewInnerFrame);
if (!aIsPseudo) {
// Put the newly created frames into the right child list
aNewOuterFrame->SetInitialChildList(nsnull, aNewInnerFrame);
rv = aState.AddChild(aNewOuterFrame, aChildItems, aContent,
aStyleContext, aContentParent);
if (NS_FAILED(rv)) {
return rv;
}
if (!mRootElementFrame) {
// The frame we're constructing will be the root element frame.
// Set mRootElementFrame before processing children.
mRootElementFrame = aNewOuterFrame;
}
nsFrameItems childItems;
rv = ProcessChildren(aState, aContent, aStyleContext, aNewInnerFrame,
PR_TRUE, childItems, PR_FALSE);
// XXXbz what about cleaning up?
if (NS_FAILED(rv)) return rv;
nsFrameItems captionItems;
PullOutCaptionFrames(childItems, captionItems);
// Set the inner table frame's initial primary list
aNewInnerFrame->SetInitialChildList(nsnull, childItems.childList);
// Set the outer table frame's secondary childlist lists
if (captionItems.childList) {
aNewOuterFrame->SetInitialChildList(nsGkAtoms::captionList,
captionItems.childList);
}
}
return rv;
}
nsresult
nsCSSFrameConstructor::ConstructTableCaptionFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrameIn,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
nsFrameItems& aChildItems,
nsIFrame*& aNewFrame,
PRBool* aHasPseudoParent)
{
if (!aParentFrameIn) return NS_ERROR_UNEXPECTED;
nsIFrame* parentFrame = aParentFrameIn;
*aHasPseudoParent = PR_FALSE;
// this frame may have a pseudo parent
CreateRequiredPseudoFrames(aNameSpaceID, *aParentFrameIn,
nsGkAtoms::tableCaptionFrame, aState, parentFrame,
*aHasPseudoParent);
if (!*aHasPseudoParent && !aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
aNewFrame = NS_NewTableCaptionFrame(mPresShell, aStyleContext);
if (NS_UNLIKELY(!aNewFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, aNewFrame);
nsHTMLContainerFrame::CreateViewForFrame(aNewFrame, PR_FALSE);
nsFrameItems childItems;
nsresult rv = ProcessChildren(aState, aContent, aStyleContext, aNewFrame,
PR_TRUE, childItems, PR_TRUE);
if (NS_FAILED(rv)) return rv;
aNewFrame->SetInitialChildList(nsnull, childItems.childList);
if (*aHasPseudoParent) {
aState.mPseudoFrames.mTableOuter.mChildList2.AddChild(aNewFrame);
}
return rv;
}
nsresult
nsCSSFrameConstructor::ConstructTableRowGroupFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrameIn,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
PRBool aIsPseudo,
nsFrameItems& aChildItems,
nsIFrame*& aNewFrame,
PRBool* aHasPseudoParent)
{
if (!aParentFrameIn) return NS_ERROR_UNEXPECTED;
nsIFrame* parentFrame = aParentFrameIn;
*aHasPseudoParent = PR_FALSE;
if (!aIsPseudo) {
// this frame may have a pseudo parent
CreateRequiredPseudoFrames(aNameSpaceID, *aParentFrameIn,
nsGkAtoms::tableRowGroupFrame, aState,
parentFrame, *aHasPseudoParent);
if (!*aHasPseudoParent && !aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
if (!aIsPseudo && *aHasPseudoParent &&
aState.mPseudoFrames.mRowGroup.mFrame) {
ProcessPseudoFrames(aState, nsGkAtoms::tableRowGroupFrame);
}
}
const nsStyleDisplay* styleDisplay = aStyleContext->GetStyleDisplay();
aNewFrame = NS_NewTableRowGroupFrame(mPresShell, aStyleContext);
nsIFrame* scrollFrame = nsnull;
if (styleDisplay->IsScrollableOverflow()) {
// Create an area container for the frame
BuildScrollFrame(aState, aContent, aStyleContext, aNewFrame, parentFrame,
scrollFrame);
}
else {
if (NS_UNLIKELY(!aNewFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, aNewFrame);
nsHTMLContainerFrame::CreateViewForFrame(aNewFrame, PR_FALSE);
}
if (!aIsPseudo) {
nsFrameItems childItems;
nsresult rv = ProcessChildren(aState, aContent, aStyleContext, aNewFrame,
PR_TRUE, childItems, PR_FALSE);
if (NS_FAILED(rv)) return rv;
aNewFrame->SetInitialChildList(nsnull, childItems.childList);
if (*aHasPseudoParent) {
nsIFrame* child = (scrollFrame) ? scrollFrame : aNewFrame;
aState.mPseudoFrames.mTableInner.mChildList.AddChild(child);
}
}
// if there is a scroll frame, use it as the one constructed
if (scrollFrame) {
aNewFrame = scrollFrame;
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructTableColGroupFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrameIn,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
PRBool aIsPseudo,
nsFrameItems& aChildItems,
nsIFrame*& aNewFrame,
PRBool* aHasPseudoParent)
{
if (!aParentFrameIn) return NS_ERROR_UNEXPECTED;
nsIFrame* parentFrame = aParentFrameIn;
*aHasPseudoParent = PR_FALSE;
if (!aIsPseudo) {
// this frame may have a pseudo parent
CreateRequiredPseudoFrames(aNameSpaceID, *aParentFrameIn,
nsGkAtoms::tableColGroupFrame, aState,
parentFrame, *aHasPseudoParent);
if (!*aHasPseudoParent && !aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
if (!aIsPseudo && *aHasPseudoParent &&
aState.mPseudoFrames.mColGroup.mFrame) {
ProcessPseudoFrames(aState, nsGkAtoms::tableColGroupFrame);
}
}
aNewFrame = NS_NewTableColGroupFrame(mPresShell, aStyleContext);
if (NS_UNLIKELY(!aNewFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, aNewFrame);
if (!aIsPseudo) {
nsFrameItems childItems;
nsresult rv = ProcessChildren(aState, aContent, aStyleContext, aNewFrame,
PR_TRUE, childItems, PR_FALSE);
if (NS_FAILED(rv)) return rv;
aNewFrame->SetInitialChildList(nsnull, childItems.childList);
if (*aHasPseudoParent) {
aState.mPseudoFrames.mTableInner.mChildList.AddChild(aNewFrame);
}
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructTableRowFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrameIn,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
PRBool aIsPseudo,
nsFrameItems& aChildItems,
nsIFrame*& aNewFrame,
PRBool* aHasPseudoParent)
{
if (!aParentFrameIn) return NS_ERROR_UNEXPECTED;
nsIFrame* parentFrame = aParentFrameIn;
*aHasPseudoParent = PR_FALSE;
if (!aIsPseudo) {
// this frame may have a pseudo parent
CreateRequiredPseudoFrames(aNameSpaceID, *aParentFrameIn,
nsGkAtoms::tableRowFrame, aState, parentFrame,
*aHasPseudoParent);
if (!*aHasPseudoParent && !aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
if (!aIsPseudo && *aHasPseudoParent && aState.mPseudoFrames.mRow.mFrame) {
ProcessPseudoFrames(aState, nsGkAtoms::tableRowFrame);
}
}
#ifdef MOZ_MATHML
if (kNameSpaceID_MathML == aNameSpaceID)
aNewFrame = NS_NewMathMLmtrFrame(mPresShell, aStyleContext);
else
#endif
aNewFrame = NS_NewTableRowFrame(mPresShell, aStyleContext);
if (NS_UNLIKELY(!aNewFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, aNewFrame);
nsHTMLContainerFrame::CreateViewForFrame(aNewFrame, PR_FALSE);
if (!aIsPseudo) {
nsFrameItems childItems;
nsresult rv = ProcessChildren(aState, aContent, aStyleContext, aNewFrame,
PR_TRUE, childItems, PR_FALSE);
if (NS_FAILED(rv)) return rv;
aNewFrame->SetInitialChildList(nsnull, childItems.childList);
if (*aHasPseudoParent) {
aState.mPseudoFrames.mRowGroup.mChildList.AddChild(aNewFrame);
}
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructTableColFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrameIn,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
PRBool aIsPseudo,
nsFrameItems& aChildItems,
nsIFrame*& aNewFrame,
PRBool* aHasPseudoParent)
{
if (!aParentFrameIn || !aStyleContext) return NS_ERROR_UNEXPECTED;
nsIFrame* parentFrame = aParentFrameIn;
*aHasPseudoParent = PR_FALSE;
if (!aIsPseudo) {
// this frame may have a pseudo parent
CreateRequiredPseudoFrames(aNameSpaceID, *aParentFrameIn,
nsGkAtoms::tableColFrame, aState, parentFrame,
*aHasPseudoParent);
if (!*aHasPseudoParent && !aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
}
nsTableColFrame* colFrame = NS_NewTableColFrame(mPresShell, aStyleContext);
aNewFrame = colFrame;
if (NS_UNLIKELY(!aNewFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, aNewFrame);
// construct additional col frames if the col frame has a span > 1
PRInt32 span = colFrame->GetSpan();
nsIFrame* lastCol = aNewFrame;
nsStyleContext* styleContext = nsnull;
for (PRInt32 spanX = 1; spanX < span; spanX++) {
// The same content node should always resolve to the same style context.
if (1 == spanX)
styleContext = aNewFrame->GetStyleContext();
nsTableColFrame* newCol = NS_NewTableColFrame(mPresShell, styleContext);
if (NS_UNLIKELY(!newCol)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, newCol, PR_FALSE);
lastCol->SetNextSibling(newCol);
lastCol->SetNextContinuation(newCol);
newCol->SetPrevContinuation(lastCol);
newCol->SetColType(eColAnonymousCol);
lastCol = newCol;
}
if (!aIsPseudo && *aHasPseudoParent) {
aState.mPseudoFrames.mColGroup.mChildList.AddChild(aNewFrame);
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructTableCellFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrameIn,
nsStyleContext* aStyleContext,
PRInt32 aNameSpaceID,
PRBool aIsPseudo,
nsFrameItems& aChildItems,
nsIFrame*& aNewCellOuterFrame,
nsIFrame*& aNewCellInnerFrame,
PRBool* aHasPseudoParent)
{
if (!aParentFrameIn) return NS_ERROR_UNEXPECTED;
nsIFrame* parentFrame = aParentFrameIn;
*aHasPseudoParent = PR_FALSE;
if (!aIsPseudo) {
// this frame may have a pseudo parent
// use nsGkAtoms::tableCellFrame which will match if it is really nsGkAtoms::bcTableCellFrame
CreateRequiredPseudoFrames(aNameSpaceID, *aParentFrameIn,
nsGkAtoms::tableCellFrame, aState, parentFrame,
*aHasPseudoParent);
if (!*aHasPseudoParent && !aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
if (!aIsPseudo && *aHasPseudoParent && aState.mPseudoFrames.mCellOuter.mFrame) {
ProcessPseudoFrames(aState, nsGkAtoms::tableCellFrame);
}
}
#ifdef MOZ_MATHML
// <mtable> is border separate in mathml.css and the MathML code doesn't implement
// border collapse. For those users who style <mtable> with border collapse,
// give them the default non-MathML table frames that understand border collpase.
// This won't break us because MathML table frames are all subclasses of the default
// table code, and so we can freely mix <mtable> with <mtr> or <tr>, <mtd> or <td>.
// What will happen is just that non-MathML frames won't understand MathML attributes
// and will therefore miss the special handling that the MathML code does.
if (kNameSpaceID_MathML == aNameSpaceID && !IsBorderCollapse(parentFrame))
aNewCellOuterFrame = NS_NewMathMLmtdFrame(mPresShell, aStyleContext);
else
#endif
// Warning: If you change this and add a wrapper frame around table cell
// frames, make sure Bug 368554 doesn't regress!
// See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.
aNewCellOuterFrame = NS_NewTableCellFrame(mPresShell, aStyleContext,
IsBorderCollapse(parentFrame));
if (NS_UNLIKELY(!aNewCellOuterFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Initialize the table cell frame
InitAndRestoreFrame(aState, aContent, parentFrame, nsnull, aNewCellOuterFrame);
nsHTMLContainerFrame::CreateViewForFrame(aNewCellOuterFrame, PR_FALSE);
// Resolve pseudo style and initialize the body cell frame
nsRefPtr<nsStyleContext> innerPseudoStyle;
innerPseudoStyle = mPresShell->StyleSet()->
ResolvePseudoStyleFor(aContent,
nsCSSAnonBoxes::cellContent, aStyleContext);
// Create a block frame that will format the cell's content
PRBool isBlock;
#ifdef MOZ_MATHML
if (kNameSpaceID_MathML == aNameSpaceID) {
aNewCellInnerFrame = NS_NewMathMLmtdInnerFrame(mPresShell, innerPseudoStyle);
isBlock = PR_FALSE;
}
else
#endif
{
aNewCellInnerFrame = NS_NewBlockFormattingContext(mPresShell,
innerPseudoStyle);
isBlock = PR_TRUE;
}
if (NS_UNLIKELY(!aNewCellInnerFrame)) {
aNewCellOuterFrame->Destroy();
aNewCellOuterFrame = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, aNewCellOuterFrame, nsnull, aNewCellInnerFrame);
if (!aIsPseudo) {
// Process the child content
nsFrameItems childItems;
nsresult rv = ProcessChildren(aState, aContent, aStyleContext,
aNewCellInnerFrame, PR_TRUE, childItems, isBlock);
if (NS_FAILED(rv)) {
// Clean up
// XXXbz kids of this stuff need to be cleaned up too!
aNewCellInnerFrame->Destroy();
aNewCellInnerFrame = nsnull;
aNewCellOuterFrame->Destroy();
aNewCellOuterFrame = nsnull;
return rv;
}
aNewCellInnerFrame->SetInitialChildList(nsnull, childItems.childList);
aNewCellOuterFrame->SetInitialChildList(nsnull, aNewCellInnerFrame);
if (*aHasPseudoParent) {
aState.mPseudoFrames.mRow.mChildList.AddChild(aNewCellOuterFrame);
}
}
return NS_OK;
}
static PRBool
NeedFrameFor(nsIFrame* aParentFrame,
nsIContent* aChildContent)
{
// don't create a whitespace frame if aParentFrame doesn't want it.
// always create frames for children in generated content. counter(),
// quotes, and attr() content can easily change dynamically and we don't
// want to be reconstructing frames. It's not even clear that these
// should be considered ignorable just because they evaluate to
// whitespace.
return !aParentFrame->IsFrameOfType(nsIFrame::eExcludesIgnorableWhitespace)
|| !TextIsOnlyWhitespace(aChildContent)
|| aParentFrame->IsGeneratedContentFrame();
}
/***********************************************
* END TABLE SECTION
***********************************************/
static PRBool CheckOverflow(nsPresContext* aPresContext,
const nsStyleDisplay* aDisplay)
{
if (aDisplay->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE)
return PR_FALSE;
if (aDisplay->mOverflowX == NS_STYLE_OVERFLOW_CLIP)
aPresContext->SetViewportOverflowOverride(NS_STYLE_OVERFLOW_HIDDEN,
NS_STYLE_OVERFLOW_HIDDEN);
else
aPresContext->SetViewportOverflowOverride(aDisplay->mOverflowX,
aDisplay->mOverflowY);
return PR_TRUE;
}
/**
* This checks the root element and the HTML BODY, if any, for an "overflow" property
* that should be applied to the viewport. If one is found then we return the
* element that we took the overflow from (which should then be treated as
* "overflow:visible"), and we store the overflow style in the prescontext.
* @return if scroll was propagated from some content node, the content node it
* was propagated from.
*/
nsIContent*
nsCSSFrameConstructor::PropagateScrollToViewport()
{
// Set default
nsPresContext* presContext = mPresShell->GetPresContext();
presContext->SetViewportOverflowOverride(NS_STYLE_OVERFLOW_AUTO,
NS_STYLE_OVERFLOW_AUTO);
// We never mess with the viewport scroll state
// when printing or in print preview
if (presContext->IsPaginated()) {
return nsnull;
}
nsIContent* docElement = mDocument->GetRootContent();
// Check the style on the document root element
nsStyleSet *styleSet = mPresShell->StyleSet();
nsRefPtr<nsStyleContext> rootStyle;
rootStyle = styleSet->ResolveStyleFor(docElement, nsnull);
if (!rootStyle) {
return nsnull;
}
if (CheckOverflow(presContext, rootStyle->GetStyleDisplay())) {
// tell caller we stole the overflow style from the root element
return docElement;
}
// Don't look in the BODY for non-HTML documents or HTML documents
// with non-HTML roots
// XXX this should be earlier; we shouldn't even look at the document root
// for non-HTML documents. Fix this once we support explicit CSS styling
// of the viewport
// XXX what about XHTML?
nsCOMPtr<nsIDOMHTMLDocument> htmlDoc(do_QueryInterface(mDocument));
if (!htmlDoc || !docElement->IsNodeOfType(nsINode::eHTML)) {
return nsnull;
}
nsCOMPtr<nsIDOMHTMLElement> body;
htmlDoc->GetBody(getter_AddRefs(body));
nsCOMPtr<nsIContent> bodyElement = do_QueryInterface(body);
if (!bodyElement ||
!bodyElement->NodeInfo()->Equals(nsGkAtoms::body)) {
// The body is not a <body> tag, it's a <frameset>.
return nsnull;
}
nsRefPtr<nsStyleContext> bodyStyle;
bodyStyle = styleSet->ResolveStyleFor(bodyElement, rootStyle);
if (!bodyStyle) {
return nsnull;
}
if (CheckOverflow(presContext, bodyStyle->GetStyleDisplay())) {
// tell caller we stole the overflow style from the body element
return bodyElement;
}
return nsnull;
}
/**
* New one
*/
nsresult
nsCSSFrameConstructor::ConstructDocElementFrame(nsFrameConstructorState& aState,
nsIContent* aDocElement,
nsIFrame* aParentFrame,
nsIFrame** aNewFrame)
{
*aNewFrame = nsnull;
if (!mTempFrameTreeState)
aState.mPresShell->CaptureHistoryState(getter_AddRefs(mTempFrameTreeState));
// ----- reattach gfx scrollbars ------
// Gfx scrollframes were created in the root frame but the primary frame map may have been destroyed if a
// new style sheet was loaded so lets reattach the frames to their content.
// XXX this seems truly bogus, we wipe out mGfxScrollFrame below
if (mGfxScrollFrame) {
nsIFrame* gfxScrollbarFrame1 = mGfxScrollFrame->GetFirstChild(nsnull);
// Check the frame type because when there aren't scrollbars, we'll
// get the canvas.
if (gfxScrollbarFrame1 &&
gfxScrollbarFrame1->GetType() == nsGkAtoms::scrollbarFrame) {
// XXX This works, but why?
aState.mFrameManager->
SetPrimaryFrameFor(gfxScrollbarFrame1->GetContent(), gfxScrollbarFrame1);
nsIFrame* gfxScrollbarFrame2 = gfxScrollbarFrame1->GetNextSibling();
if (gfxScrollbarFrame2 &&
gfxScrollbarFrame2->GetType() == nsGkAtoms::scrollbarFrame) {
// XXX This works, but why?
aState.mFrameManager->
SetPrimaryFrameFor(gfxScrollbarFrame2->GetContent(), gfxScrollbarFrame2);
}
}
}
// --------- CREATE AREA OR BOX FRAME -------
nsRefPtr<nsStyleContext> styleContext;
styleContext = mPresShell->StyleSet()->ResolveStyleFor(aDocElement,
nsnull);
const nsStyleDisplay* display = styleContext->GetStyleDisplay();
// Ensure that our XBL bindings are installed.
if (display->mBinding) {
// Get the XBL loader.
nsresult rv;
PRBool resolveStyle;
nsIXBLService * xblService = GetXBLService();
if (!xblService)
return NS_ERROR_FAILURE;
nsRefPtr<nsXBLBinding> binding;
rv = xblService->LoadBindings(aDocElement, display->mBinding->mURI,
display->mBinding->mOriginPrincipal,
PR_FALSE, getter_AddRefs(binding),
&resolveStyle);
if (NS_FAILED(rv))
return NS_OK; // Binding will load asynchronously.
if (binding) {
mDocument->BindingManager()->AddToAttachedQueue(binding);
}
if (resolveStyle) {
styleContext = mPresShell->StyleSet()->ResolveStyleFor(aDocElement,
nsnull);
display = styleContext->GetStyleDisplay();
}
}
// --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------
#ifdef DEBUG
PRBool propagatedScrollToViewport =
PropagateScrollToViewport() == aDocElement;
NS_ASSERTION(!display->IsScrollableOverflow() ||
aState.mPresContext->IsPaginated() ||
propagatedScrollToViewport,
"Scrollbars should have been propagated to the viewport");
#endif
if (NS_UNLIKELY(display->mDisplay == NS_STYLE_DISPLAY_NONE)) {
aState.mFrameManager->SetUndisplayedContent(aDocElement, styleContext);
mRootElementFrame = nsnull;
mRootElementStyleFrame = nsnull;
return NS_OK;
}
nsFrameConstructorSaveState absoluteSaveState;
if (mHasRootAbsPosContainingBlock) {
// Push the absolute containing block now so we can absolutely position
// the root element
aState.PushAbsoluteContainingBlock(mDocElementContainingBlock, absoluteSaveState);
}
nsresult rv;
// The rules from CSS 2.1, section 9.2.4, have already been applied
// by the style system, so we can assume that display->mDisplay is
// either NONE, BLOCK, or TABLE.
// contentFrame is the primary frame for the root element. *aNewFrame
// is the frame that will be the child of the initial containing block.
// These are usually the same frame but they can be different, in
// particular if the root frame is positioned, in which case
// contentFrame is the out-of-flow frame and *aNewFrame is the
// placeholder.
nsIFrame* contentFrame;
PRBool processChildren = PR_FALSE;
// Check whether we need to build a XUL box or SVG root frame
#ifdef MOZ_XUL
if (aDocElement->IsNodeOfType(nsINode::eXUL)) {
contentFrame = NS_NewDocElementBoxFrame(mPresShell, styleContext);
if (NS_UNLIKELY(!contentFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aDocElement, aParentFrame, nsnull, contentFrame);
*aNewFrame = contentFrame;
processChildren = PR_TRUE;
}
else
#endif
#ifdef MOZ_SVG
if (aDocElement->GetNameSpaceID() == kNameSpaceID_SVG) {
if (aDocElement->Tag() == nsGkAtoms::svg && NS_SVGEnabled()) {
contentFrame = NS_NewSVGOuterSVGFrame(mPresShell, styleContext);
if (NS_UNLIKELY(!contentFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aDocElement,
aState.GetGeometricParent(display, aParentFrame),
nsnull, contentFrame);
// AddChild takes care of transforming the frame tree for fixed-pos
// or abs-pos situations
nsFrameItems frameItems;
rv = aState.AddChild(contentFrame, frameItems, aDocElement,
styleContext, aParentFrame);
if (NS_FAILED(rv) || !frameItems.childList) {
return rv;
}
*aNewFrame = frameItems.childList;
processChildren = PR_TRUE;
// See if we need to create a view
nsHTMLContainerFrame::CreateViewForFrame(contentFrame, PR_FALSE);
} else {
return NS_ERROR_FAILURE;
}
}
else
#endif
{
PRBool docElemIsTable = (display->mDisplay == NS_STYLE_DISPLAY_TABLE);
if (docElemIsTable) {
nsIFrame* innerTableFrame;
nsFrameItems frameItems;
// if the document is a table then just populate it.
rv = ConstructTableFrame(aState, aDocElement,
aParentFrame, styleContext,
kNameSpaceID_None, PR_FALSE, frameItems,
contentFrame, innerTableFrame);
if (NS_FAILED(rv))
return rv;
if (!contentFrame || !frameItems.childList)
return NS_ERROR_FAILURE;
*aNewFrame = frameItems.childList;
NS_ASSERTION(!frameItems.childList->GetNextSibling(),
"multiple root element frames");
} else {
contentFrame = NS_NewBlockFrame(mPresShell, styleContext,
NS_BLOCK_FLOAT_MGR|NS_BLOCK_MARGIN_ROOT);
if (!contentFrame)
return NS_ERROR_OUT_OF_MEMORY;
nsFrameItems frameItems;
rv = ConstructBlock(aState, display, aDocElement,
aState.GetGeometricParent(display, aParentFrame),
aParentFrame, styleContext, &contentFrame,
frameItems, display->IsPositioned());
if (NS_FAILED(rv) || !frameItems.childList)
return rv;
*aNewFrame = frameItems.childList;
NS_ASSERTION(!frameItems.childList->GetNextSibling(),
"multiple root element frames");
}
}
// set the primary frame
aState.mFrameManager->SetPrimaryFrameFor(aDocElement, contentFrame);
NS_ASSERTION(processChildren ? !mRootElementFrame :
mRootElementFrame == contentFrame,
"unexpected mRootElementFrame");
mRootElementFrame = contentFrame;
// Figure out which frame has the main style for the document element,
// assigning it to mRootElementStyleFrame.
// Backgrounds should be propagated from that frame to the viewport.
PRBool isChild;
contentFrame->GetParentStyleContextFrame(aState.mPresContext,
&mRootElementStyleFrame, &isChild);
if (!isChild) {
mRootElementStyleFrame = mRootElementFrame;
}
if (processChildren) {
// Still need to process the child content
nsFrameItems childItems;
NS_ASSERTION(!nsLayoutUtils::GetAsBlock(contentFrame),
"Only XUL and SVG frames should reach here");
ProcessChildren(aState, aDocElement, styleContext, contentFrame, PR_TRUE,
childItems, PR_FALSE);
// Set the initial child lists
contentFrame->SetInitialChildList(nsnull, childItems.childList);
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructRootFrame(nsIContent* aDocElement,
nsIFrame** aNewFrame)
{
AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
NS_PRECONDITION(aNewFrame, "null out param");
/*
how the root frame hierarchy should look
Galley presentation, non-XUL, with scrolling (i.e. not a frameset):
ViewportFrame [fixed-cb]
nsHTMLScrollFrame
CanvasFrame [abs-cb]
root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
nsTableOuterFrame, nsPlaceholderFrame)
Galley presentation, non-XUL, without scrolling (i.e. a frameset):
ViewportFrame [fixed-cb]
CanvasFrame [abs-cb]
root element frame (nsBlockFrame)
Galley presentation, XUL
ViewportFrame [fixed-cb]
nsRootBoxFrame
root element frame (nsDocElementBoxFrame)
Print presentation, non-XUL
ViewportFrame
nsSimplePageSequenceFrame
nsPageFrame [fixed-cb]
nsPageContentFrame
CanvasFrame [abs-cb]
root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
nsTableOuterFrame, nsPlaceholderFrame)
Print-preview presentation, non-XUL
ViewportFrame
nsHTMLScrollFrame
nsSimplePageSequenceFrame
nsPageFrame [fixed-cb]
nsPageContentFrame
CanvasFrame [abs-cb]
root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
nsTableOuterFrame, nsPlaceholderFrame)
Print/print preview of XUL is not supported.
[fixed-cb]: the default containing block for fixed-pos content
[abs-cb]: the default containing block for abs-pos content
Meaning of nsCSSFrameConstructor fields:
mRootElementFrame is "root element frame".
mDocElementContainingBlock is the parent of mRootElementFrame
(i.e. CanvasFrame or nsRootBoxFrame)
mFixedContainingBlock is the [fixed-cb]
mGfxScrollFrame is the nsHTMLScrollFrame mentioned above, or null if there isn't one
mPageSequenceFrame is the nsSimplePageSequenceFrame, or null if there isn't one
*/
// Set up our style rule observer.
{
mPresShell->StyleSet()->SetBindingManager(mDocument->BindingManager());
}
// --------- BUILD VIEWPORT -----------
nsIFrame* viewportFrame = nsnull;
nsRefPtr<nsStyleContext> viewportPseudoStyle;
nsStyleSet *styleSet = mPresShell->StyleSet();
viewportPseudoStyle = styleSet->ResolvePseudoStyleFor(nsnull,
nsCSSAnonBoxes::viewport,
nsnull);
viewportFrame = NS_NewViewportFrame(mPresShell, viewportPseudoStyle);
nsPresContext* presContext = mPresShell->GetPresContext();
// XXXbz do we _have_ to pass a null content pointer to that frame?
// Would it really kill us to pass in the root element or something?
// What would that break?
viewportFrame->Init(nsnull, nsnull, nsnull);
// Bind the viewport frame to the root view
nsIViewManager* viewManager = mPresShell->GetViewManager();
nsIView* rootView;
viewManager->GetRootView(rootView);
viewportFrame->SetView(rootView);
nsContainerFrame::SyncFrameViewProperties(presContext, viewportFrame,
viewportPseudoStyle, rootView);
// The viewport is the containing block for 'fixed' elements
mFixedContainingBlock = viewportFrame;
// --------- CREATE ROOT FRAME -------
// Create the root frame. The document element's frame is a child of the
// root frame.
//
// The root frame serves two purposes:
// - reserves space for any margins needed for the document element's frame
// - renders the document element's background. This ensures the background covers
// the entire canvas as specified by the CSS2 spec
PRBool isPaginated = presContext->IsRootPaginatedDocument();
nsIFrame* rootFrame = nsnull;
nsIAtom* rootPseudo;
if (!isPaginated) {
#ifdef MOZ_XUL
if (aDocElement->IsNodeOfType(nsINode::eXUL))
{
// pass a temporary stylecontext, the correct one will be set later
rootFrame = NS_NewRootBoxFrame(mPresShell, viewportPseudoStyle);
} else
#endif
{
// pass a temporary stylecontext, the correct one will be set later
rootFrame = NS_NewCanvasFrame(mPresShell, viewportPseudoStyle);
mHasRootAbsPosContainingBlock = PR_TRUE;
}
rootPseudo = nsCSSAnonBoxes::canvas;
mDocElementContainingBlock = rootFrame;
} else {
// Create a page sequence frame
rootFrame = NS_NewSimplePageSequenceFrame(mPresShell, viewportPseudoStyle);
mPageSequenceFrame = rootFrame;
rootPseudo = nsCSSAnonBoxes::pageSequence;
}
// --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------
// If the device supports scrolling (e.g., in galley mode on the screen and
// for print-preview, but not when printing), then create a scroll frame that
// will act as the scrolling mechanism for the viewport.
// XXX Do we even need a viewport when printing to a printer?
// As long as the webshell doesn't prohibit it, and the device supports
// it, create a scroll frame that will act as the scolling mechanism for
// the viewport.
//
// Threre are three possible values stored in the docshell:
// 1) nsIScrollable::Scrollbar_Never = no scrollbars
// 2) nsIScrollable::Scrollbar_Auto = scrollbars appear if needed
// 3) nsIScrollable::Scrollbar_Always = scrollbars always
// Only need to create a scroll frame/view for cases 2 and 3.
PRBool isHTML = aDocElement->IsNodeOfType(nsINode::eHTML);
PRBool isXUL = PR_FALSE;
if (!isHTML) {
isXUL = aDocElement->IsNodeOfType(nsINode::eXUL);
}
// Never create scrollbars for XUL documents
PRBool isScrollable = !isXUL;
// Never create scrollbars for frameset documents.
if (isHTML) {
nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(mDocument);
if (htmlDoc && htmlDoc->GetIsFrameset())
isScrollable = PR_FALSE;
}
if (isPaginated) {
isScrollable = presContext->HasPaginatedScrolling();
}
// We no longer need to do overflow propagation here. It's taken care of
// when we construct frames for the element whose overflow might be
// propagated
NS_ASSERTION(!isScrollable || !isXUL,
"XUL documents should never be scrollable - see above");
nsIFrame* newFrame = rootFrame;
nsRefPtr<nsStyleContext> rootPseudoStyle;
// we must create a state because if the scrollbars are GFX it needs the
// state to build the scrollbar frames.
nsFrameConstructorState state(mPresShell, nsnull, nsnull, nsnull);
nsIFrame* parentFrame = viewportFrame;
// If paginated, make sure we don't put scrollbars in
if (!isScrollable) {
rootPseudoStyle = styleSet->ResolvePseudoStyleFor(nsnull,
rootPseudo,
viewportPseudoStyle);
} else {
if (rootPseudo == nsCSSAnonBoxes::canvas) {
rootPseudo = nsCSSAnonBoxes::scrolledCanvas;
} else {
NS_ASSERTION(rootPseudo == nsCSSAnonBoxes::pageSequence,
"Unknown root pseudo");
rootPseudo = nsCSSAnonBoxes::scrolledPageSequence;
}
// Build the frame. We give it the content we are wrapping which is the document,
// the root frame, the parent view port frame, and we should get back the new
// frame and the scrollable view if one was created.
// resolve a context for the scrollframe
nsRefPtr<nsStyleContext> styleContext;
styleContext = styleSet->ResolvePseudoStyleFor(nsnull,
nsCSSAnonBoxes::viewportScroll,
viewportPseudoStyle);
// Note that the viewport scrollframe is always built with
// overflow:auto style. This forces the scroll frame to create
// anonymous content for both scrollbars. This is necessary even
// if the HTML or BODY elements are overriding the viewport
// scroll style to 'hidden' --- dynamic style changes might put
// scrollbars back on the viewport and we don't want to have to
// reframe the viewport to create the scrollbar content.
newFrame = nsnull;
rootPseudoStyle = BeginBuildingScrollFrame( state,
aDocElement,
styleContext,
viewportFrame,
rootPseudo,
PR_TRUE,
newFrame);
nsIScrollableFrame* scrollable = do_QueryFrame(newFrame);
NS_ENSURE_TRUE(scrollable, NS_ERROR_FAILURE);
nsIScrollableView* scrollableView = scrollable->GetScrollableView();
NS_ENSURE_TRUE(scrollableView, NS_ERROR_FAILURE);
viewManager->SetRootScrollableView(scrollableView);
parentFrame = newFrame;
mGfxScrollFrame = newFrame;
}
rootFrame->SetStyleContextWithoutNotification(rootPseudoStyle);
rootFrame->Init(aDocElement, parentFrame, nsnull);
if (isScrollable) {
FinishBuildingScrollFrame(parentFrame, rootFrame);
}
if (isPaginated) { // paginated
// Create the first page
// Set the initial child lists
nsIFrame *pageFrame, *canvasFrame;
ConstructPageFrame(mPresShell, presContext, rootFrame, nsnull,
pageFrame, canvasFrame);
rootFrame->SetInitialChildList(nsnull, pageFrame);
// The eventual parent of the document element frame.
// XXX should this be set for every new page (in ConstructPageFrame)?
mDocElementContainingBlock = canvasFrame;
mHasRootAbsPosContainingBlock = PR_TRUE;
}
viewportFrame->SetInitialChildList(nsnull, newFrame);
*aNewFrame = viewportFrame;
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructPageFrame(nsIPresShell* aPresShell,
nsPresContext* aPresContext,
nsIFrame* aParentFrame,
nsIFrame* aPrevPageFrame,
nsIFrame*& aPageFrame,
nsIFrame*& aCanvasFrame)
{
nsStyleContext* parentStyleContext = aParentFrame->GetStyleContext();
nsStyleSet *styleSet = aPresShell->StyleSet();
nsRefPtr<nsStyleContext> pagePseudoStyle;
pagePseudoStyle = styleSet->ResolvePseudoStyleFor(nsnull,
nsCSSAnonBoxes::page,
parentStyleContext);
aPageFrame = NS_NewPageFrame(aPresShell, pagePseudoStyle);
if (NS_UNLIKELY(!aPageFrame))
return NS_ERROR_OUT_OF_MEMORY;
// Initialize the page frame and force it to have a view. This makes printing of
// the pages easier and faster.
aPageFrame->Init(nsnull, aParentFrame, aPrevPageFrame);
nsRefPtr<nsStyleContext> pageContentPseudoStyle;
pageContentPseudoStyle = styleSet->ResolvePseudoStyleFor(nsnull,
nsCSSAnonBoxes::pageContent,
pagePseudoStyle);
nsIFrame* pageContentFrame = NS_NewPageContentFrame(aPresShell, pageContentPseudoStyle);
if (NS_UNLIKELY(!pageContentFrame))
return NS_ERROR_OUT_OF_MEMORY;
// Initialize the page content frame and force it to have a view. Also make it the
// containing block for fixed elements which are repeated on every page.
nsIFrame* prevPageContentFrame = nsnull;
if (aPrevPageFrame) {
prevPageContentFrame = aPrevPageFrame->GetFirstChild(nsnull);
NS_ASSERTION(prevPageContentFrame, "missing page content frame");
}
pageContentFrame->Init(nsnull, aPageFrame, prevPageContentFrame);
aPageFrame->SetInitialChildList(nsnull, pageContentFrame);
mFixedContainingBlock = pageContentFrame;
nsRefPtr<nsStyleContext> canvasPseudoStyle;
canvasPseudoStyle = styleSet->ResolvePseudoStyleFor(nsnull,
nsCSSAnonBoxes::canvas,
pageContentPseudoStyle);
aCanvasFrame = NS_NewCanvasFrame(aPresShell, canvasPseudoStyle);
if (NS_UNLIKELY(!aCanvasFrame))
return NS_ERROR_OUT_OF_MEMORY;
nsIFrame* prevCanvasFrame = nsnull;
if (prevPageContentFrame) {
prevCanvasFrame = prevPageContentFrame->GetFirstChild(nsnull);
NS_ASSERTION(prevCanvasFrame, "missing canvas frame");
}
aCanvasFrame->Init(nsnull, pageContentFrame, prevCanvasFrame);
pageContentFrame->SetInitialChildList(nsnull, aCanvasFrame);
return NS_OK;
}
/* static */
nsresult
nsCSSFrameConstructor::CreatePlaceholderFrameFor(nsIPresShell* aPresShell,
nsIContent* aContent,
nsIFrame* aFrame,
nsStyleContext* aStyleContext,
nsIFrame* aParentFrame,
nsIFrame* aPrevInFlow,
nsIFrame** aPlaceholderFrame)
{
nsRefPtr<nsStyleContext> placeholderStyle = aPresShell->StyleSet()->
ResolveStyleForNonElement(aStyleContext->GetParent());
// The placeholder frame gets a pseudo style context
nsPlaceholderFrame* placeholderFrame =
(nsPlaceholderFrame*)NS_NewPlaceholderFrame(aPresShell, placeholderStyle);
if (placeholderFrame) {
placeholderFrame->Init(aContent, aParentFrame, aPrevInFlow);
// The placeholder frame has a pointer back to the out-of-flow frame
placeholderFrame->SetOutOfFlowFrame(aFrame);
aFrame->AddStateBits(NS_FRAME_OUT_OF_FLOW);
// Add mapping from absolutely positioned frame to its placeholder frame
aPresShell->FrameManager()->RegisterPlaceholderFrame(placeholderFrame);
*aPlaceholderFrame = static_cast<nsIFrame*>(placeholderFrame);
return NS_OK;
}
else {
return NS_ERROR_OUT_OF_MEMORY;
}
}
nsresult
nsCSSFrameConstructor::ConstructButtonFrame(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aStyleDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
*aNewFrame = nsnull;
nsIFrame* buttonFrame = nsnull;
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
if (nsGkAtoms::button == aItem.mTag) {
buttonFrame = NS_NewHTMLButtonControlFrame(mPresShell, styleContext);
}
else {
buttonFrame = NS_NewGfxButtonControlFrame(mPresShell, styleContext);
}
if (NS_UNLIKELY(!buttonFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Initialize the button frame
nsresult rv = InitAndRestoreFrame(aState, content,
aState.GetGeometricParent(aStyleDisplay, aParentFrame),
nsnull, buttonFrame);
if (NS_FAILED(rv)) {
buttonFrame->Destroy();
return rv;
}
// See if we need to create a view
nsHTMLContainerFrame::CreateViewForFrame(buttonFrame, PR_FALSE);
nsRefPtr<nsStyleContext> innerBlockContext;
innerBlockContext =
mPresShell->StyleSet()->ResolvePseudoStyleFor(content,
nsCSSAnonBoxes::buttonContent,
styleContext);
nsIFrame* blockFrame = NS_NewBlockFrame(mPresShell, innerBlockContext,
NS_BLOCK_FLOAT_MGR);
if (NS_UNLIKELY(!blockFrame)) {
buttonFrame->Destroy();
return NS_ERROR_OUT_OF_MEMORY;
}
rv = InitAndRestoreFrame(aState, content, buttonFrame, nsnull, blockFrame);
if (NS_FAILED(rv)) {
blockFrame->Destroy();
buttonFrame->Destroy();
return rv;
}
rv = aState.AddChild(buttonFrame, aFrameItems, content, styleContext,
aParentFrame);
if (NS_FAILED(rv)) {
blockFrame->Destroy();
buttonFrame->Destroy();
return rv;
}
PRBool isLeaf = buttonFrame->IsLeaf();
#ifdef DEBUG
// Make sure that we're an anonymous content creator exactly when we're a
// leaf
nsIAnonymousContentCreator* creator = do_QueryFrame(buttonFrame);
NS_ASSERTION(!creator == !isLeaf,
"Should be creator exactly when we're a leaf");
#endif
if (!isLeaf) {
// Process children
nsFrameConstructorSaveState absoluteSaveState;
nsFrameItems childItems;
if (aStyleDisplay->IsPositioned()) {
// The area frame becomes a container for child frames that are
// absolutely positioned
aState.PushAbsoluteContainingBlock(blockFrame, absoluteSaveState);
}
#ifdef DEBUG
// Make sure that anonymous child creation will have no effect in this case
nsIAnonymousContentCreator* creator = do_QueryFrame(blockFrame);
NS_ASSERTION(!creator, "Shouldn't be an anonymous content creator!");
#endif
rv = ProcessChildren(aState, content, styleContext, blockFrame, PR_TRUE,
childItems, aStyleDisplay->IsBlockOutside());
if (NS_FAILED(rv)) return rv;
// Set the areas frame's initial child lists
blockFrame->SetInitialChildList(nsnull, childItems.childList);
}
buttonFrame->SetInitialChildList(nsnull, blockFrame);
if (isLeaf) {
nsFrameItems anonymousChildItems;
// if there are any anonymous children create frames for them. Note that
// we're doing this using a different parent frame from the one we pass to
// ProcessChildren!
CreateAnonymousFrames(aState, content, buttonFrame, anonymousChildItems);
if (anonymousChildItems.childList) {
// the anonymous content is already parented to the area frame
aState.mFrameManager->AppendFrames(blockFrame, nsnull,
anonymousChildItems.childList);
}
}
// our new button frame returned is the top frame.
*aNewFrame = buttonFrame;
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructSelectFrame(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aStyleDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsresult rv = NS_OK;
const PRInt32 kNoSizeSpecified = -1;
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
// Construct a frame-based listbox or combobox
nsCOMPtr<nsIDOMHTMLSelectElement> sel(do_QueryInterface(content));
PRInt32 size = 1;
if (sel) {
sel->GetSize(&size);
PRBool multipleSelect = PR_FALSE;
sel->GetMultiple(&multipleSelect);
// Construct a combobox if size=1 or no size is specified and its multiple select
if (((1 == size || 0 == size) || (kNoSizeSpecified == size)) && (PR_FALSE == multipleSelect)) {
// Construct a frame-based combo box.
// The frame-based combo box is built out of three parts. A display area, a button and
// a dropdown list. The display area and button are created through anonymous content.
// The drop-down list's frame is created explicitly. The combobox frame shares its content
// with the drop-down list.
PRUint32 flags = NS_BLOCK_FLOAT_MGR;
nsIFrame* comboboxFrame = NS_NewComboboxControlFrame(mPresShell, styleContext, flags);
// Save the history state so we don't restore during construction
// since the complete tree is required before we restore.
nsILayoutHistoryState *historyState = aState.mFrameState;
aState.mFrameState = nsnull;
// Initialize the combobox frame
InitAndRestoreFrame(aState, content,
aState.GetGeometricParent(aStyleDisplay, aParentFrame),
nsnull, comboboxFrame);
nsHTMLContainerFrame::CreateViewForFrame(comboboxFrame, PR_FALSE);
rv = aState.AddChild(comboboxFrame, aFrameItems, content, styleContext,
aParentFrame);
if (NS_FAILED(rv)) {
return rv;
}
///////////////////////////////////////////////////////////////////
// Combobox - Old Native Implementation
///////////////////////////////////////////////////////////////////
nsIComboboxControlFrame* comboBox = do_QueryFrame(comboboxFrame);
NS_ASSERTION(comboBox, "NS_NewComboboxControlFrame returned frame that "
"doesn't implement nsIComboboxControlFrame");
// Resolve pseudo element style for the dropdown list
nsRefPtr<nsStyleContext> listStyle;
listStyle = mPresShell->StyleSet()->ResolvePseudoStyleFor(content,
nsCSSAnonBoxes::dropDownList,
styleContext);
// Create a listbox
nsIFrame* listFrame = NS_NewListControlFrame(mPresShell, listStyle);
// Notify the listbox that it is being used as a dropdown list.
nsIListControlFrame * listControlFrame = do_QueryFrame(listFrame);
if (listControlFrame) {
listControlFrame->SetComboboxFrame(comboboxFrame);
}
// Notify combobox that it should use the listbox as it's popup
comboBox->SetDropDown(listFrame);
NS_ASSERTION(!listStyle->GetStyleDisplay()->IsPositioned(),
"Ended up with positioned dropdown list somehow.");
NS_ASSERTION(!listStyle->GetStyleDisplay()->IsFloating(),
"Ended up with floating dropdown list somehow.");
// Initialize the scroll frame positioned. Note that it is NOT
// initialized as absolutely positioned.
nsIFrame* scrolledFrame = NS_NewSelectsAreaFrame(mPresShell, styleContext, flags);
InitializeSelectFrame(aState, listFrame, scrolledFrame, content,
comboboxFrame, listStyle, PR_TRUE, aFrameItems);
// Set flag so the events go to the listFrame not child frames.
// XXX: We should replace this with a real widget manager similar
// to how the nsFormControlFrame works. Re-directing events is a temporary Kludge.
NS_ASSERTION(listFrame->GetView(), "ListFrame's view is nsnull");
//listFrame->GetView()->SetViewFlags(NS_VIEW_PUBLIC_FLAG_DONT_CHECK_CHILDREN);
// Create display and button frames from the combobox's anonymous content.
// The anonymous content is appended to existing anonymous content for this
// element (the scrollbars).
nsFrameItems childItems;
CreateAnonymousFrames(aState, content, comboboxFrame, childItems);
comboboxFrame->SetInitialChildList(nsnull, childItems.childList);
// Initialize the additional popup child list which contains the
// dropdown list frame.
nsFrameItems popupItems;
popupItems.AddChild(listFrame);
comboboxFrame->SetInitialChildList(nsGkAtoms::selectPopupList,
popupItems.childList);
*aNewFrame = comboboxFrame;
aState.mFrameState = historyState;
if (aState.mFrameState && aState.mFrameManager) {
// Restore frame state for the entire subtree of |comboboxFrame|.
aState.mFrameManager->RestoreFrameState(comboboxFrame,
aState.mFrameState);
}
} else {
///////////////////////////////////////////////////////////////////
// ListBox - Old Native Implementation
///////////////////////////////////////////////////////////////////
nsIFrame* listFrame = NS_NewListControlFrame(mPresShell, styleContext);
if (listFrame) {
rv = NS_OK;
}
else {
rv = NS_ERROR_OUT_OF_MEMORY;
}
nsIFrame* scrolledFrame = NS_NewSelectsAreaFrame(
mPresShell, styleContext, NS_BLOCK_FLOAT_MGR);
// ******* this code stolen from Initialze ScrollFrame ********
// please adjust this code to use BuildScrollFrame.
InitializeSelectFrame(aState, listFrame, scrolledFrame, content,
aParentFrame, styleContext, PR_FALSE, aFrameItems);
*aNewFrame = listFrame;
}
}
return rv;
}
/**
* Used to be InitializeScrollFrame but now it's only used for the select tag
* But the select tag should really be fixed to use GFX scrollbars that can
* be create with BuildScrollFrame.
*/
nsresult
nsCSSFrameConstructor::InitializeSelectFrame(nsFrameConstructorState& aState,
nsIFrame* scrollFrame,
nsIFrame* scrolledFrame,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsStyleContext* aStyleContext,
PRBool aBuildCombobox,
nsFrameItems& aFrameItems)
{
const nsStyleDisplay* display = aStyleContext->GetStyleDisplay();
// Initialize it
nsIFrame* geometricParent = aState.GetGeometricParent(display, aParentFrame);
// We don't call InitAndRestoreFrame for scrollFrame because we can only
// restore the frame state after its parts have been created (in particular,
// the scrollable view). So we have to split Init and Restore.
// Initialize the frame
scrollFrame->Init(aContent, geometricParent, nsnull);
if (!aBuildCombobox) {
nsresult rv = aState.AddChild(scrollFrame, aFrameItems, aContent,
aStyleContext, aParentFrame);
if (NS_FAILED(rv)) {
return rv;
}
}
nsHTMLContainerFrame::CreateViewForFrame(scrollFrame, aBuildCombobox);
if (aBuildCombobox) {
// Give the drop-down list a popup widget
nsIView* view = scrollFrame->GetView();
NS_ASSERTION(view, "We asked for a view but didn't get one");
if (view) {
view->GetViewManager()->SetViewFloating(view, PR_TRUE);
nsWidgetInitData widgetData;
widgetData.mWindowType = eWindowType_popup;
widgetData.mBorderStyle = eBorderStyle_default;
#if defined(XP_MACOSX) || defined(XP_BEOS)
static NS_DEFINE_IID(kCPopUpCID, NS_POPUP_CID);
view->CreateWidget(kCPopUpCID, &widgetData, nsnull);
#else
static NS_DEFINE_IID(kCChildCID, NS_CHILD_CID);
view->CreateWidget(kCChildCID, &widgetData, nsnull);
#endif
}
}
BuildScrollFrame(aState, aContent, aStyleContext, scrolledFrame,
geometricParent, scrollFrame);
if (aState.mFrameState && aState.mFrameManager) {
// Restore frame state for the scroll frame
aState.mFrameManager->RestoreFrameStateFor(scrollFrame, aState.mFrameState);
}
// Process children
nsFrameConstructorSaveState absoluteSaveState;
nsFrameItems childItems;
if (display->IsPositioned()) {
// The area frame becomes a container for child frames that are
// absolutely positioned
aState.PushAbsoluteContainingBlock(scrolledFrame, absoluteSaveState);
}
ProcessChildren(aState, aContent, aStyleContext, scrolledFrame, PR_FALSE,
childItems, PR_TRUE);
// Set the scrolled frame's initial child lists
scrolledFrame->SetInitialChildList(nsnull, childItems.childList);
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ConstructFieldSetFrame(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aStyleDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
nsIFrame* newFrame = NS_NewFieldSetFrame(mPresShell, styleContext);
if (NS_UNLIKELY(!newFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Initialize it
InitAndRestoreFrame(aState, content,
aState.GetGeometricParent(aStyleDisplay, aParentFrame),
nsnull, newFrame);
// See if we need to create a view, e.g. the frame is absolutely
// positioned
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
// Resolve style and initialize the frame
nsRefPtr<nsStyleContext> fieldsetContentStyle;
fieldsetContentStyle =
mPresShell->StyleSet()->ResolvePseudoStyleFor(content,
nsCSSAnonBoxes::fieldsetContent,
styleContext);
nsIFrame* blockFrame = NS_NewBlockFrame(mPresShell, fieldsetContentStyle,
NS_BLOCK_FLOAT_MGR |
NS_BLOCK_MARGIN_ROOT);
InitAndRestoreFrame(aState, content, newFrame, nsnull, blockFrame);
nsresult rv = aState.AddChild(newFrame, aFrameItems, content, styleContext,
aParentFrame);
if (NS_FAILED(rv)) {
return rv;
}
// Process children
nsFrameConstructorSaveState absoluteSaveState;
nsFrameItems childItems;
if (aStyleDisplay->IsPositioned()) {
// The area frame becomes a container for child frames that are
// absolutely positioned
// XXXbz this is probably wrong, and once arbitrary frames can be absolute
// containing blocks we should fix this..
aState.PushAbsoluteContainingBlock(blockFrame, absoluteSaveState);
}
ProcessChildren(aState, content, styleContext, blockFrame, PR_TRUE,
childItems, PR_TRUE);
nsIFrame * child = childItems.childList;
nsIFrame * previous = nsnull;
nsLegendFrame* legendFrame = nsnull;
while (nsnull != child) {
legendFrame = do_QueryFrame(child);
if (legendFrame) {
// We want the legend to be the first frame in the fieldset child list.
// That way the EventStateManager will do the right thing when tabbing
// from a selection point within the legend (bug 236071), which is
// used for implementing legend access keys (bug 81481).
// GetAdjustedParentFrame() below depends on this frame order.
if (nsnull != previous) {
previous->SetNextSibling(legendFrame->GetNextSibling());
} else {
childItems.childList = legendFrame->GetNextSibling();
}
legendFrame->SetNextSibling(blockFrame);
legendFrame->SetParent(newFrame);
break;
}
previous = child;
child = child->GetNextSibling();
}
// Set the scrolled frame's initial child lists
blockFrame->SetInitialChildList(nsnull, childItems.childList);
// Set the scroll frame's initial child list
newFrame->SetInitialChildList(nsnull, legendFrame ? legendFrame : blockFrame);
// our new frame returned is the top frame which is the list frame.
*aNewFrame = newFrame;
return NS_OK;
}
static nsIFrame*
FindAncestorWithGeneratedContentPseudo(nsIFrame* aFrame)
{
for (nsIFrame* f = aFrame->GetParent(); f; f = f->GetParent()) {
NS_ASSERTION(f->IsGeneratedContentFrame(),
"should not have exited generated content");
nsIAtom* pseudo = f->GetStyleContext()->GetPseudoType();
if (pseudo == nsCSSPseudoElements::before ||
pseudo == nsCSSPseudoElements::after)
return f;
}
return nsnull;
}
#define FCDATA_DECL(_flags, _func) \
{ _flags, { (FrameCreationFunc)_func } }
#define SIMPLE_FCDATA(_func) FCDATA_DECL(0, _func)
#define FULL_CTOR_FCDATA(_flags, _func) \
{ _flags | FCDATA_FUNC_IS_FULL_CTOR, { nsnull }, _func }
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindTextData(nsIFrame* aParentFrame)
{
#ifdef MOZ_SVG
if (aParentFrame && aParentFrame->IsFrameOfType(nsIFrame::eSVG)) {
nsIFrame *ancestorFrame =
nsSVGUtils::GetFirstNonAAncestorFrame(aParentFrame);
if (ancestorFrame) {
nsISVGTextContentMetrics* metrics = do_QueryFrame(ancestorFrame);
if (metrics) {
static const FrameConstructionData sSVGGlyphData =
SIMPLE_FCDATA(NS_NewSVGGlyphFrame);
return &sSVGGlyphData;
}
}
return nsnull;
}
#endif
static const FrameConstructionData sTextData =
FCDATA_DECL(FCDATA_IS_LINE_PARTICIPANT, NS_NewTextFrame);
return &sTextData;
}
nsresult
nsCSSFrameConstructor::ConstructTextFrame(const FrameConstructionData* aData,
nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsStyleContext* aStyleContext,
nsFrameItems& aFrameItems,
PRBool aPseudoParent)
{
NS_PRECONDITION(aData, "Must have frame construction data");
// process pending pseudo frames. whitespace doesn't have an effect.
if (!aPseudoParent && !aState.mPseudoFrames.IsEmpty() &&
!TextIsOnlyWhitespace(aContent))
ProcessPseudoFrames(aState, aFrameItems);
nsIFrame* newFrame = (*aData->mFunc.mCreationFunc)(mPresShell, aStyleContext);
if (NS_UNLIKELY(!newFrame))
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = InitAndRestoreFrame(aState, aContent, aParentFrame,
nsnull, newFrame);
if (NS_FAILED(rv)) {
newFrame->Destroy();
return rv;
}
// We never need to create a view for a text frame.
if (newFrame->IsGeneratedContentFrame()) {
nsAutoPtr<nsGenConInitializer> initializer;
initializer =
static_cast<nsGenConInitializer*>(
aContent->UnsetProperty(nsGkAtoms::genConInitializerProperty));
if (initializer) {
if (initializer->mNode->InitTextFrame(initializer->mList,
FindAncestorWithGeneratedContentPseudo(newFrame), newFrame)) {
(this->*(initializer->mDirtyAll))();
}
initializer->mNode.forget();
}
}
// Add the newly constructed frame to the flow
aFrameItems.AddChild(newFrame);
// Text frames don't go in the content->frame hash table, because
// they're anonymous. This keeps the hash table smaller
return rv;
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindDataByInt(PRInt32 aInt,
nsIContent* aContent,
nsStyleContext* aStyleContext,
const FrameConstructionDataByInt* aDataPtr,
PRUint32 aDataLength)
{
for (const FrameConstructionDataByInt *curData = aDataPtr,
*endData = aDataPtr + aDataLength;
curData != endData;
++curData) {
if (curData->mInt == aInt) {
const FrameConstructionData* data = &curData->mData;
if (data->mBits & FCDATA_FUNC_IS_DATA_GETTER) {
return data->mFunc.mDataGetter(aContent, aStyleContext);
}
return data;
}
}
return nsnull;
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindDataByTag(nsIAtom* aTag,
nsIContent* aContent,
nsStyleContext* aStyleContext,
const FrameConstructionDataByTag* aDataPtr,
PRUint32 aDataLength)
{
for (const FrameConstructionDataByTag *curData = aDataPtr,
*endData = aDataPtr + aDataLength;
curData != endData;
++curData) {
if (*curData->mTag == aTag) {
const FrameConstructionData* data = &curData->mData;
if (data->mBits & FCDATA_FUNC_IS_DATA_GETTER) {
return data->mFunc.mDataGetter(aContent, aStyleContext);
}
return data;
}
}
return nsnull;
}
#define SUPPRESS_FCDATA() FCDATA_DECL(FCDATA_SUPPRESS_FRAME, nsnull)
#define SIMPLE_INT_CREATE(_int, _func) { _int, SIMPLE_FCDATA(_func) }
#define SIMPLE_INT_CHAIN(_int, _func) \
{ _int, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) }
#define COMPLEX_INT_CREATE(_int, _func) \
{ _int, FULL_CTOR_FCDATA(0, _func) }
#define SIMPLE_TAG_CREATE(_tag, _func) \
{ &nsGkAtoms::_tag, SIMPLE_FCDATA(_func) }
#define SIMPLE_TAG_CHAIN(_tag, _func) \
{ &nsGkAtoms::_tag, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) }
#define COMPLEX_TAG_CREATE(_tag, _func) \
{ &nsGkAtoms::_tag, FULL_CTOR_FCDATA(0, _func) }
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindHTMLData(nsIContent* aContent,
nsIAtom* aTag,
PRInt32 aNameSpaceID,
nsIFrame* aParentFrame,
nsStyleContext* aStyleContext)
{
// Ignore the tag if it's not HTML content and if it doesn't extend (via XBL)
// a valid HTML namespace. This check must match the one in
// ShouldHaveFirstLineStyle.
if (!aContent->IsNodeOfType(nsINode::eHTML) &&
aNameSpaceID != kNameSpaceID_XHTML) {
return nsnull;
}
NS_ASSERTION(!aParentFrame ||
aParentFrame->GetStyleContext()->GetPseudoType() !=
nsCSSAnonBoxes::fieldsetContent ||
aParentFrame->GetParent()->GetType() == nsGkAtoms::fieldSetFrame,
"Unexpected parent for fieldset content anon box");
if (aTag == nsGkAtoms::legend &&
(!aParentFrame ||
(aParentFrame->GetType() != nsGkAtoms::fieldSetFrame &&
aParentFrame->GetStyleContext()->GetPseudoType() !=
nsCSSAnonBoxes::fieldsetContent))) {
// <legend> is only special inside fieldset frames
// XXXbz it would be nice if we could just decide this based on the parent
// tag, and hence just use a SIMPLE_TAG_CHAIN for legend below, but the
// fact that with XBL we could end up with this legend element in some
// totally weird insertion point makes that chancy, I think.
return nsnull;
}
static const FrameConstructionDataByTag sHTMLData[] = {
SIMPLE_TAG_CHAIN(img, nsCSSFrameConstructor::FindImgData),
SIMPLE_TAG_CHAIN(mozgeneratedcontentimage,
nsCSSFrameConstructor::FindImgData),
{ &nsGkAtoms::br,
FCDATA_DECL(FCDATA_SKIP_FRAMEMAP | FCDATA_IS_LINE_PARTICIPANT,
NS_NewBRFrame) },
SIMPLE_TAG_CREATE(wbr, NS_NewWBRFrame),
SIMPLE_TAG_CHAIN(input, nsCSSFrameConstructor::FindInputData),
SIMPLE_TAG_CREATE(textarea, NS_NewTextControlFrame),
COMPLEX_TAG_CREATE(select, &nsCSSFrameConstructor::ConstructSelectFrame),
SIMPLE_TAG_CHAIN(object, nsCSSFrameConstructor::FindObjectData),
SIMPLE_TAG_CHAIN(applet, nsCSSFrameConstructor::FindObjectData),
SIMPLE_TAG_CHAIN(embed, nsCSSFrameConstructor::FindObjectData),
COMPLEX_TAG_CREATE(fieldset,
&nsCSSFrameConstructor::ConstructFieldSetFrame),
SIMPLE_TAG_CREATE(legend, NS_NewLegendFrame),
SIMPLE_TAG_CREATE(frameset, NS_NewHTMLFramesetFrame),
SIMPLE_TAG_CREATE(iframe, NS_NewSubDocumentFrame),
SIMPLE_TAG_CREATE(spacer, NS_NewSpacerFrame),
COMPLEX_TAG_CREATE(button, &nsCSSFrameConstructor::ConstructButtonFrame),
SIMPLE_TAG_CREATE(canvas, NS_NewHTMLCanvasFrame),
#if defined(MOZ_MEDIA)
SIMPLE_TAG_CREATE(video, NS_NewHTMLVideoFrame),
SIMPLE_TAG_CREATE(audio, NS_NewHTMLVideoFrame),
#endif
SIMPLE_TAG_CREATE(isindex, NS_NewIsIndexFrame)
};
return FindDataByTag(aTag, aContent, aStyleContext, sHTMLData,
NS_ARRAY_LENGTH(sHTMLData));
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindImgData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
if (!nsImageFrame::ShouldCreateImageFrameFor(aContent, aStyleContext)) {
return nsnull;
}
static const FrameConstructionData sImgData = SIMPLE_FCDATA(NS_NewImageFrame);
return &sImgData;
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindImgControlData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
if (!nsImageFrame::ShouldCreateImageFrameFor(aContent, aStyleContext)) {
return nsnull;
}
static const FrameConstructionData sImgControlData =
SIMPLE_FCDATA(NS_NewImageControlFrame);
return &sImgControlData;
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindInputData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
static const FrameConstructionDataByInt sInputData[] = {
SIMPLE_INT_CREATE(NS_FORM_INPUT_CHECKBOX, NS_NewGfxCheckboxControlFrame),
SIMPLE_INT_CREATE(NS_FORM_INPUT_RADIO, NS_NewGfxRadioControlFrame),
SIMPLE_INT_CREATE(NS_FORM_INPUT_FILE, NS_NewFileControlFrame),
SIMPLE_INT_CHAIN(NS_FORM_INPUT_IMAGE,
nsCSSFrameConstructor::FindImgControlData),
SIMPLE_INT_CREATE(NS_FORM_INPUT_TEXT, NS_NewTextControlFrame),
SIMPLE_INT_CREATE(NS_FORM_INPUT_PASSWORD, NS_NewTextControlFrame),
COMPLEX_INT_CREATE(NS_FORM_INPUT_SUBMIT,
&nsCSSFrameConstructor::ConstructButtonFrame),
COMPLEX_INT_CREATE(NS_FORM_INPUT_RESET,
&nsCSSFrameConstructor::ConstructButtonFrame),
COMPLEX_INT_CREATE(NS_FORM_INPUT_BUTTON,
&nsCSSFrameConstructor::ConstructButtonFrame)
// Keeping hidden inputs out of here on purpose for so they get frames by
// display (in practice, none).
};
nsCOMPtr<nsIFormControl> control = do_QueryInterface(aContent);
NS_ASSERTION(control, "input doesn't implement nsIFormControl?");
return FindDataByInt(control->GetType(), aContent, aStyleContext,
sInputData, NS_ARRAY_LENGTH(sInputData));
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindObjectData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
// GetDisplayedType isn't necessarily nsIObjectLoadingContent::TYPE_NULL for
// cases when the object is broken/suppressed/etc (e.g. a broken image), but
// we want to treat those cases as TYPE_NULL
PRUint32 type;
if (aContent->IntrinsicState() &
(NS_EVENT_STATE_BROKEN | NS_EVENT_STATE_USERDISABLED |
NS_EVENT_STATE_SUPPRESSED)) {
type = nsIObjectLoadingContent::TYPE_NULL;
} else {
nsCOMPtr<nsIObjectLoadingContent> objContent(do_QueryInterface(aContent));
NS_ASSERTION(objContent,
"applet, embed and object must implement "
"nsIObjectLoadingContent!");
objContent->GetDisplayedType(&type);
}
static const FrameConstructionDataByInt sObjectData[] = {
SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_LOADING,
NS_NewEmptyFrame),
SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_PLUGIN,
NS_NewObjectFrame),
SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_IMAGE,
NS_NewImageFrame),
SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_DOCUMENT,
NS_NewSubDocumentFrame)
// Nothing for TYPE_NULL so we'll construct frames by display there
};
return FindDataByInt((PRInt32)type, aContent, aStyleContext,
sObjectData, NS_ARRAY_LENGTH(sObjectData));
}
nsresult
nsCSSFrameConstructor::ConstructFrameFromItemInternal(FrameConstructionItem& aItem,
nsFrameConstructorState& aState,
nsIFrame* aParentFrame,
nsFrameItems& aFrameItems,
PRBool aHasPseudoParent)
{
const FrameConstructionData* data = aItem.mFCData;
NS_ASSERTION(data, "Must have frame construction data");
PRUint32 bits = data->mBits;
NS_ASSERTION(!(bits & FCDATA_FUNC_IS_DATA_GETTER),
"Should have dealt with this inside the data finder");
// Some sets of bits are not compatible with each other
#define CHECK_ONLY_ONE_BIT(_bit1, _bit2) \
NS_ASSERTION(!(bits & _bit1) || !(bits & _bit2), \
"Only one of these bits should be set")
CHECK_ONLY_ONE_BIT(FCDATA_SKIP_FRAMEMAP, FCDATA_MAY_NEED_SCROLLFRAME);
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_FORCE_NULL_ABSPOS_CONTAINER);
#ifdef MOZ_MATHML
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_WRAP_KIDS_IN_BLOCKS);
#endif
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_MAY_NEED_SCROLLFRAME);
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_IS_POPUP);
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_SKIP_ABSPOS_PUSH);
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_FORCE_VIEW);
CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR,
FCDATA_DISALLOW_GENERATED_CONTENT);
CHECK_ONLY_ONE_BIT(FCDATA_MAY_NEED_SCROLLFRAME, FCDATA_FORCE_VIEW);
#undef CHECK_ONLY_ONE_BIT
// Process pseudo-frames now if this is not a table part.
if (!aHasPseudoParent && !aState.mPseudoFrames.IsEmpty() &&
!(bits & FCDATA_IS_TABLE_PART)) {
ProcessPseudoFrames(aState, aFrameItems);
}
nsStyleContext* const styleContext = aItem.mStyleContext;
const nsStyleDisplay* display = styleContext->GetStyleDisplay();
nsIFrame* newFrame;
if (bits & FCDATA_FUNC_IS_FULL_CTOR) {
nsresult rv =
(this->*(data->mFullConstructor))(aState, aItem, aParentFrame,
display, aFrameItems, &newFrame);
if (NS_FAILED(rv)) {
return rv;
}
} else {
nsIContent* const content = aItem.mContent;
newFrame =
(*data->mFunc.mCreationFunc)(mPresShell, styleContext);
if (!newFrame) {
return NS_ERROR_OUT_OF_MEMORY;
}
PRBool allowOutOfFlow = !(bits & FCDATA_DISALLOW_OUT_OF_FLOW);
PRBool isPopup = aItem.mIsPopup;
NS_ASSERTION(!isPopup ||
(aState.mPopupItems.containingBlock &&
aState.mPopupItems.containingBlock->GetType() ==
nsGkAtoms::popupSetFrame),
"Should have a containing block here!");
nsIFrame* geometricParent =
isPopup ? aState.mPopupItems.containingBlock :
(allowOutOfFlow ? aState.GetGeometricParent(display, aParentFrame)
: aParentFrame);
nsresult rv = NS_OK;
// Must init frameToAddToList to null, since it's inout
nsIFrame* frameToAddToList = nsnull;
if ((bits & FCDATA_MAY_NEED_SCROLLFRAME) &&
display->IsScrollableOverflow()) {
BuildScrollFrame(aState, content, styleContext, newFrame,
geometricParent, frameToAddToList);
// No need to add to frame map later, since BuildScrollFrame did it
// already
bits |= FCDATA_SKIP_FRAMEMAP;
} else {
rv = InitAndRestoreFrame(aState, content, geometricParent, nsnull,
newFrame);
NS_ASSERTION(NS_SUCCEEDED(rv), "InitAndRestoreFrame failed");
// See whether we need to create a view
nsHTMLContainerFrame::CreateViewForFrame(newFrame,
(bits & FCDATA_FORCE_VIEW) != 0);
frameToAddToList = newFrame;
}
rv = aState.AddChild(frameToAddToList, aFrameItems, content, styleContext,
aParentFrame, allowOutOfFlow, allowOutOfFlow, isPopup);
if (NS_FAILED(rv)) {
return rv;
}
#ifdef MOZ_XUL
// Icky XUL stuff, sadly
if (aItem.mIsRootPopupgroup) {
NS_ASSERTION(nsIRootBox::GetRootBox(mPresShell) &&
nsIRootBox::GetRootBox(mPresShell)->GetPopupSetFrame() ==
newFrame,
"Unexpected PopupSetFrame");
aState.mPopupItems.containingBlock = newFrame;
aState.mHavePendingPopupgroup = PR_FALSE;
}
#endif /* MOZ_XUL */
// Process the child content if requested
nsFrameItems childItems;
nsFrameConstructorSaveState absoluteSaveState;
if (bits & FCDATA_FORCE_NULL_ABSPOS_CONTAINER) {
aState.PushAbsoluteContainingBlock(nsnull, absoluteSaveState);
} else if (!(bits & FCDATA_SKIP_ABSPOS_PUSH) && display->IsPositioned()) {
aState.PushAbsoluteContainingBlock(newFrame, absoluteSaveState);
}
// Process the child frames. Don't allow block styles; anything that's a
// special HTML or MathML or XUL frame but wants those should do its own
// ProcessChildren.
rv = ProcessChildren(aState, content, styleContext, newFrame,
!(bits & FCDATA_DISALLOW_GENERATED_CONTENT),
childItems, PR_FALSE);
#ifdef MOZ_XUL
// More icky XUL stuff
if (aItem.mNameSpaceID == kNameSpaceID_XUL &&
(aItem.mTag == nsGkAtoms::treechildren || // trees always need titletips
content->HasAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext) ||
content->HasAttr(kNameSpaceID_None, nsGkAtoms::tooltip))) {
nsIRootBox* rootBox = nsIRootBox::GetRootBox(mPresShell);
if (rootBox) {
rootBox->AddTooltipSupport(content);
}
}
#endif
#ifdef MOZ_MATHML
if (NS_SUCCEEDED(rv) && (bits & FCDATA_WRAP_KIDS_IN_BLOCKS)) {
nsFrameItems newItems;
nsFrameItems currentBlock;
nsIFrame* f;
while ((f = childItems.childList) != nsnull) {
PRBool wrapFrame = IsInlineFrame(f) || IsFrameSpecial(f);
if (!wrapFrame) {
rv = FlushAccumulatedBlock(aState, content, newFrame, &currentBlock, &newItems);
if (NS_FAILED(rv))
break;
}
childItems.RemoveChild(f, nsnull);
if (wrapFrame) {
currentBlock.AddChild(f);
} else {
newItems.AddChild(f);
}
}
rv = FlushAccumulatedBlock(aState, content, newFrame, &currentBlock, &newItems);
if (childItems.childList) {
// an error must have occurred, delete unprocessed frames
CleanupFrameReferences(aState.mFrameManager, childItems.childList);
nsFrameList(childItems.childList).DestroyFrames();
}
childItems = newItems;
}
#endif
// Set the frame's initial child list
// Note that MathML depends on this being called even if
// childItems.childList is null!
newFrame->SetInitialChildList(nsnull, childItems.childList);
}
NS_ASSERTION(newFrame->IsFrameOfType(nsIFrame::eLineParticipant) ==
((bits & FCDATA_IS_LINE_PARTICIPANT) != 0),
"Incorrectly set FCDATA_IS_LINE_PARTICIPANT bits");
if (!(bits & FCDATA_SKIP_FRAMEMAP)) {
aState.mFrameManager->SetPrimaryFrameFor(aItem.mContent, newFrame);
}
return NS_OK;
}
// after the node has been constructed and initialized create any
// anonymous content a node needs.
nsresult
nsCSSFrameConstructor::CreateAnonymousFrames(nsFrameConstructorState& aState,
nsIContent* aParent,
nsIFrame* aParentFrame,
nsFrameItems& aChildItems)
{
nsAutoTArray<nsIContent*, 4> newAnonymousItems;
nsresult rv = GetAnonymousContent(aParent, aParentFrame, newAnonymousItems);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 count = newAnonymousItems.Length();
if (count == 0) {
return NS_OK;
}
nsIAnonymousContentCreator* creator = do_QueryFrame(aParentFrame);
NS_ASSERTION(creator,
"How can that happen if we have nodes to construct frames for?");
// save the incoming pseudo frame state, so that we don't end up
// with those pseudoframes in aChildItems
nsPseudoFrames priorPseudoFrames;
aState.mPseudoFrames.Reset(&priorPseudoFrames);
for (PRUint32 i=0; i < count; i++) {
nsIContent* content = newAnonymousItems[i];
NS_ASSERTION(content, "null anonymous content?");
nsIFrame* newFrame = creator->CreateFrameFor(content);
if (newFrame) {
aChildItems.AddChild(newFrame);
}
else {
// create the frame and attach it to our frame
ConstructFrame(aState, content, aParentFrame, aChildItems);
}
}
// process the current pseudo frame state
if (!aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aChildItems);
}
// restore the incoming pseudo frame state
aState.mPseudoFrames = priorPseudoFrames;
return NS_OK;
}
nsresult
nsCSSFrameConstructor::GetAnonymousContent(nsIContent* aParent,
nsIFrame* aParentFrame,
nsTArray<nsIContent*>& aContent)
{
nsIAnonymousContentCreator* creator = do_QueryFrame(aParentFrame);
if (!creator)
return NS_OK;
nsresult rv = creator->CreateAnonymousContent(aContent);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 count = aContent.Length();
for (PRUint32 i=0; i < count; i++) {
// get our child's content and set its parent to our content
nsIContent* content = aContent[i];
NS_ASSERTION(content, "null anonymous content?");
#ifdef MOZ_SVG
// least-surprise CSS binding until we do the SVG specified
// cascading rules for <svg:use> - bug 265894
if (aParent &&
aParent->NodeInfo()->Equals(nsGkAtoms::use, kNameSpaceID_SVG)) {
content->SetFlags(NODE_IS_ANONYMOUS);
} else
#endif
{
content->SetNativeAnonymous();
}
rv = content->BindToTree(mDocument, aParent, aParent, PR_TRUE);
if (NS_FAILED(rv)) {
content->UnbindFromTree();
return rv;
}
}
return NS_OK;
}
static
PRBool IsXULDisplayType(const nsStyleDisplay* aDisplay)
{
return (aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_BOX ||
#ifdef MOZ_XUL
aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_GRID ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_STACK ||
#endif
aDisplay->mDisplay == NS_STYLE_DISPLAY_BOX
#ifdef MOZ_XUL
|| aDisplay->mDisplay == NS_STYLE_DISPLAY_GRID ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_STACK ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_GRID_GROUP ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_GRID_LINE ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_DECK ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_POPUP ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_GROUPBOX
#endif
);
}
// XUL frames are not allowed to be out of flow.
#define SIMPLE_XUL_FCDATA(_func) \
FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH, \
_func)
#define SCROLLABLE_XUL_FCDATA(_func) \
FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH | \
FCDATA_MAY_NEED_SCROLLFRAME, _func)
#define SIMPLE_XUL_CREATE(_tag, _func) \
{ &nsGkAtoms::_tag, SIMPLE_XUL_FCDATA(_func) }
#define SCROLLABLE_XUL_CREATE(_tag, _func) \
{ &nsGkAtoms::_tag, SCROLLABLE_XUL_FCDATA(_func) }
#define SIMPLE_XUL_INT_CREATE(_int, _func) \
{ _int, SIMPLE_XUL_FCDATA(_func) }
#define SCROLLABLE_XUL_INT_CREATE(_int, _func) \
{ _int, SCROLLABLE_XUL_FCDATA(_func) }
static
nsIFrame* NS_NewGridBoxFrame(nsIPresShell* aPresShell,
nsStyleContext* aStyleContext)
{
nsCOMPtr<nsIBoxLayout> layout;
NS_NewGridLayout2(aPresShell, getter_AddRefs(layout));
if (!layout) {
return nsnull;
}
return NS_NewBoxFrame(aPresShell, aStyleContext, PR_FALSE, layout);
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULTagData(nsIContent* aContent,
nsIAtom* aTag,
PRInt32 aNameSpaceID,
nsStyleContext* aStyleContext)
{
if (aNameSpaceID != kNameSpaceID_XUL) {
return nsnull;
}
static const FrameConstructionDataByTag sXULTagData[] = {
#ifdef MOZ_XUL
SCROLLABLE_XUL_CREATE(button, NS_NewButtonBoxFrame),
SCROLLABLE_XUL_CREATE(checkbox, NS_NewButtonBoxFrame),
SCROLLABLE_XUL_CREATE(radio, NS_NewButtonBoxFrame),
SCROLLABLE_XUL_CREATE(autorepeatbutton, NS_NewAutoRepeatBoxFrame),
SCROLLABLE_XUL_CREATE(titlebar, NS_NewTitleBarFrame),
SCROLLABLE_XUL_CREATE(resizer, NS_NewResizerFrame),
SIMPLE_XUL_CREATE(image, NS_NewImageBoxFrame),
SIMPLE_XUL_CREATE(spring, NS_NewLeafBoxFrame),
SIMPLE_XUL_CREATE(spacer, NS_NewLeafBoxFrame),
SIMPLE_XUL_CREATE(treechildren, NS_NewTreeBodyFrame),
SIMPLE_XUL_CREATE(treecol, NS_NewTreeColFrame),
SIMPLE_XUL_CREATE(text, NS_NewTextBoxFrame),
SIMPLE_TAG_CHAIN(label, nsCSSFrameConstructor::FindXULLabelData),
SIMPLE_TAG_CHAIN(description, nsCSSFrameConstructor::FindXULDescriptionData),
SIMPLE_XUL_CREATE(menu, NS_NewMenuFrame),
SIMPLE_XUL_CREATE(menubutton, NS_NewMenuFrame),
SIMPLE_XUL_CREATE(menuitem, NS_NewMenuItemFrame),
#ifdef XP_MACOSX
SIMPLE_TAG_CHAIN(menubar, nsCSSFrameConstructor::FindXULMenubarData),
#else
SIMPLE_XUL_CREATE(menubar, NS_NewMenuBarFrame),
#endif /* XP_MACOSX */
SIMPLE_TAG_CHAIN(popupgroup, nsCSSFrameConstructor::FindPopupGroupData),
SIMPLE_XUL_CREATE(iframe, NS_NewSubDocumentFrame),
SIMPLE_XUL_CREATE(editor, NS_NewSubDocumentFrame),
SIMPLE_XUL_CREATE(browser, NS_NewSubDocumentFrame),
SIMPLE_XUL_CREATE(progressmeter, NS_NewProgressMeterFrame),
SIMPLE_XUL_CREATE(splitter, NS_NewSplitterFrame),
SIMPLE_TAG_CHAIN(listboxbody,
nsCSSFrameConstructor::FindXULListBoxBodyData),
SIMPLE_TAG_CHAIN(listitem, nsCSSFrameConstructor::FindXULListItemData),
#endif /* MOZ_XUL */
SIMPLE_XUL_CREATE(slider, NS_NewSliderFrame),
SIMPLE_XUL_CREATE(scrollbar, NS_NewScrollbarFrame),
SIMPLE_XUL_CREATE(scrollbarbutton, NS_NewScrollbarButtonFrame)
};
return FindDataByTag(aTag, aContent, aStyleContext, sXULTagData,
NS_ARRAY_LENGTH(sXULTagData));
}
#ifdef MOZ_XUL
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindPopupGroupData(nsIContent* aContent,
nsStyleContext* /* unused */)
{
if (!aContent->IsRootOfNativeAnonymousSubtree()) {
return nsnull;
}
static const FrameConstructionData sPopupSetData =
SIMPLE_XUL_FCDATA(NS_NewPopupSetFrame);
return &sPopupSetData;
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData
nsCSSFrameConstructor::sXULTextBoxData = SIMPLE_XUL_FCDATA(NS_NewTextBoxFrame);
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULLabelData(nsIContent* aContent,
nsStyleContext* /* unused */)
{
if (aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::value)) {
return &sXULTextBoxData;
}
static const FrameConstructionData sLabelData =
SIMPLE_XUL_FCDATA(NS_NewXULLabelFrame);
return &sLabelData;
}
static nsIFrame*
NS_NewXULDescriptionFrame(nsIPresShell* aPresShell, nsStyleContext *aContext)
{
// XXXbz do we really need to set those flags? If the parent is not
// a block we'll get them anyway, and if it is, do we want them?
return NS_NewBlockFrame(aPresShell, aContext,
NS_BLOCK_FLOAT_MGR | NS_BLOCK_MARGIN_ROOT);
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULDescriptionData(nsIContent* aContent,
nsStyleContext* /* unused */)
{
if (aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::value)) {
return &sXULTextBoxData;
}
static const FrameConstructionData sDescriptionData =
SIMPLE_XUL_FCDATA(NS_NewXULDescriptionFrame);
return &sDescriptionData;
}
#ifdef XP_MACOSX
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULMenubarData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
nsCOMPtr<nsISupports> container =
aStyleContext->PresContext()->GetContainer();
if (container) {
nsCOMPtr<nsIDocShellTreeItem> treeItem(do_QueryInterface(container));
if (treeItem) {
PRInt32 type;
treeItem->GetItemType(&type);
if (nsIDocShellTreeItem::typeChrome == type) {
nsCOMPtr<nsIDocShellTreeItem> parent;
treeItem->GetParent(getter_AddRefs(parent));
if (!parent) {
// This is the root. Suppress the menubar, since on Mac
// window menus are not attached to the window.
static const FrameConstructionData sSuppressData = SUPPRESS_FCDATA();
return &sSuppressData;
}
}
}
}
static const FrameConstructionData sMenubarData =
SIMPLE_XUL_FCDATA(NS_NewMenuBarFrame);
return &sMenubarData;
}
#endif /* XP_MACOSX */
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULListBoxBodyData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
if (aStyleContext->GetStyleDisplay()->mDisplay !=
NS_STYLE_DISPLAY_GRID_GROUP) {
return nsnull;
}
static const FrameConstructionData sListBoxBodyData =
SCROLLABLE_XUL_FCDATA(NS_NewListBoxBodyFrame);
return &sListBoxBodyData;
}
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULListItemData(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
if (aStyleContext->GetStyleDisplay()->mDisplay !=
NS_STYLE_DISPLAY_GRID_LINE) {
return nsnull;
}
static const FrameConstructionData sListItemData =
SCROLLABLE_XUL_FCDATA(NS_NewListItemFrame);
return &sListItemData;
}
#endif /* MOZ_XUL */
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindXULDisplayData(const nsStyleDisplay* aDisplay,
nsIContent* aContent,
nsStyleContext* aStyleContext)
{
static const FrameConstructionDataByInt sXULDisplayData[] = {
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_INLINE_BOX, NS_NewBoxFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_BOX, NS_NewBoxFrame),
#ifdef MOZ_XUL
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_INLINE_GRID, NS_NewGridBoxFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_GRID, NS_NewGridBoxFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_GRID_GROUP,
NS_NewGridRowGroupFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_GRID_LINE,
NS_NewGridRowLeafFrame),
SIMPLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_DECK, NS_NewDeckFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_GROUPBOX, NS_NewGroupBoxFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_INLINE_STACK, NS_NewStackFrame),
SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_STACK, NS_NewStackFrame),
{ NS_STYLE_DISPLAY_POPUP,
FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_IS_POPUP |
FCDATA_SKIP_ABSPOS_PUSH, NS_NewMenuPopupFrame) }
#endif /* MOZ_XUL */
};
// Processing by display here:
return FindDataByInt(aDisplay->mDisplay, aContent, aStyleContext,
sXULDisplayData, NS_ARRAY_LENGTH(sXULDisplayData));
}
nsresult
nsCSSFrameConstructor::AddLazyChildren(nsIContent* aContent,
nsLazyFrameConstructionCallback* aCallback,
void* aArg, PRBool aIsSynch)
{
nsCOMPtr<nsIRunnable> event =
new LazyGenerateChildrenEvent(aContent, mPresShell, aCallback, aArg);
return aIsSynch ? event->Run() :
NS_DispatchToCurrentThread(event);
}
already_AddRefed<nsStyleContext>
nsCSSFrameConstructor::BeginBuildingScrollFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsStyleContext* aContentStyle,
nsIFrame* aParentFrame,
nsIAtom* aScrolledPseudo,
PRBool aIsRoot,
nsIFrame*& aNewFrame)
{
nsIFrame* gfxScrollFrame = aNewFrame;
nsFrameItems anonymousItems;
nsRefPtr<nsStyleContext> contentStyle = aContentStyle;
if (!gfxScrollFrame) {
// Build a XULScrollFrame when the child is a box, otherwise an
// HTMLScrollFrame
// XXXbz this is the lone remaining consumer of IsXULDisplayType.
// I wonder whether we can eliminate that somehow.
if (IsXULDisplayType(aContentStyle->GetStyleDisplay())) {
gfxScrollFrame = NS_NewXULScrollFrame(mPresShell, contentStyle, aIsRoot);
} else {
gfxScrollFrame = NS_NewHTMLScrollFrame(mPresShell, contentStyle, aIsRoot);
}
InitAndRestoreFrame(aState, aContent, aParentFrame, nsnull, gfxScrollFrame);
// Create a view
nsHTMLContainerFrame::CreateViewForFrame(gfxScrollFrame, PR_FALSE);
}
// if there are any anonymous children for the scroll frame, create
// frames for them.
CreateAnonymousFrames(aState, aContent, gfxScrollFrame, anonymousItems);
aNewFrame = gfxScrollFrame;
// we used the style that was passed in. So resolve another one.
nsStyleSet *styleSet = mPresShell->StyleSet();
nsStyleContext* aScrolledChildStyle = styleSet->ResolvePseudoStyleFor(aContent,
aScrolledPseudo,
contentStyle).get();
if (gfxScrollFrame) {
gfxScrollFrame->SetInitialChildList(nsnull, anonymousItems.childList);
}
return aScrolledChildStyle;
}
void
nsCSSFrameConstructor::FinishBuildingScrollFrame(nsIFrame* aScrollFrame,
nsIFrame* aScrolledFrame)
{
aScrollFrame->AppendFrames(nsnull, aScrolledFrame);
// force the scrolled frame to have a view. The view will be parented to
// the correct anonymous inner view because the scrollframes override
// nsIFrame::GetParentViewForChildFrame.
nsHTMLContainerFrame::CreateViewForFrame(aScrolledFrame, PR_TRUE);
// XXXbz what's the point of the code after this in this method?
nsIView* view = aScrolledFrame->GetView();
if (!view)
return;
}
/**
* Called to wrap a gfx scrollframe around a frame. The hierarchy will look like this
*
* ------- for gfx scrollbars ------
*
*
* ScrollFrame
* ^
* |
* Frame (scrolled frame you passed in)
*
*
*-----------------------------------
* LEGEND:
*
* ScrollFrame: This is a frame that manages gfx cross platform frame based scrollbars.
*
* @param aContent the content node of the child to wrap.
* @param aScrolledFrame The frame of the content to wrap. This should not be
* Initialized. This method will initialize it with a scrolled pseudo
* and no nsIContent. The content will be attached to the scrollframe
* returned.
* @param aContentStyle the style context that has already been resolved for the content being passed in.
*
* @param aParentFrame The parent to attach the scroll frame to
*
* @param aNewFrame The new scrollframe or gfx scrollframe that we create. It will contain the
* scrolled frame you passed in. (returned)
* If this is not null, we'll just use it
* @param aScrolledContentStyle the style that was resolved for the scrolled frame. (returned)
*/
nsresult
nsCSSFrameConstructor::BuildScrollFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsStyleContext* aContentStyle,
nsIFrame* aScrolledFrame,
nsIFrame* aParentFrame,
nsIFrame*& aNewFrame)
{
nsRefPtr<nsStyleContext> scrolledContentStyle =
BeginBuildingScrollFrame(aState, aContent, aContentStyle, aParentFrame,
nsCSSAnonBoxes::scrolledContent,
PR_FALSE, aNewFrame);
aScrolledFrame->SetStyleContextWithoutNotification(scrolledContentStyle);
InitAndRestoreFrame(aState, aContent, aNewFrame, nsnull, aScrolledFrame);
FinishBuildingScrollFrame(aNewFrame, aScrolledFrame);
// now set the primary frame to the ScrollFrame
aState.mFrameManager->SetPrimaryFrameFor( aContent, aNewFrame );
return NS_OK;
}
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindDisplayData(const nsStyleDisplay* aDisplay,
nsIContent* aContent)
{
// The style system ensures that floated and positioned frames are
// block-level.
NS_ASSERTION(!(aDisplay->IsFloating() ||
aDisplay->IsAbsolutelyPositioned()) ||
aDisplay->IsBlockOutside(),
"Style system did not apply CSS2.1 section 9.7 fixups");
// If this is "body", try propagating its scroll style to the viewport
// Note that we need to do this even if the body is NOT scrollable;
// it might have dynamically changed from scrollable to not scrollable,
// and that might need to be propagated.
// XXXbz is this the right place to do this? If this code moves,
// make this function static.
PRBool propagatedScrollToViewport = PR_FALSE;
if (aContent->NodeInfo()->Equals(nsGkAtoms::body) &&
aContent->IsNodeOfType(nsINode::eHTML)) {
propagatedScrollToViewport =
PropagateScrollToViewport() == aContent;
}
// If the frame is a block-level frame and is scrollable, then wrap it
// in a scroll frame.
// XXX Ignore tables for the time being
// XXXbz it would be nice to combine this with the other block
// case... Think about how do do this?
if (aDisplay->IsBlockInside() &&
aDisplay->IsScrollableOverflow() &&
!propagatedScrollToViewport) {
static const FrameConstructionData sScrollableBlockData =
FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructScrollableBlock);
return &sScrollableBlockData;
}
// Handle various non-scrollable blocks
if (aDisplay->IsBlockInside() ||
NS_STYLE_DISPLAY_RUN_IN == aDisplay->mDisplay ||
NS_STYLE_DISPLAY_COMPACT == aDisplay->mDisplay) {
static const FrameConstructionData sNonScrollableBlockData =
FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructNonScrollableBlock);
return &sNonScrollableBlockData;
}
// Handle various inlines
if (NS_STYLE_DISPLAY_INLINE == aDisplay->mDisplay ||
NS_STYLE_DISPLAY_MARKER == aDisplay->mDisplay) {
// To keep the hash table small don't add inline frames (they're
// typically things like FONT and B), because we can quickly
// find them if we need to.
// XXXbz the "quickly" part is a bald-faced lie!
static const FrameConstructionData sInlineData =
FULL_CTOR_FCDATA(FCDATA_SKIP_FRAMEMAP | FCDATA_IS_INLINE |
FCDATA_IS_LINE_PARTICIPANT,
&nsCSSFrameConstructor::ConstructInline);
return &sInlineData;
}
if (NS_STYLE_DISPLAY_TABLE == aDisplay->mDisplay ||
NS_STYLE_DISPLAY_INLINE_TABLE == aDisplay->mDisplay) {
static const FrameConstructionData sTableData =
FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructTable);
return &sTableData;
}
static const FrameConstructionData sTablePartData =
FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | FCDATA_SKIP_FRAMEMAP,
&nsCSSFrameConstructor::ConstructTablePart);
return &sTablePartData;
}
nsresult
nsCSSFrameConstructor::ConstructScrollableBlock(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
*aNewFrame = nsnull;
nsRefPtr<nsStyleContext> scrolledContentStyle
= BeginBuildingScrollFrame(aState, content, styleContext,
aState.GetGeometricParent(aDisplay, aParentFrame),
nsCSSAnonBoxes::scrolledContent,
PR_FALSE, *aNewFrame);
// Create our block frame
// pass a temporary stylecontext, the correct one will be set later
nsIFrame* scrolledFrame =
NS_NewBlockFormattingContext(mPresShell, styleContext);
nsFrameItems blockItem;
nsresult rv = ConstructBlock(aState,
scrolledContentStyle->GetStyleDisplay(), content,
*aNewFrame, *aNewFrame, scrolledContentStyle,
&scrolledFrame, blockItem, aDisplay->IsPositioned());
if (NS_UNLIKELY(NS_FAILED(rv))) {
// XXXbz any cleanup needed here?
return rv;
}
NS_ASSERTION(blockItem.childList == scrolledFrame,
"Scrollframe's frameItems should be exactly the scrolled frame");
FinishBuildingScrollFrame(*aNewFrame, scrolledFrame);
rv = aState.AddChild(*aNewFrame, aFrameItems, content, styleContext,
aParentFrame);
return rv;
}
nsresult
nsCSSFrameConstructor::ConstructNonScrollableBlock(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsStyleContext* const styleContext = aItem.mStyleContext;
if (aDisplay->IsAbsolutelyPositioned() ||
aDisplay->IsFloating() ||
NS_STYLE_DISPLAY_INLINE_BLOCK == aDisplay->mDisplay) {
*aNewFrame = NS_NewBlockFormattingContext(mPresShell, styleContext);
} else {
*aNewFrame = NS_NewBlockFrame(mPresShell, styleContext);
}
return ConstructBlock(aState, aDisplay, aItem.mContent,
aState.GetGeometricParent(aDisplay, aParentFrame),
aParentFrame, styleContext, aNewFrame,
aFrameItems, aDisplay->IsPositioned());
}
nsresult
nsCSSFrameConstructor::ConstructTable(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
NS_PRECONDITION(aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE ||
aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_TABLE,
"Unexpected call");
nsIFrame* innerTable;
return ConstructTableFrame(aState, aItem.mContent, aParentFrame,
aItem.mStyleContext, aItem.mNameSpaceID,
PR_FALSE, aFrameItems, *aNewFrame, innerTable);
}
nsresult
nsCSSFrameConstructor::ConstructTablePart(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
PRInt32 namespaceID = aItem.mNameSpaceID;
nsresult rv = NS_ERROR_UNEXPECTED;
PRBool hasPseudoParent;
// Use the 'display' property to choose a frame type
switch (aDisplay->mDisplay) {
case NS_STYLE_DISPLAY_TABLE_CAPTION:
{
// aParentFrame may be an inner table frame rather than an outer frame
// In this case we need to get the outer frame.
nsIFrame* parentFrame = AdjustCaptionParentFrame(aParentFrame);
rv = ConstructTableCaptionFrame(aState, content, parentFrame,
styleContext, namespaceID, aFrameItems,
*aNewFrame, &hasPseudoParent);
break;
}
case NS_STYLE_DISPLAY_TABLE_ROW_GROUP:
case NS_STYLE_DISPLAY_TABLE_HEADER_GROUP:
case NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP:
rv = ConstructTableRowGroupFrame(aState, content, aParentFrame,
styleContext, namespaceID, PR_FALSE,
aFrameItems, *aNewFrame, &hasPseudoParent);
break;
case NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP:
rv = ConstructTableColGroupFrame(aState, content, aParentFrame,
styleContext, namespaceID,
PR_FALSE, aFrameItems, *aNewFrame,
&hasPseudoParent);
break;
case NS_STYLE_DISPLAY_TABLE_COLUMN:
rv = ConstructTableColFrame(aState, content, aParentFrame,
styleContext, namespaceID, PR_FALSE,
aFrameItems, *aNewFrame, &hasPseudoParent);
break;
case NS_STYLE_DISPLAY_TABLE_ROW:
rv = ConstructTableRowFrame(aState, content, aParentFrame,
styleContext, namespaceID, PR_FALSE,
aFrameItems, *aNewFrame, &hasPseudoParent);
break;
case NS_STYLE_DISPLAY_TABLE_CELL:
{
nsIFrame* innerTable;
rv = ConstructTableCellFrame(aState, content, aParentFrame,
styleContext, namespaceID,
PR_FALSE, aFrameItems, *aNewFrame,
innerTable, &hasPseudoParent);
break;
}
default:
NS_NOTREACHED("How did we get here?");
break;
}
if (NS_SUCCEEDED(rv) && !hasPseudoParent) {
aFrameItems.AddChild(*aNewFrame);
}
return rv;
}
nsresult
nsCSSFrameConstructor::InitAndRestoreFrame(const nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsIFrame* aPrevInFlow,
nsIFrame* aNewFrame,
PRBool aAllowCounters)
{
NS_PRECONDITION(mUpdateCount != 0,
"Should be in an update while creating frames");
nsresult rv = NS_OK;
NS_ASSERTION(aNewFrame, "Null frame cannot be initialized");
if (!aNewFrame)
return NS_ERROR_NULL_POINTER;
// Initialize the frame
rv = aNewFrame->Init(aContent, aParentFrame, aPrevInFlow);
aNewFrame->AddStateBits(aState.mAdditionalStateBits);
if (aState.mFrameState && aState.mFrameManager) {
// Restore frame state for just the newly created frame.
aState.mFrameManager->RestoreFrameStateFor(aNewFrame, aState.mFrameState);
}
if (aAllowCounters && !aPrevInFlow &&
mCounterManager.AddCounterResetsAndIncrements(aNewFrame)) {
CountersDirty();
}
return rv;
}
already_AddRefed<nsStyleContext>
nsCSSFrameConstructor::ResolveStyleContext(nsIFrame* aParentFrame,
nsIContent* aContent)
{
nsStyleContext* parentStyleContext = nsnull;
if (aContent->GetParent()) {
aParentFrame = nsFrame::CorrectStyleParentFrame(aParentFrame, nsnull);
if (aParentFrame) {
// Resolve the style context based on the content object and the parent
// style context
parentStyleContext = aParentFrame->GetStyleContext();
} else {
// Perhaps aParentFrame is a canvasFrame and we're replicating
// fixed-pos frames.
// XXX should we create a way to tell ConstructFrame which style
// context to use, and pass it the style context for the
// previous page's fixed-pos frame?
}
} else {
// This has got to be a call from ConstructDocElementTableFrame.
// Not sure how best to assert that here.
}
return ResolveStyleContext(parentStyleContext, aContent);
}
already_AddRefed<nsStyleContext>
nsCSSFrameConstructor::ResolveStyleContext(nsStyleContext* aParentStyleContext,
nsIContent* aContent)
{
nsStyleSet *styleSet = mPresShell->StyleSet();
if (aContent->IsNodeOfType(nsINode::eELEMENT)) {
return styleSet->ResolveStyleFor(aContent, aParentStyleContext);
}
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
"shouldn't waste time creating style contexts for "
"comments and processing instructions");
return styleSet->ResolveStyleForNonElement(aParentStyleContext);
}
// MathML Mod - RBS
#ifdef MOZ_MATHML
nsresult
nsCSSFrameConstructor::FlushAccumulatedBlock(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsFrameItems* aBlockItems,
nsFrameItems* aNewItems)
{
if (!aBlockItems->childList) {
// Nothing to do
return NS_OK;
}
nsStyleContext* parentContext =
nsFrame::CorrectStyleParentFrame(aParentFrame,
nsCSSAnonBoxes::mozMathMLAnonymousBlock)->GetStyleContext();
nsStyleSet *styleSet = mPresShell->StyleSet();
nsRefPtr<nsStyleContext> blockContext;
blockContext = styleSet->ResolvePseudoStyleFor(aContent,
nsCSSAnonBoxes::mozMathMLAnonymousBlock,
parentContext);
// then, create a block frame that will wrap the child frames. Make it a
// MathML frame so that Get(Absolute/Float)ContainingBlockFor know that this
// is not a suitable block.
nsIFrame* blockFrame = NS_NewMathMLmathBlockFrame(mPresShell, blockContext,
NS_BLOCK_FLOAT_MGR | NS_BLOCK_MARGIN_ROOT);
if (NS_UNLIKELY(!blockFrame))
return NS_ERROR_OUT_OF_MEMORY;
InitAndRestoreFrame(aState, aContent, aParentFrame, nsnull, blockFrame);
for (nsIFrame* f = aBlockItems->childList; f; f = f->GetNextSibling()) {
ReparentFrame(aState.mFrameManager, blockFrame, f);
}
// abs-pos and floats are disabled in MathML children so we don't have to
// worry about messing up those.
blockFrame->SetInitialChildList(nsnull, aBlockItems->childList);
*aBlockItems = nsFrameItems();
aNewItems->AddChild(blockFrame);
return NS_OK;
}
// Only <math> elements can be floated or positioned. All other MathML
// should be in-flow.
#define SIMPLE_MATHML_CREATE(_tag, _func) \
{ &nsGkAtoms::_tag, \
FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \
FCDATA_FORCE_NULL_ABSPOS_CONTAINER | \
FCDATA_WRAP_KIDS_IN_BLOCKS | \
FCDATA_SKIP_FRAMEMAP, _func) }
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindMathMLData(nsIContent* aContent,
nsIAtom* aTag,
PRInt32 aNameSpaceID,
nsStyleContext* aStyleContext)
{
// Make sure that we remain confined in the MathML world
if (aNameSpaceID != kNameSpaceID_MathML)
return nsnull;
// Handle <math> specially, because it sometimes produces inlines
if (aTag == nsGkAtoms::math) {
if (aStyleContext->GetStyleDisplay()->mDisplay == NS_STYLE_DISPLAY_BLOCK) {
static const FrameConstructionData sBlockMathData =
FCDATA_DECL(FCDATA_FORCE_NULL_ABSPOS_CONTAINER |
FCDATA_WRAP_KIDS_IN_BLOCKS |
FCDATA_SKIP_FRAMEMAP,
NS_CreateNewMathMLmathBlockFrame);
return &sBlockMathData;
}
static const FrameConstructionData sInlineMathData =
FCDATA_DECL(FCDATA_FORCE_NULL_ABSPOS_CONTAINER |
FCDATA_WRAP_KIDS_IN_BLOCKS |
FCDATA_SKIP_FRAMEMAP |
FCDATA_IS_LINE_PARTICIPANT,
NS_NewMathMLmathInlineFrame);
return &sInlineMathData;
}
static const FrameConstructionDataByTag sMathMLData[] = {
SIMPLE_MATHML_CREATE(mi_, NS_NewMathMLTokenFrame),
SIMPLE_MATHML_CREATE(mn_, NS_NewMathMLTokenFrame),
SIMPLE_MATHML_CREATE(ms_, NS_NewMathMLTokenFrame),
SIMPLE_MATHML_CREATE(mtext_, NS_NewMathMLTokenFrame),
SIMPLE_MATHML_CREATE(mo_, NS_NewMathMLmoFrame),
SIMPLE_MATHML_CREATE(mfrac_, NS_NewMathMLmfracFrame),
SIMPLE_MATHML_CREATE(msup_, NS_NewMathMLmsupFrame),
SIMPLE_MATHML_CREATE(msub_, NS_NewMathMLmsubFrame),
SIMPLE_MATHML_CREATE(msubsup_, NS_NewMathMLmsubsupFrame),
SIMPLE_MATHML_CREATE(munder_, NS_NewMathMLmunderFrame),
SIMPLE_MATHML_CREATE(mover_, NS_NewMathMLmoverFrame),
SIMPLE_MATHML_CREATE(munderover_, NS_NewMathMLmunderoverFrame),
SIMPLE_MATHML_CREATE(mphantom_, NS_NewMathMLmphantomFrame),
SIMPLE_MATHML_CREATE(mpadded_, NS_NewMathMLmpaddedFrame),
SIMPLE_MATHML_CREATE(mspace_, NS_NewMathMLmspaceFrame),
SIMPLE_MATHML_CREATE(none, NS_NewMathMLmspaceFrame),
SIMPLE_MATHML_CREATE(mprescripts_, NS_NewMathMLmspaceFrame),
SIMPLE_MATHML_CREATE(mfenced_, NS_NewMathMLmfencedFrame),
SIMPLE_MATHML_CREATE(mmultiscripts_, NS_NewMathMLmmultiscriptsFrame),
SIMPLE_MATHML_CREATE(mstyle_, NS_NewMathMLmstyleFrame),
SIMPLE_MATHML_CREATE(msqrt_, NS_NewMathMLmsqrtFrame),
SIMPLE_MATHML_CREATE(mroot_, NS_NewMathMLmrootFrame),
SIMPLE_MATHML_CREATE(maction_, NS_NewMathMLmactionFrame),
SIMPLE_MATHML_CREATE(mrow_, NS_NewMathMLmrowFrame),
SIMPLE_MATHML_CREATE(merror_, NS_NewMathMLmrowFrame)
};
return FindDataByTag(aTag, aContent, aStyleContext, sMathMLData,
NS_ARRAY_LENGTH(sMathMLData));
}
#endif // MOZ_MATHML
#ifdef MOZ_SVG
// Only outer <svg> elements can be floated or positioned. All other SVG
// should be in-flow.
#define SIMPLE_SVG_FCDATA(_func) \
FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \
FCDATA_SKIP_ABSPOS_PUSH | FCDATA_SKIP_FRAMEMAP | \
FCDATA_DISALLOW_GENERATED_CONTENT, _func)
#define SIMPLE_SVG_CREATE(_tag, _func) \
{ &nsGkAtoms::_tag, SIMPLE_SVG_FCDATA(_func) }
/* static */
const nsCSSFrameConstructor::FrameConstructionData*
nsCSSFrameConstructor::FindSVGData(nsIContent* aContent,
nsIAtom* aTag,
PRInt32 aNameSpaceID,
nsIFrame* aParentFrame,
nsStyleContext* aStyleContext)
{
if (aNameSpaceID != kNameSpaceID_SVG || !NS_SVGEnabled()) {
return nsnull;
}
static const FrameConstructionData sSuppressData = SUPPRESS_FCDATA();
static const FrameConstructionData sGenericContainerData =
SIMPLE_SVG_FCDATA(NS_NewSVGGenericContainerFrame);
PRBool parentIsSVG = PR_FALSE;
nsIContent* parentContent =
aParentFrame ? aParentFrame->GetContent() : nsnull;
// XXXbz should this really be based on the XBL-resolved tag of the parent
// frame's content? Should it not be based on the type of the parent frame
// (e.g. whether it's an SVG frame)?
if (parentContent) {
PRInt32 parentNSID;
nsIAtom* parentTag =
parentContent->GetOwnerDoc()->BindingManager()->
ResolveTag(aParentFrame->GetContent(), &parentNSID);
// It's not clear whether the SVG spec intends to allow any SVG
// content within svg:foreignObject at all (SVG 1.1, section
// 23.2), but if it does, it better be svg:svg. So given that
// we're allowing it, treat it as a non-SVG parent.
parentIsSVG = parentNSID == kNameSpaceID_SVG &&
parentTag != nsGkAtoms::foreignObject;
}
if ((aTag != nsGkAtoms::svg && !parentIsSVG) ||
(aTag == nsGkAtoms::desc || aTag == nsGkAtoms::title)) {
// Sections 5.1 and G.4 of SVG 1.1 say that SVG elements other than
// svg:svg not contained within svg:svg are incorrect, although they
// don't seem to specify error handling. Ignore them, since many of
// our frame classes can't deal. It *may* be that the document
// should at that point be considered in error according to F.2, but
// it's hard to tell.
//
// Style mutation can't change this situation, so don't bother
// adding to the undisplayed content map.
// XXXbz except of course that this makes GetPrimaryFrameFor for this stuff
// that much slower.
//
// We don't currently handle any UI for desc/title
return &sSuppressData;
}
// Reduce the number of frames we create unnecessarily. Note that this is not
// where we select which frame in a <switch> to render! That happens in
// nsSVGSwitchFrame::PaintSVG.
if (!NS_SVG_PassesConditionalProcessingTests(aContent)) {
// Note that just returning is probably not right. According
// to the spec, <use> is allowed to use an element that fails its
// conditional, but because we never actually create the frame when
// a conditional fails and when we use GetReferencedFrame to find the
// references, things don't work right.
// XXX FIXME XXX
return &sSuppressData;
}
// Special case for aTag == nsGkAtoms::svg because we don't want to
// have to recompute parentIsSVG for it.
if (aTag == nsGkAtoms::svg) {
if (parentIsSVG) {
static const FrameConstructionData sInnerSVGData =
SIMPLE_SVG_FCDATA(NS_NewSVGInnerSVGFrame);
return &sInnerSVGData;
}
static const FrameConstructionData sOuterSVGData =
FCDATA_DECL(FCDATA_FORCE_VIEW | FCDATA_SKIP_ABSPOS_PUSH |
FCDATA_SKIP_FRAMEMAP | FCDATA_DISALLOW_GENERATED_CONTENT,
NS_NewSVGOuterSVGFrame);
return &sOuterSVGData;
}
// Special cases for text/tspan/textpath, because the kind of frame
// they get depends on the parent frame.
if (aTag == nsGkAtoms::text) {
NS_ASSERTION(aParentFrame, "Should have aParentFrame here");
nsIFrame *ancestorFrame =
nsSVGUtils::GetFirstNonAAncestorFrame(aParentFrame);
if (ancestorFrame) {
nsISVGTextContentMetrics* metrics = do_QueryFrame(ancestorFrame);
// Text cannot be nested
if (metrics) {
return &sGenericContainerData;
}
}
}
else if (aTag == nsGkAtoms::tspan) {
NS_ASSERTION(aParentFrame, "Should have aParentFrame here");
nsIFrame *ancestorFrame =
nsSVGUtils::GetFirstNonAAncestorFrame(aParentFrame);
if (ancestorFrame) {
nsISVGTextContentMetrics* metrics = do_QueryFrame(ancestorFrame);
if (!metrics) {
return &sGenericContainerData;
}
}
}
else if (aTag == nsGkAtoms::textPath) {
NS_ASSERTION(aParentFrame, "Should have aParentFrame here");
nsIFrame *ancestorFrame =
nsSVGUtils::GetFirstNonAAncestorFrame(aParentFrame);
if (!ancestorFrame ||
ancestorFrame->GetType() != nsGkAtoms::svgTextFrame) {
return &sGenericContainerData;
}
}
static const FrameConstructionDataByTag sSVGData[] = {
SIMPLE_SVG_CREATE(g, NS_NewSVGGFrame),
SIMPLE_SVG_CREATE(svgSwitch, NS_NewSVGSwitchFrame),
SIMPLE_SVG_CREATE(polygon, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(polyline, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(circle, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(ellipse, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(line, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(rect, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(path, NS_NewSVGPathGeometryFrame),
SIMPLE_SVG_CREATE(defs, NS_NewSVGContainerFrame),
{ &nsGkAtoms::foreignObject,
FULL_CTOR_FCDATA(FCDATA_DISALLOW_OUT_OF_FLOW,
&nsCSSFrameConstructor::ConstructSVGForeignObjectFrame) },
SIMPLE_SVG_CREATE(a, NS_NewSVGAFrame),
SIMPLE_SVG_CREATE(text, NS_NewSVGTextFrame),
SIMPLE_SVG_CREATE(tspan, NS_NewSVGTSpanFrame),
SIMPLE_SVG_CREATE(linearGradient, NS_NewSVGLinearGradientFrame),
SIMPLE_SVG_CREATE(radialGradient, NS_NewSVGRadialGradientFrame),
SIMPLE_SVG_CREATE(stop, NS_NewSVGStopFrame),
SIMPLE_SVG_CREATE(use, NS_NewSVGUseFrame),
SIMPLE_SVG_CREATE(marker, NS_NewSVGMarkerFrame),
SIMPLE_SVG_CREATE(image, NS_NewSVGImageFrame),
SIMPLE_SVG_CREATE(clipPath, NS_NewSVGClipPathFrame),
SIMPLE_SVG_CREATE(textPath, NS_NewSVGTextPathFrame),
SIMPLE_SVG_CREATE(filter, NS_NewSVGFilterFrame),
SIMPLE_SVG_CREATE(pattern, NS_NewSVGPatternFrame),
SIMPLE_SVG_CREATE(mask, NS_NewSVGMaskFrame),
SIMPLE_SVG_CREATE(feDistantLight, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(fePointLight, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feSpotLight, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feBlend, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feColorMatrix, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feFuncR, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feFuncG, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feFuncB, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feFuncA, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feComposite, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feConvolveMatrix, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feDisplacementMap, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feFlood, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feGaussianBlur, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feImage, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feMergeNode, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feMorphology, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feOffset, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feTile, NS_NewSVGLeafFrame),
SIMPLE_SVG_CREATE(feTurbulence, NS_NewSVGLeafFrame)
};
const FrameConstructionData* data =
FindDataByTag(aTag, aContent, aStyleContext, sSVGData,
NS_ARRAY_LENGTH(sSVGData));
if (!data) {
data = &sGenericContainerData;
}
return data;
}
nsresult
nsCSSFrameConstructor::ConstructSVGForeignObjectFrame(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aStyleDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
nsIFrame* newFrame = NS_NewSVGForeignObjectFrame(mPresShell, styleContext);
if (NS_UNLIKELY(!newFrame)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// We don't allow this frame to be out of flow
InitAndRestoreFrame(aState, content, aParentFrame, nsnull, newFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
nsresult rv = aState.AddChild(newFrame, aFrameItems, content, styleContext,
aParentFrame, PR_FALSE, PR_FALSE);
if (NS_FAILED(rv)) {
return rv;
}
nsRefPtr<nsStyleContext> innerPseudoStyle;
innerPseudoStyle = mPresShell->StyleSet()->
ResolvePseudoStyleFor(content,
nsCSSAnonBoxes::mozSVGForeignContent, styleContext);
nsIFrame* blockFrame = NS_NewBlockFrame(mPresShell, innerPseudoStyle,
NS_BLOCK_FLOAT_MGR |
NS_BLOCK_MARGIN_ROOT);
if (NS_UNLIKELY(!blockFrame)) {
newFrame->Destroy();
return NS_ERROR_OUT_OF_MEMORY;
}
nsFrameItems childItems;
// Claim to be relatively positioned so that we end up being the
// absolute containing block.
rv = ConstructBlock(aState, innerPseudoStyle->GetStyleDisplay(), content,
newFrame, newFrame, innerPseudoStyle,
&blockFrame, childItems, PR_TRUE);
// Give the blockFrame a view so that GetOffsetTo works for descendants
// of blockFrame with views...
nsHTMLContainerFrame::CreateViewForFrame(blockFrame, PR_TRUE);
newFrame->SetInitialChildList(nsnull, childItems.childList);
*aNewFrame = newFrame;
return rv;
}
#endif // MOZ_SVG
void
nsCSSFrameConstructor::AddPageBreakItem(nsIContent* aContent,
nsStyleContext* aMainStyleContext,
FrameConstructionItemList& aItems)
{
nsRefPtr<nsStyleContext> pseudoStyle;
// Use the same parent style context that |aMainStyleContext| has, since
// that's easier to re-resolve and it doesn't matter in practice.
// (Getting different parents can result in framechange hints, e.g.,
// for user-modify.)
pseudoStyle =
mPresShell->StyleSet()->
ResolvePseudoStyleFor(nsnull, nsCSSAnonBoxes::pageBreak,
aMainStyleContext->GetParent());
NS_ASSERTION(pseudoStyle->GetStyleDisplay()->mDisplay ==
NS_STYLE_DISPLAY_BLOCK, "Unexpected display");
FrameConstructionItem* item = aItems.AppendItem();
if (!item) {
return;
}
static const FrameConstructionData sPageBreakData =
FCDATA_DECL(FCDATA_SKIP_FRAMEMAP, NS_NewPageBreakFrame);
item->mFCData = &sPageBreakData;
item->mContent = aContent;
// Lie about the tag and namespace so we don't trigger anything
// interesting during frame construction.
item->mTag = nsCSSAnonBoxes::pageBreak;
item->mNameSpaceID = kNameSpaceID_None;
item->mStyleContext.swap(pseudoStyle);
item->mIsText = PR_FALSE;
item->mIsGeneratedContent = PR_FALSE;
item->mIsRootPopupgroup = PR_FALSE;
item->mIsAllInline = item->mHasInlineEnds = PR_FALSE;
item->mIsPopup = PR_FALSE;
}
nsresult
nsCSSFrameConstructor::ConstructFrame(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsFrameItems& aFrameItems)
{
NS_PRECONDITION(nsnull != aParentFrame, "no parent frame");
FrameConstructionItemList items;
AddFrameConstructionItems(aState, aContent, aParentFrame, items);
for (FCItemIterator iter(items); !iter.IsDone(); iter.Next()) {
nsresult rv =
ConstructFramesFromItem(aState, iter, aParentFrame, aFrameItems);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
void
nsCSSFrameConstructor::AddFrameConstructionItems(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrame,
FrameConstructionItemList& aItems)
{
// don't create a whitespace frame if aParent doesn't want it
if (!NeedFrameFor(aParentFrame, aContent)) {
return;
}
// never create frames for comments or PIs
if (aContent->IsNodeOfType(nsINode::eCOMMENT) ||
aContent->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION))
return;
nsRefPtr<nsStyleContext> styleContext;
styleContext = ResolveStyleContext(aParentFrame, aContent);
AddFrameConstructionItemsInternal(aState, aContent, aParentFrame,
aContent->Tag(), aContent->GetNameSpaceID(),
styleContext,
ITEM_ALLOW_XBL_BASE | ITEM_ALLOW_PAGE_BREAK,
aItems);
}
void
nsCSSFrameConstructor::AddFrameConstructionItemsInternal(nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsIAtom* aTag,
PRInt32 aNameSpaceID,
nsStyleContext* aStyleContext,
PRUint32 aFlags,
FrameConstructionItemList& aItems)
{
// The following code allows the user to specify the base tag
// of an element using XBL. XUL and HTML objects (like boxes, menus, etc.)
// can then be extended arbitrarily.
const nsStyleDisplay* display = aStyleContext->GetStyleDisplay();
nsRefPtr<nsStyleContext> styleContext(aStyleContext);
nsAutoEnqueueBinding binding(mDocument);
if ((aFlags & ITEM_ALLOW_XBL_BASE) && display->mBinding)
{
// Ensure that our XBL bindings are installed.
nsIXBLService * xblService = GetXBLService();
if (!xblService)
return;
PRBool resolveStyle;
nsresult rv = xblService->LoadBindings(aContent, display->mBinding->mURI,
display->mBinding->mOriginPrincipal,
PR_FALSE,
getter_AddRefs(binding.mBinding),
&resolveStyle);
if (NS_FAILED(rv))
return;
if (resolveStyle) {
styleContext = ResolveStyleContext(styleContext->GetParent(), aContent);
display = styleContext->GetStyleDisplay();
aStyleContext = styleContext;
}
aTag = mDocument->BindingManager()->ResolveTag(aContent, &aNameSpaceID);
}
// Pre-check for display "none" - if we find that, don't create
// any frame at all
if (NS_STYLE_DISPLAY_NONE == display->mDisplay) {
aState.mFrameManager->SetUndisplayedContent(aContent, styleContext);
return;
}
PRBool isText = aContent->IsNodeOfType(nsINode::eTEXT);
PRBool isPopup = PR_FALSE;
// Try to find frame construction data for this content
const FrameConstructionData* data;
if (isText) {
data = FindTextData(aParentFrame);
#ifdef MOZ_SVG
if (!data) {
// Nothing to do here; suppressed text inside SVG
return;
}
#endif /* MOZ_SVG */
} else {
#ifdef MOZ_SVG
// Don't create frames for non-SVG element children of SVG elements.
if (aNameSpaceID != kNameSpaceID_SVG &&
aParentFrame &&
aParentFrame->IsFrameOfType(nsIFrame::eSVG) &&
!aParentFrame->IsFrameOfType(nsIFrame::eSVGForeignObject)
) {
return;
}
#endif /* MOZ_SVG */
data = FindHTMLData(aContent, aTag, aNameSpaceID, aParentFrame,
styleContext);
if (!data) {
data = FindXULTagData(aContent, aTag, aNameSpaceID, styleContext);
}
#ifdef MOZ_MATHML
if (!data) {
data = FindMathMLData(aContent, aTag, aNameSpaceID, styleContext);
}
#endif
#ifdef MOZ_SVG
if (!data) {
data = FindSVGData(aContent, aTag, aNameSpaceID, aParentFrame,
styleContext);
}
#endif /* MOZ_SVG */
// Now check for XUL display types
if (!data) {
data = FindXULDisplayData(display, aContent, styleContext);
}
// And general display types
if (!data) {
data = FindDisplayData(display, aContent);
}
NS_ASSERTION(data, "Should have frame construction data now");
if (data->mBits & FCDATA_SUPPRESS_FRAME) {
return;
}
#ifdef MOZ_XUL
if ((data->mBits & FCDATA_IS_POPUP) &&
(!aParentFrame || // Parent is inline
aParentFrame->GetType() != nsGkAtoms::menuFrame)) {
if (!aState.mPopupItems.containingBlock &&
!aState.mHavePendingPopupgroup) {
return;
}
isPopup = PR_TRUE;
}
#endif /* MOZ_XUL */
}
PRUint32 bits = data->mBits;
// Inside colgroups, suppress everything except columns.
if (aParentFrame &&
aParentFrame->GetType() == nsGkAtoms::tableColGroupFrame &&
(!(bits & FCDATA_IS_TABLE_PART) ||
display->mDisplay != NS_STYLE_DISPLAY_TABLE_COLUMN)) {
return;
}
PRBool canHavePageBreak =
(aFlags & ITEM_ALLOW_PAGE_BREAK) &&
aState.mPresContext->IsPaginated() &&
!display->IsAbsolutelyPositioned() &&
!(bits & FCDATA_IS_TABLE_PART);
if (canHavePageBreak && display->mBreakBefore) {
AddPageBreakItem(aContent, aStyleContext, aItems);
}
PRBool isGeneratedContent = ((aFlags & ITEM_IS_GENERATED_CONTENT) != 0);
FrameConstructionItem* item = aItems.AppendItem();
if (!item) {
if (isGeneratedContent) {
aContent->UnbindFromTree();
}
return;
}
item->mFCData = data;
item->mContent = aContent;
item->mTag = aTag;
item->mNameSpaceID = aNameSpaceID;
item->mStyleContext.swap(styleContext);
item->mIsText = isText;
item->mIsGeneratedContent = isGeneratedContent;
if (isGeneratedContent) {
NS_ADDREF(item->mContent);
}
item->mIsRootPopupgroup =
aNameSpaceID == kNameSpaceID_XUL && aTag == nsGkAtoms::popupgroup &&
aContent->IsRootOfNativeAnonymousSubtree();
if (item->mIsRootPopupgroup) {
aState.mHavePendingPopupgroup = PR_TRUE;
}
item->mIsPopup = isPopup;
if (canHavePageBreak && display->mBreakAfter) {
AddPageBreakItem(aContent, aStyleContext, aItems);
}
if (bits & FCDATA_IS_INLINE) {
// To correctly set item->mIsAllInline we need to build up our child items
// right now.
BuildInlineChildItems(aState, *item);
item->mHasInlineEnds = PR_TRUE;
} else {
item->mIsAllInline = item->mHasInlineEnds =
// Table-internal things are inline-outside if they're kids of
// inlines, since they'll trigger construction of inline-table
// pseudos.
((bits & FCDATA_IS_TABLE_PART) &&
(!aParentFrame || // No aParentFrame means inline
aParentFrame->GetStyleDisplay()->mDisplay == NS_STYLE_DISPLAY_INLINE)) ||
// Things that are inline-outside but aren't inline frames are inline
display->IsInlineOutside() ||
// Things that we're guaranteed will end up out-of-flow are inline. This
// is not a precise test, since one of our ancestor inlines might add an
// absolute containing block (if it's relatively positioned) or float
// containing block (the latter if it gets split by child blocks on both
// sides of us) when there wasn't such a containining block before. But
// it's conservative in the sense that anything that will really end up
// as an in-flow non-inline will have false mIsAllInline. It just might
// be that even an inline that has mIsAllInline false doesn't need an
// {ib} split. So this is just an optimization to keep from doint to
// much work when that happens.
(!(bits & FCDATA_DISALLOW_OUT_OF_FLOW) &&
aState.GetGeometricParent(display, nsnull)) ||
// Popups that are certainly out of flow.
isPopup;
}
if (item->mIsAllInline) {
aItems.InlineItemAdded();
}
if (bits & FCDATA_IS_LINE_PARTICIPANT) {
aItems.LineParticipantItemAdded();
}
}
static void DestroyContent(void *aObject,
nsIAtom *aPropertyName,
void *aPropertyValue,
void *aData)
{
nsIContent* content = static_cast<nsIContent*>(aPropertyValue);
content->UnbindFromTree();
NS_RELEASE(content);
}
nsresult
nsCSSFrameConstructor::ConstructFramesFromItem(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
nsFrameItems& aFrameItems)
{
nsIFrame* adjParentFrame = aParentFrame;
nsFrameItems* frameItems = &aFrameItems;
PRBool pseudoParent = PR_FALSE;
nsStyleContext* styleContext = aItem.mStyleContext;
nsFrameConstructorSaveState pseudoSaveState;
nsresult rv = AdjustParentFrame(aState, aItem.mContent, adjParentFrame,
aItem.mFCData, aItem.mNameSpaceID,
styleContext, frameItems, pseudoSaveState,
pseudoParent);
if (NS_FAILED(rv)) {
return rv;
}
if (aItem.mIsText) {
return ConstructTextFrame(aItem.mFCData, aState, aItem.mContent,
adjParentFrame, styleContext,
*frameItems, pseudoParent);
}
// If the page contains markup that overrides text direction, and
// does not contain any characters that would activate the Unicode
// bidi algorithm, we need to call |SetBidiEnabled| on the pres
// context before reflow starts. This requires us to resolve some
// style information now. See bug 115921.
{
if (styleContext->GetStyleVisibility()->mDirection ==
NS_STYLE_DIRECTION_RTL)
aState.mPresContext->SetBidiEnabled();
}
// Start background loads during frame construction. This is just
// a hint; the paint code will do the right thing in any case.
{
styleContext->GetStyleBackground();
}
nsFrameState savedStateBits = aState.mAdditionalStateBits;
if (aItem.mIsGeneratedContent) {
// Ensure that frames created here are all tagged with
// NS_FRAME_GENERATED_CONTENT.
aState.mAdditionalStateBits |= NS_FRAME_GENERATED_CONTENT;
aParentFrame->SetProperty(styleContext->GetPseudoType(),
aItem.mContent, DestroyContent);
// Now that we've passed ownership of aItem.mContent to the frame, unset
// our generated content flag so we don't release or unbind it ourselves.
aItem.mIsGeneratedContent = PR_FALSE;
}
// XXXbz maybe just inline ConstructFrameFromItemInternal here or something?
rv = ConstructFrameFromItemInternal(aItem, aState, adjParentFrame,
*frameItems, pseudoParent);
aState.mAdditionalStateBits = savedStateBits;
return rv;
}
inline PRBool
IsRootBoxFrame(nsIFrame *aFrame)
{
return (aFrame->GetType() == nsGkAtoms::rootFrame);
}
nsresult
nsCSSFrameConstructor::ReconstructDocElementHierarchy()
{
AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
return ReconstructDocElementHierarchyInternal();
}
nsresult
nsCSSFrameConstructor::ReconstructDocElementHierarchyInternal()
{
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ReconstructDocElementHierarchy\n");
}
#endif
nsresult rv = NS_OK;
// XXXbz is that null-check needed? Why?
if (mDocument && mPresShell) {
nsIContent *rootContent = mDocument->GetRootContent();
if (rootContent) {
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
nsnull, nsnull, mTempFrameTreeState);
// Before removing the frames associated with the content object, ask them to save their
// state onto a temporary state object.
CaptureStateFor(state.mFrameManager->GetRootFrame(), mTempFrameTreeState);
// Get the frame that corresponds to the document element
nsIFrame* docElementFrame =
state.mFrameManager->GetPrimaryFrameFor(rootContent, -1);
if (docElementFrame) {
// Destroy out-of-flow frames that might not be in the frame subtree
// rooted at docElementFrame
::DeletingFrameSubtree(state.mFrameManager, docElementFrame);
} else {
state.mFrameManager->ClearUndisplayedContentIn(rootContent, nsnull);
}
// Remove any existing fixed items: they are always on the
// FixedContainingBlock. Note that this has to be done before we call
// ClearPlaceholderFrameMap(), since RemoveFixedItems uses the
// placeholder frame map.
rv = RemoveFixedItems(state, docElementFrame);
if (NS_SUCCEEDED(rv)) {
nsPlaceholderFrame* placeholderFrame = nsnull;
if (docElementFrame &&
(docElementFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
// Get the placeholder frame now, before we tear down the
// placeholder frame map
placeholderFrame =
state.mFrameManager->GetPlaceholderFrameFor(docElementFrame);
NS_ASSERTION(placeholderFrame, "No placeholder for out-of-flow?");
}
// Clear the hash tables that map from content to frame and out-of-flow
// frame to placeholder frame
state.mFrameManager->ClearPrimaryFrameMap();
state.mFrameManager->ClearPlaceholderFrameMap();
state.mFrameManager->ClearUndisplayedContentMap();
if (docElementFrame) {
// Take the docElementFrame, and remove it from its parent.
// XXXbz So why can't we reuse ContentRemoved?
// Notify self that we will destroy the entire frame tree, this blocks
// RemoveMappingsForFrameSubtree() which would otherwise lead to a
// crash since we cleared the placeholder map above (bug 398982).
PRBool wasDestroyingFrameTree = mIsDestroyingFrameTree;
WillDestroyFrameTree(PR_FALSE);
rv = state.mFrameManager->RemoveFrame(docElementFrame->GetParent(),
GetChildListNameFor(docElementFrame), docElementFrame);
if (placeholderFrame) {
// Remove the placeholder frame first (XXX second for now) (so
// that it doesn't retain a dangling pointer to memory)
rv |= state.mFrameManager->RemoveFrame(placeholderFrame->GetParent(),
nsnull, placeholderFrame);
}
mIsDestroyingFrameTree = wasDestroyingFrameTree;
if (NS_FAILED(rv)) {
return rv;
}
}
}
}
if (rootContent && NS_SUCCEEDED(rv)) {
mRootElementFrame = nsnull;
mRootElementStyleFrame = nsnull;
// We don't reuse the old frame constructor state because,
// for example, its mPopupItems may be stale
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
nsnull, nsnull, mTempFrameTreeState);
// Create the new document element hierarchy
nsIFrame* newChild;
rv = ConstructDocElementFrame(state, rootContent,
mDocElementContainingBlock, &newChild);
// newChild could be null even if |rv| is success, thanks to XBL.
if (NS_SUCCEEDED(rv) && newChild) {
rv = state.mFrameManager->InsertFrames(mDocElementContainingBlock,
nsnull, nsnull, newChild);
}
}
}
return rv;
}
nsIFrame*
nsCSSFrameConstructor::GetFrameFor(nsIContent* aContent)
{
// Get the primary frame associated with the content
nsIFrame* frame = mPresShell->GetPrimaryFrameFor(aContent);
if (!frame)
return nsnull;
nsIFrame* insertionFrame = frame->GetContentInsertionFrame();
NS_ASSERTION(insertionFrame == frame || !frame->IsLeaf(),
"The insertion frame is the primary frame or the primary frame isn't a leaf");
return insertionFrame;
}
nsIFrame*
nsCSSFrameConstructor::GetAbsoluteContainingBlock(nsIFrame* aFrame)
{
NS_PRECONDITION(nsnull != mRootElementFrame, "no root element frame");
// Starting with aFrame, look for a frame that is absolutely positioned or
// relatively positioned
nsIFrame* containingBlock = nsnull;
for (nsIFrame* frame = aFrame; frame && !containingBlock;
frame = frame->GetParent()) {
if (frame->IsFrameOfType(nsIFrame::eMathML)) {
// If it's mathml, bail out -- no absolute positioning out from inside
// mathml frames. Note that we don't make this part of the loop
// condition because of the stuff at the end of this method...
return nsnull;
}
// Is it positioned?
// If it's table-related then ignore it, because for the time
// being table-related frames are not containers for absolutely
// positioned child frames.
const nsStyleDisplay* disp = frame->GetStyleDisplay();
if (disp->IsPositioned() && !IsTableRelated(frame->GetType(), PR_TRUE)) {
// Find the outermost wrapped block under this frame
for (nsIFrame* wrappedFrame = aFrame; wrappedFrame != frame->GetParent();
wrappedFrame = wrappedFrame->GetParent()) {
nsIAtom* frameType = wrappedFrame->GetType();
if (nsGkAtoms::blockFrame == frameType ||
#ifdef MOZ_XUL
nsGkAtoms::XULLabelFrame == frameType ||
#endif
nsGkAtoms::positionedInlineFrame == frameType) {
containingBlock = wrappedFrame;
} else if (nsGkAtoms::fieldSetFrame == frameType) {
// If the positioned frame is a fieldset, use the area frame inside it.
// We don't use GetContentInsertionFrame for fieldsets yet.
containingBlock = GetFieldSetBlockFrame(wrappedFrame);
}
}
#ifdef DEBUG
if (!containingBlock)
NS_WARNING("Positioned frame that does not handle positioned kids; looking further up the parent chain");
#endif
}
}
// If we found an absolutely positioned containing block, then use the
// first-continuation.
if (containingBlock)
return AdjustAbsoluteContainingBlock(containingBlock);
// If we didn't find it, then use the document element containing block
return mHasRootAbsPosContainingBlock ? mDocElementContainingBlock : nsnull;
}
nsIFrame*
nsCSSFrameConstructor::GetFloatContainingBlock(nsIFrame* aFrame)
{
NS_PRECONDITION(mRootElementFrame, "no root element frame");
// Starting with aFrame, look for a frame that is a float containing block.
// IF we hit a mathml frame, bail out; we don't allow floating out of mathml
// frames, because they don't seem to be able to deal.
// The logic here needs to match the logic in ProcessChildren()
for (nsIFrame* containingBlock = aFrame;
containingBlock && !containingBlock->IsFrameOfType(nsIFrame::eMathML) &&
!containingBlock->IsBoxFrame();
containingBlock = containingBlock->GetParent()) {
if (containingBlock->IsFloatContainingBlock()) {
return containingBlock;
}
}
// If we didn't find a containing block, then there just isn't
// one.... return null
return nsnull;
}
/**
* This function will check whether aContainer has :after generated content.
* If so, appending to it should actually insert. The return value is the
* parent to use for newly-appended content. *aAfterFrame points to the :after
* frame before which appended content should go, if there is one.
*/
static nsIFrame*
AdjustAppendParentForAfterContent(nsPresContext* aPresContext,
nsIContent* aContainer,
nsIFrame* aParentFrame,
nsIFrame** aAfterFrame)
{
// See if the parent has an :after pseudo-element. Check for the presence
// of style first, since nsLayoutUtils::GetAfterFrame is sorta expensive.
nsStyleContext* parentStyle = aParentFrame->GetStyleContext();
if (nsLayoutUtils::HasPseudoStyle(aContainer, parentStyle,
nsCSSPseudoElements::after,
aPresContext)) {
nsIFrame* afterFrame = nsLayoutUtils::GetAfterFrame(aParentFrame);
if (afterFrame) {
*aAfterFrame = afterFrame;
return afterFrame->GetParent();
}
}
*aAfterFrame = nsnull;
return aParentFrame;
}
/**
* This function is called by ContentAppended() and ContentInserted()
* when appending flowed frames to a parent's principal child list. It
* handles the case where the parent frame has :after pseudo-element
* generated content.
*/
nsresult
nsCSSFrameConstructor::AppendFrames(nsFrameConstructorState& aState,
nsIContent* aContainer,
nsIFrame* aParentFrame,
nsFrameItems& aFrameList,
nsIFrame* aAfterFrame)
{
#ifdef DEBUG
nsIFrame* debugAfterFrame;
nsIFrame* debugNewParent =
::AdjustAppendParentForAfterContent(aState.mPresContext, aContainer,
aParentFrame, &debugAfterFrame);
NS_ASSERTION(debugNewParent == aParentFrame, "Incorrect parent");
NS_ASSERTION(debugAfterFrame == aAfterFrame, "Incorrect after frame");
#endif
nsFrameManager* frameManager = aState.mFrameManager;
if (aAfterFrame) {
NS_ASSERTION(!IsFrameSpecial(aParentFrame) ||
IsInlineFrame(aParentFrame) ||
!IsInlineOutside(aAfterFrame),
"Shouldn't have inline :after content on the block in an "
"{ib} split");
nsFrameList frames(aParentFrame->GetFirstChild(nsnull));
// Insert the frames before the :after pseudo-element.
return frameManager->InsertFrames(aParentFrame, nsnull,
frames.GetPrevSiblingFor(aAfterFrame),
aFrameList.childList);
}
if (IsFrameSpecial(aParentFrame) &&
!IsInlineFrame(aParentFrame) &&
IsInlineOutside(aFrameList.lastChild)) {
NS_ASSERTION(!aParentFrame->GetNextContinuation() ||
!aParentFrame->GetNextContinuation()->GetFirstChild(nsnull),
"Shouldn't happen");
// We want to put some of the frames into the following inline frame.
nsIFrame* lastBlock = FindLastBlock(aFrameList.childList);
nsIFrame* firstTrailingInline;
if (lastBlock) {
firstTrailingInline = lastBlock->GetNextSibling();
lastBlock->SetNextSibling(nsnull);
aFrameList.lastChild = lastBlock;
} else {
firstTrailingInline = aFrameList.childList;
aFrameList = nsFrameItems();
}
NS_ASSERTION(firstTrailingInline, "How did that happen?");
nsIFrame* inlineSibling = GetSpecialSibling(aParentFrame);
NS_ASSERTION(inlineSibling, "How did that happen?");
nsIFrame* stateParent = inlineSibling->GetParent();
nsFrameConstructorState targetState(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(stateParent),
GetFloatContainingBlock(stateParent));
MoveFramesToEndOfIBSplit(aState, inlineSibling, firstTrailingInline,
aParentFrame, &targetState);
}
if (!aFrameList.childList) {
// It all got eaten by the special inline
return NS_OK;
}
return frameManager->AppendFrames(aParentFrame, nsnull,
aFrameList.childList);
}
#define UNSET_DISPLAY 255
// This gets called to see if the frames corresponding to aSiblingDisplay and aDisplay
// should be siblings in the frame tree. Although (1) rows and cols, (2) row groups
// and col groups, (3) row groups and captions, (4) legends and content inside fieldsets, (5) popups and other kids of the menu
// are siblings from a content perspective, they are not considered siblings in the
// frame tree.
PRBool
nsCSSFrameConstructor::IsValidSibling(nsIFrame* aSibling,
nsIContent* aContent,
PRUint8& aDisplay)
{
nsIFrame* parentFrame = aSibling->GetParent();
nsIAtom* parentType = nsnull;
nsIAtom* grandparentType = nsnull;
if (parentFrame) {
parentType = parentFrame->GetType();
nsIFrame* grandparentFrame = parentFrame->GetParent();
if (grandparentFrame) {
grandparentType = grandparentFrame->GetType();
}
}
PRUint8 siblingDisplay = aSibling->GetStyleDisplay()->mDisplay;
if ((NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == siblingDisplay) ||
(NS_STYLE_DISPLAY_TABLE_COLUMN == siblingDisplay) ||
(NS_STYLE_DISPLAY_TABLE_CAPTION == siblingDisplay) ||
(NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == siblingDisplay) ||
(NS_STYLE_DISPLAY_TABLE_ROW_GROUP == siblingDisplay) ||
(NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == siblingDisplay) ||
nsGkAtoms::menuFrame == parentType) {
// if we haven't already, construct a style context to find the display type of aContent
if (UNSET_DISPLAY == aDisplay) {
nsRefPtr<nsStyleContext> styleContext;
nsIFrame* styleParent;
PRBool providerIsChild;
if (NS_FAILED(aSibling->
GetParentStyleContextFrame(aSibling->PresContext(),
&styleParent,
&providerIsChild)) ||
!styleParent) {
NS_NOTREACHED("Shouldn't happen");
return PR_FALSE;
}
styleContext = ResolveStyleContext(styleParent, aContent);
if (!styleContext) return PR_FALSE;
const nsStyleDisplay* display = styleContext->GetStyleDisplay();
aDisplay = display->mDisplay;
}
if (nsGkAtoms::menuFrame == parentType) {
return
(NS_STYLE_DISPLAY_POPUP == aDisplay) ==
(NS_STYLE_DISPLAY_POPUP == siblingDisplay);
}
switch (siblingDisplay) {
case NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP:
return (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == aDisplay);
case NS_STYLE_DISPLAY_TABLE_COLUMN:
return (NS_STYLE_DISPLAY_TABLE_COLUMN == aDisplay);
case NS_STYLE_DISPLAY_TABLE_CAPTION:
return (NS_STYLE_DISPLAY_TABLE_CAPTION == aDisplay);
default: // all of the row group types
return (NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == aDisplay) ||
(NS_STYLE_DISPLAY_TABLE_ROW_GROUP == aDisplay) ||
(NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == aDisplay) ||
(NS_STYLE_DISPLAY_TABLE_CAPTION == aDisplay);
}
}
else if (nsGkAtoms::fieldSetFrame == parentType ||
(nsGkAtoms::fieldSetFrame == grandparentType &&
nsGkAtoms::blockFrame == parentType)) {
// Legends can be sibling of legends but not of other content in the fieldset
nsIAtom* sibType = aSibling->GetType();
nsCOMPtr<nsIDOMHTMLLegendElement> legendContent(do_QueryInterface(aContent));
if ((legendContent && (nsGkAtoms::legendFrame != sibType)) ||
(!legendContent && (nsGkAtoms::legendFrame == sibType)))
return PR_FALSE;
}
return PR_TRUE;
}
nsIFrame*
nsCSSFrameConstructor::FindFrameForContentSibling(nsIContent* aContent,
nsIContent* aTargetContent,
PRUint8& aTargetContentDisplay,
PRBool aPrevSibling)
{
nsIFrame* sibling = mPresShell->GetPrimaryFrameFor(aContent);
if (!sibling) {
return nsnull;
}
// If the frame is out-of-flow, GPFF() will have returned the
// out-of-flow frame; we want the placeholder.
if (sibling->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
nsIFrame* placeholderFrame;
mPresShell->GetPlaceholderFrameFor(sibling, &placeholderFrame);
NS_ASSERTION(placeholderFrame, "no placeholder for out-of-flow frame");
sibling = placeholderFrame;
}
// The frame we have now should never be a continuation
NS_ASSERTION(!sibling->GetPrevContinuation(), "How did that happen?");
if (aPrevSibling) {
// The frame may be a special frame (a split inline frame that
// contains a block). Get the last part of that split.
if (IsFrameSpecial(sibling)) {
sibling = GetLastSpecialSibling(sibling, PR_FALSE);
}
// The frame may have a continuation. If so, we want the last
// non-overflow-container continuation as our previous sibling.
sibling = sibling->GetTailContinuation();
}
if (aTargetContent &&
!IsValidSibling(sibling, aTargetContent, aTargetContentDisplay)) {
sibling = nsnull;
}
return sibling;
}
nsIFrame*
nsCSSFrameConstructor::FindPreviousSibling(const ChildIterator& aFirst,
ChildIterator aIter)
{
nsIContent* child = *aIter;
PRUint8 childDisplay = UNSET_DISPLAY;
// Note: not all content objects are associated with a frame (e.g., if it's
// `display: none') so keep looking until we find a previous frame
while (aIter-- != aFirst) {
nsIFrame* prevSibling =
FindFrameForContentSibling(*aIter, child, childDisplay, PR_TRUE);
if (prevSibling) {
// Found a previous sibling, we're done!
return prevSibling;
}
}
return nsnull;
}
nsIFrame*
nsCSSFrameConstructor::FindNextSibling(ChildIterator aIter,
const ChildIterator& aLast)
{
if (aIter == aLast) {
// XXXbz Can happen when XBL lies to us about insertion points. This check
// might be able to go away once bug 474324 is fixed.
return nsnull;
}
nsIContent* child = *aIter;
PRUint8 childDisplay = UNSET_DISPLAY;
while (++aIter != aLast) {
nsIFrame* nextSibling =
FindFrameForContentSibling(*aIter, child, childDisplay, PR_FALSE);
if (nextSibling) {
// We found a next sibling, we're done!
return nextSibling;
}
}
return nsnull;
}
// For fieldsets, returns the area frame, if the child is not a legend.
static nsIFrame*
GetAdjustedParentFrame(nsIFrame* aParentFrame,
nsIAtom* aParentFrameType,
nsIContent* aChildContent)
{
NS_PRECONDITION(nsGkAtoms::tableOuterFrame != aParentFrameType,
"Shouldn't be happening!");
nsIFrame* newParent = nsnull;
if (nsGkAtoms::fieldSetFrame == aParentFrameType) {
// If the parent is a fieldSet, use the fieldSet's area frame as the
// parent unless the new content is a legend.
nsCOMPtr<nsIDOMHTMLLegendElement> legendContent(do_QueryInterface(aChildContent));
if (!legendContent) {
newParent = GetFieldSetBlockFrame(aParentFrame);
}
}
return (newParent) ? newParent : aParentFrame;
}
static void
InvalidateCanvasIfNeeded(nsIFrame* aFrame);
static PRBool
IsSpecialFramesetChild(nsIContent* aContent)
{
// IMPORTANT: This must match the conditions in nsHTMLFramesetFrame::Init.
return aContent->IsNodeOfType(nsINode::eHTML) &&
(aContent->Tag() == nsGkAtoms::frameset ||
aContent->Tag() == nsGkAtoms::frame);
}
nsresult
nsCSSFrameConstructor::ContentAppended(nsIContent* aContainer,
PRInt32 aNewIndexInContainer)
{
AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
NS_PRECONDITION(mUpdateCount != 0,
"Should be in an update while creating frames");
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ContentAppended container=%p index=%d\n",
static_cast<void*>(aContainer), aNewIndexInContainer);
if (gReallyNoisyContentUpdates && aContainer) {
aContainer->List(stdout, 0);
}
}
#endif
#ifdef MOZ_XUL
if (aContainer) {
PRInt32 namespaceID;
nsIAtom* tag =
mDocument->BindingManager()->ResolveTag(aContainer, &namespaceID);
// Just ignore tree tags, anyway we don't create any frames for them.
if (tag == nsGkAtoms::treechildren ||
tag == nsGkAtoms::treeitem ||
tag == nsGkAtoms::treerow)
return NS_OK;
}
#endif // MOZ_XUL
// Get the frame associated with the content
nsIFrame* parentFrame = GetFrameFor(aContainer);
if (! parentFrame)
return NS_OK;
// See if we have an XBL insertion point. If so, then that's our
// real parent frame; if not, then the frame hasn't been built yet
// and we just bail.
//
nsIFrame* insertionPoint;
PRBool multiple = PR_FALSE;
GetInsertionPoint(parentFrame, nsnull, &insertionPoint, &multiple);
if (! insertionPoint)
return NS_OK; // Don't build the frames.
PRBool hasInsertion = PR_FALSE;
if (!multiple) {
nsIDocument* document = nsnull;
nsIContent *firstAppendedChild =
aContainer->GetChildAt(aNewIndexInContainer);
if (firstAppendedChild) {
document = firstAppendedChild->GetDocument();
}
if (document &&
document->BindingManager()->GetInsertionParent(firstAppendedChild)) {
hasInsertion = PR_TRUE;
}
}
if (multiple || hasInsertion) {
// We have an insertion point. There are some additional tests we need to do
// in order to ensure that an append is a safe operation.
PRUint32 childCount = 0;
if (!multiple) {
// We may need to make multiple ContentInserted calls instead. A
// reasonable heuristic to employ (in order to maintain good performance)
// is to find out if the insertion point's content node contains any
// explicit children. If it does not, then it is highly likely that
// an append is occurring. (Note it is not definite, and there are insane
// cases we will not deal with by employing this heuristic, but it beats
// always falling back to multiple ContentInserted calls).
//
// In the multiple insertion point case, we know we're going to need to do
// multiple ContentInserted calls anyway.
childCount = insertionPoint->GetContent()->GetChildCount();
}
if (multiple || childCount > 0) {
// Now comes the fun part. For each appended child, make a
// ContentInserted call as if it had just gotten inserted at the index
// it's at in aContainer and let ContentInserted handle the mess. If our
// insertion point is non-XBL that's the correct index, and otherwise
// ContentInserted will ignore the passed-in index.
PRUint32 containerCount = aContainer->GetChildCount();
for (PRUint32 i = aNewIndexInContainer; i < containerCount; i++) {
LAYOUT_PHASE_TEMP_EXIT();
// Call ContentInserted with this index.
ContentInserted(aContainer, aContainer->GetChildAt(i), i,
mTempFrameTreeState);
LAYOUT_PHASE_TEMP_REENTER();
}
return NS_OK;
}
}
parentFrame = insertionPoint;
if (parentFrame->GetType() == nsGkAtoms::frameSetFrame) {
// Check whether we have any kids we care about.
PRUint32 count = aContainer->GetChildCount();
for (PRUint32 i = aNewIndexInContainer; i < count; ++i) {
if (IsSpecialFramesetChild(aContainer->GetChildAt(i))) {
// Just reframe the parent, since framesets are weird like that.
return RecreateFramesForContent(parentFrame->GetContent());
}
}
}
if (parentFrame->IsLeaf()) {
// Nothing to do here; we shouldn't be constructing kids of leaves
return NS_OK;
}
#ifdef MOZ_MATHML
if (parentFrame->IsFrameOfType(nsIFrame::eMathML))
return RecreateFramesForContent(parentFrame->GetContent());
#endif
// If the frame we are manipulating is a ``special'' frame (that is, one
// that's been created as a result of a block-in-inline situation) then we
// need to append to the last special sibling, not to the frame itself.
if (IsFrameSpecial(parentFrame)) {
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ContentAppended: parentFrame=");
nsFrame::ListTag(stdout, parentFrame);
printf(" is special\n");
}
#endif
// Since we're appending, we'll walk to the last anonymous frame
// that was created for the broken inline frame. But don't walk
// to the trailing inline if its empty; stop at the block.
parentFrame = GetLastSpecialSibling(parentFrame, PR_TRUE);
}
// Get continuation that parents the last child
parentFrame = nsLayoutUtils::GetLastContinuationWithChild(parentFrame);
nsIAtom* frameType = parentFrame->GetType();
// We should never get here with fieldsets, since they have multiple
// insertion points.
NS_ASSERTION(frameType != nsGkAtoms::fieldSetFrame,
"Unexpected parent");
// Deal with possible :after generated content on the parent
nsIFrame* parentAfterFrame;
parentFrame =
::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(),
aContainer, parentFrame,
&parentAfterFrame);
// Create some new frames
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(parentFrame),
GetFloatContainingBlock(parentFrame));
// See if the containing block has :first-letter style applied.
PRBool haveFirstLetterStyle = PR_FALSE, haveFirstLineStyle = PR_FALSE;
nsIFrame* containingBlock = state.mFloatedItems.containingBlock;
if (containingBlock) {
haveFirstLetterStyle = HasFirstLetterStyle(containingBlock);
haveFirstLineStyle =
ShouldHaveFirstLineStyle(containingBlock->GetContent(),
containingBlock->GetStyleContext());
}
if (haveFirstLetterStyle) {
// Before we get going, remove the current letter frames
RemoveLetterFrames(state.mPresContext, state.mPresShell,
state.mFrameManager, containingBlock);
}
FrameConstructionItemList items;
for (PRUint32 i = aNewIndexInContainer, count = aContainer->GetChildCount();
i < count;
++i) {
AddFrameConstructionItems(state, aContainer->GetChildAt(i), parentFrame,
items);
}
// Perform special check for diddling around with the frames in
// a special inline frame.
// If we're appending before :after content, then we're not really
// appending, so let WipeContainingBlock know that.
if (WipeContainingBlock(state, containingBlock, parentFrame, items,
!parentAfterFrame, nsnull)) {
return NS_OK;
}
// if the container is a table and a caption was appended, it needs to be put in
// the outer table frame's additional child list.
nsFrameItems frameItems;
nsFrameItems captionItems;
for (FCItemIterator iter(items); !iter.IsDone(); iter.Next()) {
nsresult rv =
ConstructFramesFromItem(state, iter, parentFrame, frameItems);
if (NS_FAILED(rv)) {
break;
}
// ConstructFramesFromItem will always create at least one frame if it
// succeeds.
// FIXME: But due to bug 480880, we might not have a frameItems.lastChild
// anyway.
if (frameItems.lastChild)
InvalidateCanvasIfNeeded(frameItems.lastChild);
}
if (nsGkAtoms::tableFrame == frameType) {
// Pull out the captions. Note that we don't want to do that as we go,
// because processing a single caption can add a whole bunch of things to
// the frame items due to pseudoframe processing. So we'd have to pull
// captions from a list anyway; might as well do that here.
PullOutCaptionFrames(frameItems, captionItems);
}
// process the current pseudo frame state
if (!state.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(state, frameItems);
}
if (haveFirstLineStyle && parentFrame == containingBlock) {
// It's possible that some of the new frames go into a
// first-line frame. Look at them and see...
AppendFirstLineFrames(state, containingBlock->GetContent(),
containingBlock, frameItems);
}
nsresult result = NS_OK;
// Notify the parent frame passing it the list of new frames
if (NS_SUCCEEDED(result) &&
(frameItems.childList || captionItems.childList)) {
// Append the flowed frames to the principal child list, tables need special treatment
if (nsGkAtoms::tableFrame == frameType) {
if (captionItems.childList) { // append the caption to the outer table
nsIFrame* outerTable = parentFrame->GetParent();
if (outerTable) {
state.mFrameManager->AppendFrames(outerTable,
nsGkAtoms::captionList,
captionItems.childList);
}
}
if (frameItems.childList) { // append children of the inner table
AppendFrames(state, aContainer, parentFrame, frameItems,
parentAfterFrame);
}
}
else {
AppendFrames(state, aContainer, parentFrame, frameItems,
parentAfterFrame);
}
}
// Recover first-letter frames
if (haveFirstLetterStyle) {
RecoverLetterFrames(containingBlock);
}
#ifdef DEBUG
if (gReallyNoisyContentUpdates) {
nsIFrameDebug* fdbg = do_QueryFrame(parentFrame);
if (fdbg) {
printf("nsCSSFrameConstructor::ContentAppended: resulting frame model:\n");
fdbg->List(stdout, 0);
}
}
#endif
return NS_OK;
}
#ifdef MOZ_XUL
enum content_operation
{
CONTENT_INSERTED,
CONTENT_REMOVED
};
// Helper function to lookup the listbox body frame and send a notification
// for insertion or removal of content
static
PRBool NotifyListBoxBody(nsPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer,
nsIDocument* aDocument,
nsIFrame* aChildFrame,
content_operation aOperation)
{
if (!aContainer)
return PR_FALSE;
if (aContainer->IsNodeOfType(nsINode::eXUL) &&
aChild->IsNodeOfType(nsINode::eXUL) &&
aContainer->Tag() == nsGkAtoms::listbox &&
aChild->Tag() == nsGkAtoms::listitem) {
nsCOMPtr<nsIDOMXULElement> xulElement = do_QueryInterface(aContainer);
nsCOMPtr<nsIBoxObject> boxObject;
xulElement->GetBoxObject(getter_AddRefs(boxObject));
nsCOMPtr<nsPIListBoxObject> listBoxObject = do_QueryInterface(boxObject);
if (listBoxObject) {
nsListBoxBodyFrame* listBoxBodyFrame = listBoxObject->GetListBoxBody(PR_FALSE);
if (listBoxBodyFrame) {
if (aOperation == CONTENT_REMOVED) {
// Except if we have an aChildFrame and its parent is not the right
// thing, then we don't do this. Pseudo frames are so much fun....
if (!aChildFrame || aChildFrame->GetParent() == listBoxBodyFrame) {
listBoxBodyFrame->OnContentRemoved(aPresContext, aChildFrame,
aIndexInContainer);
return PR_TRUE;
}
} else {
// If this codepath ever starts using aIndexInContainer, need to
// change ContentInserted to pass in something resembling a correct
// one in the XBL cases.
listBoxBodyFrame->OnContentInserted(aPresContext, aChild);
return PR_TRUE;
}
}
}
}
return PR_FALSE;
}
#endif // MOZ_XUL
nsresult
nsCSSFrameConstructor::ContentInserted(nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer,
nsILayoutHistoryState* aFrameState)
{
AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
NS_PRECONDITION(mUpdateCount != 0,
"Should be in an update while creating frames");
// XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and
// the :empty pseudo-class?
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ContentInserted container=%p child=%p index=%d\n",
static_cast<void*>(aContainer),
static_cast<void*>(aChild),
aIndexInContainer);
if (gReallyNoisyContentUpdates) {
(aContainer ? aContainer : aChild)->List(stdout, 0);
}
}
#endif
nsresult rv = NS_OK;
#ifdef MOZ_XUL
// aIndexInContainer might be bogus here, but it's not used by
// NotifyListBoxBody's CONTENT_INSERTED handling in any case.
if (NotifyListBoxBody(mPresShell->GetPresContext(), aContainer, aChild,
aIndexInContainer,
mDocument, nsnull, CONTENT_INSERTED))
return NS_OK;
#endif // MOZ_XUL
// If we have a null parent, then this must be the document element
// being inserted
if (! aContainer) {
nsIContent *docElement = mDocument->GetRootContent();
if (aChild == docElement) {
NS_PRECONDITION(nsnull == mRootElementFrame, "root element frame already created");
if (!mDocElementContainingBlock)
return NS_OK; // We get into this situation when an XBL binding is asynchronously
// applied to the root tag (e.g., <window> in XUL). It's ok. We can
// just bail here because the root will really be built later during
// InitialReflow.
// Create frames for the document element and its child elements
nsIFrame* docElementFrame;
nsFrameConstructorState state(mPresShell, mFixedContainingBlock, nsnull,
nsnull, aFrameState);
rv = ConstructDocElementFrame(state,
docElement,
mDocElementContainingBlock,
&docElementFrame);
if (NS_SUCCEEDED(rv) && docElementFrame) {
if (mDocElementContainingBlock->GetStateBits() & NS_FRAME_FIRST_REFLOW) {
// Set the initial child list for the parent and wait on the initial
// reflow.
mDocElementContainingBlock->SetInitialChildList(nsnull,
docElementFrame);
} else {
// Whoops, we've already received our initial reflow! Insert the doc.
// element as a child so it reflows (note that containing block is
// empty, so we can simply append).
NS_ASSERTION(mDocElementContainingBlock->GetFirstChild(nsnull) == nsnull,
"Unexpected child of document element containing block");
mDocElementContainingBlock->AppendFrames(nsnull, docElementFrame);
}
InvalidateCanvasIfNeeded(docElementFrame);
#ifdef DEBUG
if (gReallyNoisyContentUpdates) {
nsIFrameDebug* fdbg = do_QueryFrame(docElementFrame);
if (fdbg) {
printf("nsCSSFrameConstructor::ContentInserted: resulting frame model:\n");
fdbg->List(stdout, 0);
}
}
#endif
}
}
// otherwise this is not a child of the root element, and we
// won't let it have a frame.
return NS_OK;
}
// Otherwise, we've got parent content. Find its frame.
nsIFrame* parentFrame = GetFrameFor(aContainer);
if (! parentFrame)
return NS_OK; // XXXwaterson will this break selects? (See ``Here
// we have been notified...'' below.)
// See if we have an XBL insertion point. If so, then that's our
// real parent frame; if not, then the frame hasn't been built yet
// and we just bail.
nsIFrame* insertionPoint;
GetInsertionPoint(parentFrame, aChild, &insertionPoint);
if (! insertionPoint)
return NS_OK; // Don't build the frames.
parentFrame = insertionPoint;
// Find the frame that precedes the insertion point. Walk backwards
// from the parent frame to get the parent content, because if an
// XBL insertion point is involved, we'll need to use _that_ to find
// the preceding frame.
nsIContent* container = parentFrame->GetContent();
ChildIterator first, last;
ChildIterator::Init(container, &first, &last);
ChildIterator iter(first);
if (iter.XBLInvolved() || container != aContainer) {
iter.seek(aChild);
// Don't touch our aIndexInContainer, though it's almost certainly bogus in
// this case. If someone wants to use an index below, they should make
// sure to use the right index (aIndexInContainer vs iter.position()) with
// the right parent node.
} else if (aIndexInContainer != -1) {
// Do things the fast way if we can. The check for -1 is because editor is
// severely broken and calls us directly for native anonymous nodes that it
// creates.
iter.seek(aIndexInContainer);
NS_ASSERTION(*iter == aChild, "Someone screwed up the indexing");
}
#ifdef DEBUG
else {
NS_WARNING("Someone passed native anonymous content directly into frame "
"construction. Stop doing that!");
}
#endif
nsIFrame* prevSibling = FindPreviousSibling(first, iter);
PRBool isAppend = PR_FALSE;
nsIFrame* appendAfterFrame; // This is only looked at when isAppend is true
// Now, find the geometric parent so that we can handle
// continuations properly. Use the prev sibling if we have it;
// otherwise use the next sibling.
if (prevSibling) {
parentFrame = prevSibling->GetParent()->GetContentInsertionFrame();
}
else {
// If there is no previous sibling, then find the frame that follows
nsIFrame* nextSibling = FindNextSibling(iter, last);
if (nextSibling) {
parentFrame = nextSibling->GetParent()->GetContentInsertionFrame();
}
else {
// No previous or next sibling, so treat this like an appended frame.
isAppend = PR_TRUE;
// Get continuation that parents the last child
parentFrame = nsLayoutUtils::GetLastContinuationWithChild(parentFrame);
// Deal with fieldsets
parentFrame = ::GetAdjustedParentFrame(parentFrame,
parentFrame->GetType(),
aChild);
parentFrame =
::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(),
aContainer, parentFrame,
&appendAfterFrame);
}
}
if (parentFrame->GetType() == nsGkAtoms::frameSetFrame &&
IsSpecialFramesetChild(aChild)) {
// Just reframe the parent, since framesets are weird like that.
return RecreateFramesForContent(parentFrame->GetContent());
}
// Don't construct kids of leaves
if (parentFrame->IsLeaf()) {
return NS_OK;
}
#ifdef MOZ_MATHML
if (parentFrame->IsFrameOfType(nsIFrame::eMathML))
return RecreateFramesForContent(parentFrame->GetContent());
#endif
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(parentFrame),
GetFloatContainingBlock(parentFrame),
aFrameState);
// Recover state for the containing block - we need to know if
// it has :first-letter or :first-line style applied to it. The
// reason we care is that the internal structure in these cases
// is not the normal structure and requires custom updating
// logic.
nsIFrame* containingBlock = state.mFloatedItems.containingBlock;
PRBool haveFirstLetterStyle = PR_FALSE;
PRBool haveFirstLineStyle = PR_FALSE;
// In order to shave off some cycles, we only dig up the
// containing block haveFirst* flags if the parent frame where
// the insertion/append is occurring is an inline or block
// container. For other types of containers this isn't relevant.
const nsStyleDisplay* parentDisplay = parentFrame->GetStyleDisplay();
// Examine the parentFrame where the insertion is taking
// place. If it's a certain kind of container then some special
// processing is done.
if ((NS_STYLE_DISPLAY_BLOCK == parentDisplay->mDisplay) ||
(NS_STYLE_DISPLAY_LIST_ITEM == parentDisplay->mDisplay) ||
(NS_STYLE_DISPLAY_INLINE == parentDisplay->mDisplay) ||
(NS_STYLE_DISPLAY_INLINE_BLOCK == parentDisplay->mDisplay)) {
// Recover the special style flags for the containing block
if (containingBlock) {
haveFirstLetterStyle = HasFirstLetterStyle(containingBlock);
haveFirstLineStyle =
ShouldHaveFirstLineStyle(containingBlock->GetContent(),
containingBlock->GetStyleContext());
}
if (haveFirstLetterStyle) {
// Get the correct parentFrame and prevSibling - if a
// letter-frame is present, use its parent.
if (parentFrame->GetType() == nsGkAtoms::letterFrame) {
parentFrame = parentFrame->GetParent();
container = parentFrame->GetContent();
}
// Remove the old letter frames before doing the insertion
RemoveLetterFrames(state.mPresContext, mPresShell,
state.mFrameManager,
state.mFloatedItems.containingBlock);
// Removing the letterframes messes around with the frame tree, removing
// and creating frames. We need to reget our prevsibling.
ChildIterator::Init(container, &first, &last);
if (last.XBLInvolved() || container != aContainer) {
last.seek(aChild);
} else if (aIndexInContainer != -1) {
last.seek(aIndexInContainer);
NS_ASSERTION(*iter == aChild, "Someone screwed up the indexing");
}
prevSibling = FindPreviousSibling(first, last);
}
}
if (!prevSibling) {
// We're inserting the new frame as the first child. See if the
// parent has a :before pseudo-element
nsIFrame* firstChild = parentFrame->GetFirstChild(nsnull);
if (firstChild &&
nsLayoutUtils::IsGeneratedContentFor(aContainer, firstChild,
nsCSSPseudoElements::before)) {
// Insert the new frames after the last continuation of the :before
prevSibling = firstChild->GetTailContinuation();
parentFrame = prevSibling->GetParent();
// We perhaps could leave this true and take the AppendFrames path
// below, but we'd have to update appendAfterFrame and it seems safer
// to force all insert-after-:before cases to take these to take the
// InsertFrames path
isAppend = PR_FALSE;
}
}
FrameConstructionItemList items;
AddFrameConstructionItems(state, aChild, parentFrame, items);
// Perform special check for diddling around with the frames in
// a special inline frame.
// If we're appending before :after content, then we're not really
// appending, so let WipeContainingBlock know that.
if (WipeContainingBlock(state, containingBlock, parentFrame, items,
isAppend && !appendAfterFrame, prevSibling))
return NS_OK;
// if the container is a table and a caption will be appended, it needs to be
// put in the outer table frame's additional child list.
nsFrameItems frameItems, captionItems;
for (FCItemIterator iter(items); !iter.IsDone(); iter.Next()) {
ConstructFramesFromItem(state, iter, parentFrame, frameItems);
}
if (frameItems.childList) {
InvalidateCanvasIfNeeded(frameItems.childList);
if (nsGkAtoms::tableCaptionFrame == frameItems.childList->GetType()) {
NS_ASSERTION(frameItems.childList == frameItems.lastChild ,
"adding a non caption frame to the caption childlist?");
captionItems.AddChild(frameItems.childList);
frameItems = nsFrameItems();
}
}
// process the current pseudo frame state
if (!state.mPseudoFrames.IsEmpty())
ProcessPseudoFrames(state, frameItems);
// If the parent of our current prevSibling is different from the frame we'll
// actually use as the parent, then the calculated insertion point is now
// invalid and as it is unknown where to insert correctly we append instead
// (bug 341858).
// This can affect our appendAfterFrame, but should not have any effect on
// the WipeContainingBlock above, since this should only happen when neither
// parent is a special frame (and in fact, only when one is an outer table
// and one is an inner table or when the parent is a fieldset or fieldset
// content frame).
// XXXbz we should push our frame construction item code up higher, so we
// know what our items are by the time we start figuring out previous
// siblings
if (prevSibling && frameItems.childList &&
frameItems.childList->GetParent() != prevSibling->GetParent()) {
#ifdef DEBUG
nsIFrame* frame1 = frameItems.childList->GetParent();
nsIFrame* frame2 = prevSibling->GetParent();
NS_ASSERTION(!IsFrameSpecial(frame1) && !IsFrameSpecial(frame2),
"Neither should be special");
NS_ASSERTION((frame1->GetType() == nsGkAtoms::tableFrame &&
frame2->GetType() == nsGkAtoms::tableOuterFrame) ||
(frame1->GetType() == nsGkAtoms::tableOuterFrame &&
frame2->GetType() == nsGkAtoms::tableFrame) ||
frame1->GetType() == nsGkAtoms::fieldSetFrame ||
(frame1->GetParent() &&
frame1->GetParent()->GetType() == nsGkAtoms::fieldSetFrame),
"Unexpected frame types");
#endif
prevSibling = nsnull;
isAppend = PR_TRUE;
parentFrame =
::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(),
aContainer,
frameItems.childList->GetParent(),
&appendAfterFrame);
}
if (haveFirstLineStyle && parentFrame == containingBlock) {
// It's possible that the new frame goes into a first-line
// frame. Look at it and see...
if (isAppend) {
// Use append logic when appending
AppendFirstLineFrames(state, containingBlock->GetContent(),
containingBlock, frameItems);
}
else {
// Use more complicated insert logic when inserting
InsertFirstLineFrames(state, aContainer, containingBlock, &parentFrame,
prevSibling, frameItems);
}
}
nsIFrame* const newFrame = frameItems.childList;
if (NS_SUCCEEDED(rv) && newFrame) {
NS_ASSERTION(!captionItems.childList, "leaking caption frames");
// Notify the parent frame
if (isAppend) {
AppendFrames(state, aContainer, parentFrame, frameItems,
appendAfterFrame);
} else {
state.mFrameManager->InsertFrames(parentFrame,
nsnull, prevSibling, newFrame);
}
}
else {
// we might have a caption treat it here
nsIFrame* newCaptionFrame = captionItems.childList;
if (NS_SUCCEEDED(rv) && newCaptionFrame) {
nsIFrame* outerTableFrame;
if (GetCaptionAdjustedParent(parentFrame, newCaptionFrame, &outerTableFrame)) {
// If the parent of our current prevSibling is different from the frame
// we'll actually use as the parent, then the calculated insertion
// point is now invalid (bug 341382).
if (prevSibling && prevSibling->GetParent() != outerTableFrame) {
prevSibling = nsnull;
}
// If the parent is not a outer table frame we will try to add frames
// to a named child list that the parent does not honour and the frames
// will get lost
NS_ASSERTION(nsGkAtoms::tableOuterFrame == outerTableFrame->GetType(),
"Pseudo frame construction failure, "
"a caption can be only a child of a outer table frame");
if (isAppend) {
state.mFrameManager->AppendFrames(outerTableFrame,
nsGkAtoms::captionList,
newCaptionFrame);
}
else {
state.mFrameManager->InsertFrames(outerTableFrame,
nsGkAtoms::captionList,
prevSibling, newCaptionFrame);
}
}
}
}
if (haveFirstLetterStyle) {
// Recover the letter frames for the containing block when
// it has first-letter style.
RecoverLetterFrames(state.mFloatedItems.containingBlock);
}
#ifdef DEBUG
if (gReallyNoisyContentUpdates && parentFrame) {
nsIFrameDebug* fdbg = do_QueryFrame(parentFrame);
if (fdbg) {
printf("nsCSSFrameConstructor::ContentInserted: resulting frame model:\n");
fdbg->List(stdout, 0);
}
}
#endif
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ReinsertContent(nsIContent* aContainer,
nsIContent* aChild)
{
PRInt32 ix = aContainer->IndexOf(aChild);
// XXX For now, do a brute force remove and insert.
// XXXbz this probably doesn't work so well with anonymous content
// XXXbz doesn't this need to do the state-saving stuff that
// RecreateFramesForContent does?
PRBool didReconstruct;
nsresult res = ContentRemoved(aContainer, aChild, ix, &didReconstruct);
if (NS_SUCCEEDED(res) && !didReconstruct) {
// If ContentRemoved just reconstructed everything, there is no need to
// reinsert the content here
res = ContentInserted(aContainer, aChild, ix, nsnull);
}
return res;
}
static void
DoDeletingFrameSubtree(nsFrameManager* aFrameManager,
nsTArray<nsIFrame*>& aDestroyQueue,
nsIFrame* aRemovedFrame,
nsIFrame* aFrame);
static void
DoDeletingOverflowContainers(nsFrameManager* aFrameManager,
nsTArray<nsIFrame*>& aDestroyQueue,
nsIFrame* aRemovedFrame,
nsIFrame* aFrame)
{
// The invariant that "continuing frames should be found as part of the
// walk over the top-most frame's continuing frames" does not hold for
// out-of-flow overflow containers, so we need to walk them too.
// Note that DoDeletingFrameSubtree() skips the child lists where
// overflow containers live so we won't process them twice.
const PRBool orphanSubtree = aRemovedFrame == aFrame;
for (nsIFrame* next = aFrame->GetNextContinuation();
next && (next->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER);
next = next->GetNextContinuation()) {
DoDeletingFrameSubtree(aFrameManager, aDestroyQueue,
orphanSubtree ? next : aRemovedFrame,
next);
}
}
/**
* Called when a frame subtree is about to be deleted. Two important
* things happen:
*
* 1. For each frame in the subtree, we remove the mapping from the
* content object to its frame
*
* 2. For child frames that have been moved out of the flow, we enqueue
* the out-of-flow frame for deletion *if* the out-of-flow frame's
* geometric parent is not in |aRemovedFrame|'s hierarchy (e.g., an
* absolutely positioned element that has been promoted to be a direct
* descendant of an area frame).
*
* Note: this function should only be called by DeletingFrameSubtree()
*
* @param aRemovedFrame this is the frame that was removed from the
* content model. As we recurse we need to remember this so we
* can check if out-of-flow frames are a descendant of the frame
* being removed
* @param aFrame the local subtree that is being deleted. This is initially
* the same as aRemovedFrame, but as we recurse down the tree
* this changes
*/
static void
DoDeletingFrameSubtree(nsFrameManager* aFrameManager,
nsTArray<nsIFrame*>& aDestroyQueue,
nsIFrame* aRemovedFrame,
nsIFrame* aFrame)
{
#undef RECURSE
#define RECURSE(top, child) \
DoDeletingFrameSubtree(aFrameManager, aDestroyQueue, (top), (child)); \
DoDeletingOverflowContainers(aFrameManager, aDestroyQueue, (top), (child));
// Remove the mapping from the content object to its frame.
nsIContent* content = aFrame->GetContent();
if (content) {
aFrameManager->RemoveAsPrimaryFrame(content, aFrame);
aFrameManager->ClearAllUndisplayedContentIn(content);
}
nsIAtom* childListName = nsnull;
PRInt32 childListIndex = 0;
do {
// Walk aFrame's normal flow child frames looking for placeholder frames.
nsIFrame* childFrame = aFrame->GetFirstChild(childListName);
for (; childFrame; childFrame = childFrame->GetNextSibling()) {
NS_ASSERTION(!(childFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW),
"out-of-flow on wrong child list");
if (NS_LIKELY(nsGkAtoms::placeholderFrame != childFrame->GetType())) {
RECURSE(aRemovedFrame, childFrame);
} else {
nsIFrame* outOfFlowFrame =
nsPlaceholderFrame::GetRealFrameForPlaceholder(childFrame);
// Remove the mapping from the out-of-flow frame to its placeholder.
aFrameManager->UnregisterPlaceholderFrame((nsPlaceholderFrame*)childFrame);
// Don't SetOutOfFlowFrame(nsnull) here because the float cache depends
// on it when the float is removed later on, see bug 348688 comment 6.
// Queue the out-of-flow frame to be destroyed only if aRemovedFrame is _not_
// one of its ancestor frames or if it is a popup frame.
// If aRemovedFrame is an ancestor of the out-of-flow frame, then
// the out-of-flow frame will be destroyed by aRemovedFrame.
if (outOfFlowFrame->GetStyleDisplay()->mDisplay == NS_STYLE_DISPLAY_POPUP ||
!nsLayoutUtils::IsProperAncestorFrame(aRemovedFrame, outOfFlowFrame)) {
NS_ASSERTION(aDestroyQueue.IndexOf(outOfFlowFrame) == kNotFound,
"out-of-flow is already in the destroy queue");
aDestroyQueue.AppendElement(outOfFlowFrame);
// Recurse into the out-of-flow, it is now the aRemovedFrame.
RECURSE(outOfFlowFrame, outOfFlowFrame);
}
else {
// Also recurse into the out-of-flow when it's a descendant of aRemovedFrame
// since we don't walk those lists, see |childListName| increment below.
RECURSE(aRemovedFrame, outOfFlowFrame);
}
}
}
// Move to next child list but skip lists with frames we should have
// a placeholder for or that contains only next-in-flow overflow containers
// (which we walk explicitly above).
do {
childListName = aFrame->GetAdditionalChildListName(childListIndex++);
} while (IsOutOfFlowList(childListName) ||
childListName == nsGkAtoms::overflowContainersList ||
childListName == nsGkAtoms::excessOverflowContainersList);
} while (childListName);
}
/**
* Called when a frame is about to be deleted. Calls DoDeletingFrameSubtree()
* for aFrame and each of its continuing frames
*/
static nsresult
DeletingFrameSubtree(nsFrameManager* aFrameManager,
nsIFrame* aFrame)
{
NS_ENSURE_TRUE(aFrame, NS_OK); // XXXldb Remove this sometime in the future.
// If there's no frame manager it's probably because the pres shell is
// being destroyed.
if (NS_UNLIKELY(!aFrameManager)) {
return NS_OK;
}
nsAutoTArray<nsIFrame*, 8> destroyQueue;
// If it's a "special" block-in-inline frame, then we can't really deal.
// That really shouldn't be happening.
NS_ASSERTION(!IsFrameSpecial(aFrame),
"DeletingFrameSubtree on a special frame. Prepare to crash.");
do {
DoDeletingFrameSubtree(aFrameManager, destroyQueue, aFrame, aFrame);
// If it's split, then get the continuing frame. Note that we only do
// this for the top-most frame being deleted. Don't do it if we're
// recursing over a subtree, because those continuing frames should be
// found as part of the walk over the top-most frame's continuing frames.
// Walking them again will make this an N^2/2 algorithm.
// The above is true for normal child next-in-flows but not overflow
// containers which we do walk because they *can* escape the subtree
// we're deleting. We skip [excess]overflowContainersList where
// they live to avoid processing them more than once.
aFrame = aFrame->GetNextContinuation();
} while (aFrame);
// Now destroy any out-of-flow frames that have been enqueued for
// destruction.
for (PRInt32 i = destroyQueue.Length() - 1; i >= 0; --i) {
nsIFrame* outOfFlowFrame = destroyQueue[i];
// Ask the out-of-flow's parent to delete the out-of-flow
// frame from the right list.
aFrameManager->RemoveFrame(outOfFlowFrame->GetParent(),
GetChildListNameFor(outOfFlowFrame),
outOfFlowFrame);
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::RemoveMappingsForFrameSubtree(nsIFrame* aRemovedFrame)
{
NS_ASSERTION(!(aRemovedFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW),
"RemoveMappingsForFrameSubtree doesn't handle out-of-flows");
if (NS_UNLIKELY(mIsDestroyingFrameTree)) {
// The frame tree might not be in a consistent state after
// WillDestroyFrameTree() has been called. Most likely we're destroying
// the pres shell which means the frame manager takes care of clearing all
// mappings so there is no need to walk the frame tree here, bug 372576.
return NS_OK;
}
nsFrameManager *frameManager = mPresShell->FrameManager();
if (nsGkAtoms::placeholderFrame == aRemovedFrame->GetType()) {
nsIFrame *placeholderFrame = aRemovedFrame;
do {
NS_ASSERTION(placeholderFrame->GetType() == nsGkAtoms::placeholderFrame,
"continuation must be of same type");
nsIFrame* outOfFlowFrame =
nsPlaceholderFrame::GetRealFrameForPlaceholder(placeholderFrame);
// Remove the mapping from the out-of-flow frame to its placeholder.
frameManager->UnregisterPlaceholderFrame(
static_cast<nsPlaceholderFrame*>(placeholderFrame));
::DeletingFrameSubtree(frameManager, outOfFlowFrame);
frameManager->RemoveFrame(outOfFlowFrame->GetParent(),
GetChildListNameFor(outOfFlowFrame),
outOfFlowFrame);
placeholderFrame = placeholderFrame->GetNextContinuation();
} while (placeholderFrame);
}
// Save the frame tree's state before deleting it
CaptureStateFor(aRemovedFrame, mTempFrameTreeState);
return ::DeletingFrameSubtree(frameManager, aRemovedFrame);
}
static void UnregisterPlaceholderChain(nsFrameManager* frameManager,
nsPlaceholderFrame* placeholderFrame)
{
// Remove the mapping from the frame to its placeholder
nsPlaceholderFrame* curFrame = placeholderFrame;
do {
frameManager->UnregisterPlaceholderFrame(curFrame);
curFrame->SetOutOfFlowFrame(nsnull);
curFrame = static_cast<nsPlaceholderFrame*>(curFrame->GetNextContinuation());
} while (curFrame);
}
nsresult
nsCSSFrameConstructor::ContentRemoved(nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInContainer,
PRBool* aDidReconstruct)
{
AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
NS_PRECONDITION(mUpdateCount != 0,
"Should be in an update while destroying frames");
*aDidReconstruct = PR_FALSE;
// XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and
// the :empty pseudo-class?
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ContentRemoved container=%p child=%p index=%d\n",
static_cast<void*>(aContainer),
static_cast<void*>(aChild),
aIndexInContainer);
if (gReallyNoisyContentUpdates) {
aContainer->List(stdout, 0);
}
}
#endif
nsFrameManager *frameManager = mPresShell->FrameManager();
nsPresContext *presContext = mPresShell->GetPresContext();
nsresult rv = NS_OK;
// Find the child frame that maps the content
nsIFrame* childFrame =
mPresShell->FrameManager()->GetPrimaryFrameFor(aChild, aIndexInContainer);
if (!childFrame || childFrame->GetContent() != aChild) {
// XXXbz the GetContent() != aChild check is needed due to bug 135040.
// Remove it once that's fixed.
frameManager->ClearUndisplayedContentIn(aChild, aContainer);
}
#ifdef MOZ_XUL
if (NotifyListBoxBody(presContext, aContainer, aChild, aIndexInContainer,
mDocument, childFrame, CONTENT_REMOVED))
return NS_OK;
#endif // MOZ_XUL
if (childFrame) {
InvalidateCanvasIfNeeded(childFrame);
// If the frame we are manipulating is a special frame then do
// something different instead of just inserting newly created
// frames.
// NOTE: if we are in ReinsertContent,
// then do not reframe as we are already doing just that!
if (MaybeRecreateContainerForIBSplitterFrame(childFrame, &rv)) {
*aDidReconstruct = PR_TRUE;
return rv;
}
// Get the childFrame's parent frame
nsIFrame* parentFrame = childFrame->GetParent();
nsIAtom* parentType = parentFrame->GetType();
if (parentType == nsGkAtoms::frameSetFrame &&
IsSpecialFramesetChild(aChild)) {
// Just reframe the parent, since framesets are weird like that.
*aDidReconstruct = PR_TRUE;
return RecreateFramesForContent(parentFrame->GetContent());
}
#ifdef MOZ_MATHML
// If we're a child of MathML, then we should reframe the MathML content.
// If we're non-MathML, then we would be wrapped in a block so we need to
// check our grandparent in that case.
nsIFrame* possibleMathMLAncestor = parentType == nsGkAtoms::blockFrame ?
parentFrame->GetParent() : parentFrame;
if (possibleMathMLAncestor->IsFrameOfType(nsIFrame::eMathML)) {
*aDidReconstruct = PR_TRUE;
return RecreateFramesForContent(possibleMathMLAncestor->GetContent());
}
#endif
// Undo XUL wrapping if it's no longer needed.
// (If we're in the XUL block-wrapping situation, parentFrame is the
// wrapper frame.)
nsIFrame* grandparentFrame = parentFrame->GetParent();
if (grandparentFrame && grandparentFrame->IsBoxFrame() &&
(grandparentFrame->GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK) &&
// check if this frame is the only one needing wrapping
aChild == AnyKidsNeedBlockParent(parentFrame->GetFirstChild(nsnull)) &&
!AnyKidsNeedBlockParent(childFrame->GetNextSibling())) {
*aDidReconstruct = PR_TRUE;
return RecreateFramesForContent(grandparentFrame->GetContent());
}
// Examine the containing-block for the removed content and see if
// :first-letter style applies.
nsIFrame* containingBlock = GetFloatContainingBlock(parentFrame);
PRBool haveFLS = containingBlock && HasFirstLetterStyle(containingBlock);
if (haveFLS) {
// Trap out to special routine that handles adjusting a blocks
// frame tree when first-letter style is present.
#ifdef NOISY_FIRST_LETTER
printf("ContentRemoved: containingBlock=");
nsFrame::ListTag(stdout, containingBlock);
printf(" parentFrame=");
nsFrame::ListTag(stdout, parentFrame);
printf(" childFrame=");
nsFrame::ListTag(stdout, childFrame);
printf("\n");
#endif
// First update the containing blocks structure by removing the
// existing letter frames. This makes the subsequent logic
// simpler.
RemoveLetterFrames(presContext, mPresShell, frameManager,
containingBlock);
// Recover childFrame and parentFrame
childFrame = mPresShell->GetPrimaryFrameFor(aChild);
if (!childFrame || childFrame->GetContent() != aChild) {
// XXXbz the GetContent() != aChild check is needed due to bug 135040.
// Remove it once that's fixed.
frameManager->ClearUndisplayedContentIn(aChild, aContainer);
return NS_OK;
}
parentFrame = childFrame->GetParent();
#ifdef NOISY_FIRST_LETTER
printf(" ==> revised parentFrame=");
nsFrame::ListTag(stdout, parentFrame);
printf(" childFrame=");
nsFrame::ListTag(stdout, childFrame);
printf("\n");
#endif
}
#ifdef DEBUG
if (gReallyNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ContentRemoved: childFrame=");
nsFrame::ListTag(stdout, childFrame);
printf("\n");
nsIFrameDebug* fdbg = do_QueryFrame(parentFrame);
if (fdbg)
fdbg->List(stdout, 0);
}
#endif
// Walk the frame subtree deleting any out-of-flow frames, and
// remove the mapping from content objects to frames
::DeletingFrameSubtree(frameManager, childFrame);
// See if the child frame is an out-of-flow
if (childFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
nsPlaceholderFrame* placeholderFrame =
frameManager->GetPlaceholderFrameFor(childFrame);
NS_ASSERTION(placeholderFrame, "No placeholder for out-of-flow?");
UnregisterPlaceholderChain(frameManager, placeholderFrame);
// Now we remove the out-of-flow frame
// XXX has to be done first for now: for floats, the block's line list
// contains an array of pointers to the placeholder - we have to
// remove the float first (which gets rid of the lines
// reference to the placeholder and float) and then remove the
// placeholder
rv = frameManager->RemoveFrame(parentFrame,
GetChildListNameFor(childFrame),
childFrame);
// Remove the placeholder frame first (XXX second for now) (so
// that it doesn't retain a dangling pointer to memory)
nsIFrame* placeholderParent = placeholderFrame->GetParent();
::DeletingFrameSubtree(frameManager, placeholderFrame);
rv |= frameManager->RemoveFrame(placeholderParent,
nsnull, placeholderFrame);
} else {
// Notify the parent frame that it should delete the frame
// check for a table caption which goes on an additional child list with a different parent
nsIFrame* outerTableFrame;
if (GetCaptionAdjustedParent(parentFrame, childFrame, &outerTableFrame)) {
rv = frameManager->RemoveFrame(outerTableFrame,
nsGkAtoms::captionList,
childFrame);
}
else {
rv = frameManager->RemoveFrame(parentFrame, nsnull, childFrame);
}
}
if (mRootElementFrame == childFrame) {
mRootElementFrame = nsnull;
mRootElementStyleFrame = nsnull;
}
if (haveFLS && mRootElementFrame) {
NS_ASSERTION(containingBlock == GetFloatContainingBlock(parentFrame),
"What happened here?");
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(parentFrame),
containingBlock);
RecoverLetterFrames(containingBlock);
}
#ifdef DEBUG
if (gReallyNoisyContentUpdates && parentFrame) {
nsIFrameDebug* fdbg = do_QueryFrame(parentFrame);
if (fdbg) {
printf("nsCSSFrameConstructor::ContentRemoved: resulting frame model:\n");
fdbg->List(stdout, 0);
}
}
#endif
}
return rv;
}
#ifdef DEBUG
// To ensure that the functions below are only called within
// |ApplyRenderingChangeToTree|.
static PRBool gInApplyRenderingChangeToTree = PR_FALSE;
#endif
static void
DoApplyRenderingChangeToTree(nsIFrame* aFrame,
nsIViewManager* aViewManager,
nsFrameManager* aFrameManager,
nsChangeHint aChange);
/**
* @param aBoundsRect returns the bounds enclosing the areas covered by aFrame and its childre
* This rect is relative to aFrame's parent
*/
static void
UpdateViewsForTree(nsIFrame* aFrame, nsIViewManager* aViewManager,
nsFrameManager* aFrameManager,
nsChangeHint aChange)
{
NS_PRECONDITION(gInApplyRenderingChangeToTree,
"should only be called within ApplyRenderingChangeToTree");
nsIView* view = aFrame->GetView();
if (view) {
if (aChange & nsChangeHint_SyncFrameView) {
nsContainerFrame::SyncFrameViewProperties(aFrame->PresContext(),
aFrame, nsnull, view);
}
}
// now do children of frame
PRInt32 listIndex = 0;
nsIAtom* childList = nsnull;
do {
nsIFrame* child = aFrame->GetFirstChild(childList);
while (child) {
if (!(child->GetStateBits() & NS_FRAME_OUT_OF_FLOW)
|| (child->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER)) {
// only do frames that don't have placeholders
if (nsGkAtoms::placeholderFrame == child->GetType()) { // placeholder
// get out of flow frame and start over there
nsIFrame* outOfFlowFrame =
nsPlaceholderFrame::GetRealFrameForPlaceholder(child);
DoApplyRenderingChangeToTree(outOfFlowFrame, aViewManager,
aFrameManager, aChange);
}
else { // regular frame
UpdateViewsForTree(child, aViewManager, aFrameManager, aChange);
}
}
child = child->GetNextSibling();
}
childList = aFrame->GetAdditionalChildListName(listIndex++);
} while (childList);
}
static void
DoApplyRenderingChangeToTree(nsIFrame* aFrame,
nsIViewManager* aViewManager,
nsFrameManager* aFrameManager,
nsChangeHint aChange)
{
NS_PRECONDITION(gInApplyRenderingChangeToTree,
"should only be called within ApplyRenderingChangeToTree");
for ( ; aFrame; aFrame = nsLayoutUtils::GetNextContinuationOrSpecialSibling(aFrame)) {
// Get view if this frame has one and trigger an update. If the
// frame doesn't have a view, find the nearest containing view
// (adjusting r's coordinate system to reflect the nesting) and
// update there.
UpdateViewsForTree(aFrame, aViewManager, aFrameManager, aChange);
// if frame has view, will already be invalidated
if (aChange & nsChangeHint_RepaintFrame) {
if (aFrame->IsFrameOfType(nsIFrame::eSVG)) {
#ifdef MOZ_SVG
if (!(aFrame->GetStateBits() & NS_STATE_SVG_NONDISPLAY_CHILD)) {
nsSVGOuterSVGFrame *outerSVGFrame = nsSVGUtils::GetOuterSVGFrame(aFrame);
if (outerSVGFrame) {
// marker changes can change the covered region
outerSVGFrame->UpdateAndInvalidateCoveredRegion(aFrame);
}
}
#endif
} else {
aFrame->Invalidate(aFrame->GetOverflowRect());
}
}
}
}
static void
ApplyRenderingChangeToTree(nsPresContext* aPresContext,
nsIFrame* aFrame,
nsChangeHint aChange)
{
nsIPresShell *shell = aPresContext->PresShell();
PRBool isPaintingSuppressed = PR_FALSE;
shell->IsPaintingSuppressed(&isPaintingSuppressed);
if (isPaintingSuppressed) {
// Don't allow synchronous rendering changes when painting is turned off.
aChange = NS_SubtractHint(aChange, nsChangeHint_RepaintFrame);
if (!aChange) {
return;
}
}
// If the frame's background is propagated to an ancestor, walk up to
// that ancestor.
const nsStyleBackground *bg;
while (!nsCSSRendering::FindBackground(aPresContext, aFrame, &bg)) {
aFrame = aFrame->GetParent();
NS_ASSERTION(aFrame, "root frame must paint");
}
nsIViewManager* viewManager = aPresContext->GetViewManager();
// Trigger rendering updates by damaging this frame and any
// continuations of this frame.
// XXX this needs to detect the need for a view due to an opacity change and deal with it...
nsIViewManager::UpdateViewBatch batch(viewManager);
#ifdef DEBUG
gInApplyRenderingChangeToTree = PR_TRUE;
#endif
DoApplyRenderingChangeToTree(aFrame, viewManager, shell->FrameManager(),
aChange);
#ifdef DEBUG
gInApplyRenderingChangeToTree = PR_FALSE;
#endif
batch.EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
}
/**
* This method invalidates the canvas when frames are removed or added for a
* node that might have its background propagated to the canvas, i.e., a
* document root node or an HTML BODY which is a child of the root node.
*
* @param aFrame a frame for a content node about to be removed or a frme that
* was just created for a content node that was inserted.
*/
static void
InvalidateCanvasIfNeeded(nsIFrame* aFrame)
{
NS_ASSERTION(aFrame, "Must have frame!");
// Note that for both in ContentRemoved and ContentInserted the content node
// will still have the right parent pointer, so looking at that is ok.
nsIContent* node = aFrame->GetContent();
nsIContent* parent = node->GetParent();
if (parent) {
// Has a parent; might not be what we want
nsIContent* grandParent = parent->GetParent();
if (grandParent) {
// Has a grandparent, so not what we want
return;
}
// Check whether it's an HTML body
if (node->Tag() != nsGkAtoms::body ||
!node->IsNodeOfType(nsINode::eHTML)) {
return;
}
}
// At this point the node has no parent or it's an HTML <body> child of the
// root. We might not need to invalidate in this case (eg we might be in
// XHTML or something), but chances are we want to. Play it safe. Find the
// frame to invalidate and do it.
nsIFrame *ancestor = aFrame;
const nsStyleBackground *bg;
nsPresContext* presContext = aFrame->PresContext();
while (!nsCSSRendering::FindBackground(presContext, ancestor, &bg)) {
ancestor = ancestor->GetParent();
NS_ASSERTION(ancestor, "canvas must paint");
}
if (ancestor->GetType() == nsGkAtoms::canvasFrame) {
// The canvas frame's dimensions are not meaningful; invalidate the
// viewport instead.
ancestor = ancestor->GetParent();
}
if (ancestor != aFrame) {
// Wrap this in a DEFERRED view update batch so we don't try to
// flush out layout here
nsIViewManager::UpdateViewBatch batch(presContext->GetViewManager());
ApplyRenderingChangeToTree(presContext, ancestor,
nsChangeHint_RepaintFrame);
batch.EndUpdateViewBatch(NS_VMREFRESH_DEFERRED);
}
}
nsresult
nsCSSFrameConstructor::StyleChangeReflow(nsIFrame* aFrame)
{
// If the frame hasn't even received an initial reflow, then don't
// send it a style-change reflow!
if (aFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW)
return NS_OK;
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::StyleChangeReflow: aFrame=");
nsFrame::ListTag(stdout, aFrame);
printf("\n");
}
#endif
// If the frame is part of a split block-in-inline hierarchy, then
// target the style-change reflow at the first ``normal'' ancestor
// so we're sure that the style change will propagate to any
// anonymously created siblings.
if (IsFrameSpecial(aFrame))
aFrame = GetIBContainingBlockFor(aFrame);
do {
mPresShell->FrameNeedsReflow(aFrame, nsIPresShell::eStyleChange,
NS_FRAME_IS_DIRTY);
aFrame = aFrame->GetNextContinuation();
} while (aFrame);
return NS_OK;
}
nsresult
nsCSSFrameConstructor::CharacterDataChanged(nsIContent* aContent,
PRBool aAppend)
{
AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
nsresult rv = NS_OK;
// Find the child frame
nsIFrame* frame = mPresShell->GetPrimaryFrameFor(aContent);
// Notify the first frame that maps the content. It will generate a reflow
// command
// It's possible the frame whose content changed isn't inserted into the
// frame hierarchy yet, or that there is no frame that maps the content
if (nsnull != frame) {
#if 0
NS_FRAME_LOG(NS_FRAME_TRACE_CALLS,
("nsCSSFrameConstructor::CharacterDataChanged: content=%p[%s] subcontent=%p frame=%p",
aContent, ContentTag(aContent, 0),
aSubContent, frame));
#endif
// Special check for text content that is a child of a letter frame. If
// this happens, we should remove the letter frame, do whatever we're
// planning to do with this notification, then put the letter frame back.
// Note that this is basically what ReinsertContent ends up doing; the
// reason we dont' want to call that here is that our text content could be
// native anonymous, in which case ReinsertContent would completely barf on
// it. And reinserting the non-anonymous ancestor would just lead us to
// come back into this notification (e.g. if quotes or counters are
// involved), leading to a loop.
nsIFrame* block = GetFloatContainingBlock(frame);
PRBool haveFirstLetterStyle = PR_FALSE;
if (block) {
// See if the block has first-letter style applied to it.
haveFirstLetterStyle = HasFirstLetterStyle(block);
if (haveFirstLetterStyle) {
RemoveLetterFrames(mPresShell->GetPresContext(), mPresShell,
mPresShell->FrameManager(), block);
// Reget |frame|, since we might have killed it.
// Do we really need to call CharacterDataChanged in this case, though?
frame = mPresShell->GetPrimaryFrameFor(aContent);
NS_ASSERTION(frame, "Should have frame here!");
}
}
frame->CharacterDataChanged(mPresShell->GetPresContext(), aContent,
aAppend);
if (haveFirstLetterStyle) {
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(frame),
block, nsnull);
RecoverLetterFrames(block);
}
}
return rv;
}
nsresult
nsCSSFrameConstructor::ProcessRestyledFrames(nsStyleChangeList& aChangeList)
{
NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
"Someone forgot a script blocker");
PRInt32 count = aChangeList.Count();
if (!count)
return NS_OK;
// Make sure to not rebuild quote or counter lists while we're
// processing restyles
BeginUpdate();
nsPropertyTable *propTable = mPresShell->GetPresContext()->PropertyTable();
// Mark frames so that we skip frames that die along the way, bug 123049.
// A frame can be in the list multiple times with different hints. Further
// optmization is possible if nsStyleChangeList::AppendChange could coalesce
PRInt32 index = count;
while (0 <= --index) {
const nsStyleChangeData* changeData;
aChangeList.ChangeAt(index, &changeData);
if (changeData->mFrame) {
propTable->SetProperty(changeData->mFrame,
nsGkAtoms::changeListProperty,
nsnull, nsnull, nsnull);
}
}
index = count;
while (0 <= --index) {
nsIFrame* frame;
nsIContent* content;
nsChangeHint hint;
aChangeList.ChangeAt(index, frame, content, hint);
if (frame && frame->GetContent() != content) {
// XXXbz this is due to image maps messing with the primary frame map.
// See bug 135040. Remove this block once that's fixed.
frame = nsnull;
if (!(hint & nsChangeHint_ReconstructFrame)) {
continue;
}
}
// skip any frame that has been destroyed due to a ripple effect
if (frame) {
nsresult res;
propTable->GetProperty(frame, nsGkAtoms::changeListProperty, &res);
if (NS_PROPTABLE_PROP_NOT_THERE == res)
continue;
}
if (hint & nsChangeHint_ReconstructFrame) {
RecreateFramesForContent(content);
} else {
NS_ASSERTION(frame, "This shouldn't happen");
#ifdef MOZ_SVG
if (hint & nsChangeHint_UpdateEffects) {
nsSVGEffects::UpdateEffects(frame);
}
#endif
if (hint & nsChangeHint_ReflowFrame) {
StyleChangeReflow(frame);
}
if (hint & (nsChangeHint_RepaintFrame | nsChangeHint_SyncFrameView)) {
ApplyRenderingChangeToTree(mPresShell->GetPresContext(), frame, hint);
}
if (hint & nsChangeHint_UpdateCursor) {
nsIViewManager* viewMgr = mPresShell->GetViewManager();
if (viewMgr)
viewMgr->SynthesizeMouseMove(PR_FALSE);
}
}
}
EndUpdate();
// cleanup references and verify the style tree. Note that the latter needs
// to happen once we've processed the whole list, since until then the tree
// is not in fact in a consistent state.
index = count;
while (0 <= --index) {
const nsStyleChangeData* changeData;
aChangeList.ChangeAt(index, &changeData);
if (changeData->mFrame) {
propTable->DeleteProperty(changeData->mFrame,
nsGkAtoms::changeListProperty);
}
#ifdef DEBUG
// reget frame from content since it may have been regenerated...
if (changeData->mContent) {
nsIFrame* frame = mPresShell->GetPrimaryFrameFor(changeData->mContent);
if (frame) {
mPresShell->FrameManager()->DebugVerifyStyleTree(frame);
}
} else {
NS_WARNING("Unable to test style tree integrity -- no content node");
}
#endif
}
aChangeList.Clear();
return NS_OK;
}
void
nsCSSFrameConstructor::RestyleElement(nsIContent *aContent,
nsIFrame *aPrimaryFrame,
nsChangeHint aMinHint)
{
NS_ASSERTION(aPrimaryFrame == mPresShell->GetPrimaryFrameFor(aContent),
"frame/content mismatch");
if (aPrimaryFrame && aPrimaryFrame->GetContent() != aContent) {
// XXXbz this is due to image maps messing with the primary frame mapping.
// See bug 135040. We can remove this block once that's fixed.
aPrimaryFrame = nsnull;
}
NS_ASSERTION(!aPrimaryFrame || aPrimaryFrame->GetContent() == aContent,
"frame/content mismatch");
if (aMinHint & nsChangeHint_ReconstructFrame) {
RecreateFramesForContent(aContent);
} else if (aPrimaryFrame) {
nsStyleChangeList changeList;
mPresShell->FrameManager()->
ComputeStyleChangeFor(aPrimaryFrame, &changeList, aMinHint);
ProcessRestyledFrames(changeList);
} else {
// no frames, reconstruct for content
MaybeRecreateFramesForContent(aContent);
}
}
void
nsCSSFrameConstructor::RestyleLaterSiblings(nsIContent *aContent)
{
nsIContent *parent = aContent->GetParent();
if (!parent)
return; // root element has no later siblings
for (PRInt32 index = parent->IndexOf(aContent) + 1,
index_end = parent->GetChildCount();
index != index_end; ++index) {
nsIContent *child = parent->GetChildAt(index);
if (!child->IsNodeOfType(nsINode::eELEMENT))
continue;
nsIFrame* primaryFrame = mPresShell->GetPrimaryFrameFor(child);
RestyleElement(child, primaryFrame, NS_STYLE_HINT_NONE);
}
}
nsresult
nsCSSFrameConstructor::ContentStatesChanged(nsIContent* aContent1,
nsIContent* aContent2,
PRInt32 aStateMask)
{
DoContentStateChanged(aContent1, aStateMask);
DoContentStateChanged(aContent2, aStateMask);
return NS_OK;
}
void
nsCSSFrameConstructor::DoContentStateChanged(nsIContent* aContent,
PRInt32 aStateMask)
{
nsStyleSet *styleSet = mPresShell->StyleSet();
nsPresContext *presContext = mPresShell->GetPresContext();
NS_ASSERTION(styleSet, "couldn't get style set");
if (aContent) {
nsChangeHint hint = NS_STYLE_HINT_NONE;
// Any change to a content state that affects which frames we construct
// must lead to a frame reconstruct here if we already have a frame.
// Note that we never decide through non-CSS means to not create frames
// based on content states, so if we already don't have a frame we don't
// need to force a reframe -- if it's needed, the HasStateDependentStyle
// call will handle things.
nsIFrame* primaryFrame = mPresShell->GetPrimaryFrameFor(aContent);
if (primaryFrame) {
// If it's generated content, ignore LOADING/etc state changes on it.
if (!primaryFrame->IsGeneratedContentFrame() &&
(aStateMask & (NS_EVENT_STATE_BROKEN | NS_EVENT_STATE_USERDISABLED |
NS_EVENT_STATE_SUPPRESSED | NS_EVENT_STATE_LOADING))) {
hint = nsChangeHint_ReconstructFrame;
} else {
PRUint8 app = primaryFrame->GetStyleDisplay()->mAppearance;
if (app) {
nsITheme *theme = presContext->GetTheme();
if (theme && theme->ThemeSupportsWidget(presContext,
primaryFrame, app)) {
PRBool repaint = PR_FALSE;
theme->WidgetStateChanged(primaryFrame, app, nsnull, &repaint);
if (repaint) {
NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
}
}
}
}
}
nsReStyleHint rshint =
styleSet->HasStateDependentStyle(presContext, aContent, aStateMask);
if ((aStateMask & NS_EVENT_STATE_HOVER) && rshint != 0) {
++mHoverGeneration;
}
PostRestyleEvent(aContent, rshint, hint);
}
}
nsresult
nsCSSFrameConstructor::AttributeChanged(nsIContent* aContent,
PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
PRInt32 aModType,
PRUint32 aStateMask)
{
nsresult result = NS_OK;
// Hold onto the PresShell to prevent ourselves from being destroyed.
// XXXbz how, exactly, would this attribute change cause us to be
// destroyed from inside this function?
nsCOMPtr<nsIPresShell> shell = mPresShell;
// Get the frame associated with the content which is the highest in the frame tree
nsIFrame* primaryFrame = shell->GetPrimaryFrameFor(aContent);
#if 0
NS_FRAME_LOG(NS_FRAME_TRACE_CALLS,
("HTMLStyleSheet::AttributeChanged: content=%p[%s] frame=%p",
aContent, ContentTag(aContent, 0), frame));
#endif
// the style tag has its own interpretation based on aHint
nsChangeHint hint = aContent->GetAttributeChangeHint(aAttribute, aModType);
PRBool reframe = (hint & nsChangeHint_ReconstructFrame) != 0;
#ifdef MOZ_XUL
// The following listbox widget trap prevents offscreen listbox widget
// content from being removed and re-inserted (which is what would
// happen otherwise).
if (!primaryFrame && !reframe) {
PRInt32 namespaceID;
nsIAtom* tag =
mDocument->BindingManager()->ResolveTag(aContent, &namespaceID);
if (namespaceID == kNameSpaceID_XUL &&
(tag == nsGkAtoms::listitem ||
tag == nsGkAtoms::listcell))
return NS_OK;
}
if (aAttribute == nsGkAtoms::tooltiptext ||
aAttribute == nsGkAtoms::tooltip)
{
nsIRootBox* rootBox = nsIRootBox::GetRootBox(mPresShell);
if (rootBox) {
if (aModType == nsIDOMMutationEvent::REMOVAL)
rootBox->RemoveTooltipSupport(aContent);
if (aModType == nsIDOMMutationEvent::ADDITION)
rootBox->AddTooltipSupport(aContent);
}
}
#endif // MOZ_XUL
if (primaryFrame) {
// See if we have appearance information for a theme.
const nsStyleDisplay* disp = primaryFrame->GetStyleDisplay();
if (disp->mAppearance) {
nsPresContext* presContext = mPresShell->GetPresContext();
nsITheme *theme = presContext->GetTheme();
if (theme && theme->ThemeSupportsWidget(presContext, primaryFrame, disp->mAppearance)) {
PRBool repaint = PR_FALSE;
theme->WidgetStateChanged(primaryFrame, disp->mAppearance, aAttribute, &repaint);
if (repaint)
NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
}
}
// let the frame deal with it now, so we don't have to deal later
result = primaryFrame->AttributeChanged(aNameSpaceID, aAttribute,
aModType);
// XXXwaterson should probably check for special IB siblings
// here, and propagate the AttributeChanged notification to
// them, as well. Currently, inline frames don't do anything on
// this notification, so it's not that big a deal.
}
// See if we can optimize away the style re-resolution -- must be called after
// the frame's AttributeChanged() in case it does something that affects the style
nsFrameManager *frameManager = shell->FrameManager();
nsReStyleHint rshint = frameManager->HasAttributeDependentStyle(aContent,
aAttribute,
aModType,
aStateMask);
PostRestyleEvent(aContent, rshint, hint);
return result;
}
void
nsCSSFrameConstructor::BeginUpdate() {
NS_SuppressFocusEvent();
++mFocusSuppressCount;
++mUpdateCount;
}
void
nsCSSFrameConstructor::EndUpdate()
{
if (mUpdateCount == 1) {
// This is the end of our last update. Before we decrement
// mUpdateCount, recalc quotes and counters as needed.
RecalcQuotesAndCounters();
NS_ASSERTION(mUpdateCount == 1, "Odd update count");
}
--mUpdateCount;
if (mFocusSuppressCount) {
NS_UnsuppressFocusEvent();
--mFocusSuppressCount;
}
}
void
nsCSSFrameConstructor::RecalcQuotesAndCounters()
{
if (mQuotesDirty) {
mQuotesDirty = PR_FALSE;
mQuoteList.RecalcAll();
}
if (mCountersDirty) {
mCountersDirty = PR_FALSE;
mCounterManager.RecalcAll();
}
NS_ASSERTION(!mQuotesDirty, "Quotes updates will be lost");
NS_ASSERTION(!mCountersDirty, "Counter updates will be lost");
}
class nsFocusUnsuppressEvent : public nsRunnable {
public:
NS_DECL_NSIRUNNABLE
nsFocusUnsuppressEvent(PRUint32 aCount) : mCount(aCount) {}
private:
PRUint32 mCount;
};
NS_IMETHODIMP nsFocusUnsuppressEvent::Run()
{
while (mCount) {
--mCount;
NS_UnsuppressFocusEvent();
}
return NS_OK;
}
void
nsCSSFrameConstructor::WillDestroyFrameTree(PRBool aDestroyingPresShell)
{
#if defined(DEBUG_dbaron_off)
mCounterManager.Dump();
#endif
mIsDestroyingFrameTree = PR_TRUE;
// Prevent frame tree destruction from being O(N^2)
mQuoteList.Clear();
mCounterManager.Clear();
// Cancel all pending re-resolves
mRestyleEvent.Revoke();
if (mFocusSuppressCount && aDestroyingPresShell) {
nsRefPtr<nsFocusUnsuppressEvent> ev =
new nsFocusUnsuppressEvent(mFocusSuppressCount);
if (NS_SUCCEEDED(NS_DispatchToCurrentThread(ev))) {
mFocusSuppressCount = 0;
}
}
}
//STATIC
// XXXbz I'd really like this method to go away. Once we have inline-block and
// I can just use that for sized broken images, that can happen, maybe.
void nsCSSFrameConstructor::GetAlternateTextFor(nsIContent* aContent,
nsIAtom* aTag, // content object's tag
nsXPIDLString& aAltText)
{
// The "alt" attribute specifies alternate text that is rendered
// when the image can not be displayed
// If there's no "alt" attribute, and aContent is an input
// element, then use the value of the "value" attribute
if (!aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::alt, aAltText) &&
nsGkAtoms::input == aTag) {
// If there's no "value" attribute either, then use the localized string
// for "Submit" as the alternate text.
if (!aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::value, aAltText)) {
nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES,
"Submit", aAltText);
}
}
}
nsresult
nsCSSFrameConstructor::CreateContinuingOuterTableFrame(nsIPresShell* aPresShell,
nsPresContext* aPresContext,
nsIFrame* aFrame,
nsIFrame* aParentFrame,
nsIContent* aContent,
nsStyleContext* aStyleContext,
nsIFrame** aContinuingFrame)
{
nsIFrame* newFrame = NS_NewTableOuterFrame(aPresShell, aStyleContext);
if (newFrame) {
newFrame->Init(aContent, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
// Create a continuing inner table frame, and if there's a caption then
// replicate the caption
nsFrameItems newChildFrames;
nsIFrame* childFrame = aFrame->GetFirstChild(nsnull);
if (childFrame) {
nsIFrame* continuingTableFrame;
nsresult rv = CreateContinuingFrame(aPresContext, childFrame, newFrame,
&continuingTableFrame);
if (NS_FAILED(rv)) {
newFrame->Destroy();
*aContinuingFrame = nsnull;
return rv;
}
newChildFrames.AddChild(continuingTableFrame);
NS_ASSERTION(!childFrame->GetNextSibling(),"there can be only one inner table frame");
}
// Set the outer table's initial child list
newFrame->SetInitialChildList(nsnull, newChildFrames.childList);
*aContinuingFrame = newFrame;
return NS_OK;
}
else {
*aContinuingFrame = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
}
nsresult
nsCSSFrameConstructor::CreateContinuingTableFrame(nsIPresShell* aPresShell,
nsPresContext* aPresContext,
nsIFrame* aFrame,
nsIFrame* aParentFrame,
nsIContent* aContent,
nsStyleContext* aStyleContext,
nsIFrame** aContinuingFrame)
{
nsIFrame* newFrame = NS_NewTableFrame(aPresShell, aStyleContext);
if (newFrame) {
newFrame->Init(aContent, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
// Replicate any header/footer frames
nsFrameItems childFrames;
nsIFrame* childFrame = aFrame->GetFirstChild(nsnull);
for ( ; childFrame; childFrame = childFrame->GetNextSibling()) {
// See if it's a header/footer, possibly wrapped in a scroll frame.
nsTableRowGroupFrame* rowGroupFrame =
nsTableFrame::GetRowGroupFrame(childFrame);
if (rowGroupFrame) {
// If the row group was continued, then don't replicate it.
nsIFrame* rgNextInFlow = rowGroupFrame->GetNextInFlow();
if (rgNextInFlow) {
rowGroupFrame->SetRepeatable(PR_FALSE);
}
else if (rowGroupFrame->IsRepeatable()) {
// Replicate the header/footer frame.
nsTableRowGroupFrame* headerFooterFrame;
nsFrameItems childItems;
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(newFrame),
nsnull);
headerFooterFrame = static_cast<nsTableRowGroupFrame*>
(NS_NewTableRowGroupFrame(aPresShell, rowGroupFrame->GetStyleContext()));
nsIContent* headerFooter = rowGroupFrame->GetContent();
headerFooterFrame->Init(headerFooter, newFrame, nsnull);
ProcessChildren(state, headerFooter, rowGroupFrame->GetStyleContext(),
headerFooterFrame, PR_TRUE, childItems, PR_FALSE);
NS_ASSERTION(!state.mFloatedItems.childList, "unexpected floated element");
headerFooterFrame->SetInitialChildList(nsnull, childItems.childList);
headerFooterFrame->SetRepeatable(PR_TRUE);
// Table specific initialization
headerFooterFrame->InitRepeatedFrame(aPresContext, rowGroupFrame);
// XXX Deal with absolute and fixed frames...
childFrames.AddChild(headerFooterFrame);
}
}
}
// Set the table frame's initial child list
newFrame->SetInitialChildList(nsnull, childFrames.childList);
*aContinuingFrame = newFrame;
return NS_OK;
}
else {
*aContinuingFrame = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
}
nsresult
nsCSSFrameConstructor::CreateContinuingFrame(nsPresContext* aPresContext,
nsIFrame* aFrame,
nsIFrame* aParentFrame,
nsIFrame** aContinuingFrame,
PRBool aIsFluid)
{
nsIPresShell* shell = aPresContext->PresShell();
nsStyleContext* styleContext = aFrame->GetStyleContext();
nsIFrame* newFrame = nsnull;
nsresult rv = NS_OK;
nsIFrame* nextContinuation = aFrame->GetNextContinuation();
nsIFrame* nextInFlow = aFrame->GetNextInFlow();
// Use the frame type to determine what type of frame to create
nsIAtom* frameType = aFrame->GetType();
nsIContent* content = aFrame->GetContent();
NS_ASSERTION(aFrame->GetSplittableType() != NS_FRAME_NOT_SPLITTABLE,
"why CreateContinuingFrame for a non-splittable frame?");
if (nsGkAtoms::textFrame == frameType) {
newFrame = NS_NewContinuingTextFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::inlineFrame == frameType) {
newFrame = NS_NewInlineFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::blockFrame == frameType) {
newFrame = NS_NewBlockFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
#ifdef MOZ_XUL
} else if (nsGkAtoms::XULLabelFrame == frameType) {
newFrame = NS_NewXULLabelFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
#endif
} else if (nsGkAtoms::columnSetFrame == frameType) {
newFrame = NS_NewColumnSetFrame(shell, styleContext, 0);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::positionedInlineFrame == frameType) {
newFrame = NS_NewPositionedInlineFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::pageFrame == frameType) {
nsIFrame* canvasFrame;
rv = ConstructPageFrame(shell, aPresContext, aParentFrame, aFrame,
newFrame, canvasFrame);
} else if (nsGkAtoms::tableOuterFrame == frameType) {
rv = CreateContinuingOuterTableFrame(shell, aPresContext, aFrame, aParentFrame,
content, styleContext, &newFrame);
} else if (nsGkAtoms::tableFrame == frameType) {
rv = CreateContinuingTableFrame(shell, aPresContext, aFrame, aParentFrame,
content, styleContext, &newFrame);
} else if (nsGkAtoms::tableRowGroupFrame == frameType) {
newFrame = NS_NewTableRowGroupFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::tableRowFrame == frameType) {
newFrame = NS_NewTableRowFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
// Create a continuing frame for each table cell frame
nsFrameItems newChildList;
nsIFrame* cellFrame = aFrame->GetFirstChild(nsnull);
while (cellFrame) {
// See if it's a table cell frame
if (IS_TABLE_CELL(cellFrame->GetType())) {
nsIFrame* continuingCellFrame;
rv = CreateContinuingFrame(aPresContext, cellFrame, newFrame,
&continuingCellFrame);
if (NS_FAILED(rv)) {
nsFrameList tmp(newChildList.childList);
tmp.DestroyFrames();
newFrame->Destroy();
*aContinuingFrame = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
newChildList.AddChild(continuingCellFrame);
}
cellFrame = cellFrame->GetNextSibling();
}
// Set the table cell's initial child list
newFrame->SetInitialChildList(nsnull, newChildList.childList);
}
} else if (IS_TABLE_CELL(frameType)) {
// Warning: If you change this and add a wrapper frame around table cell
// frames, make sure Bug 368554 doesn't regress!
// See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.
newFrame = NS_NewTableCellFrame(shell, styleContext, IsBorderCollapse(aParentFrame));
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
// Create a continuing area frame
nsIFrame* continuingBlockFrame;
nsIFrame* blockFrame = aFrame->GetFirstChild(nsnull);
rv = CreateContinuingFrame(aPresContext, blockFrame, newFrame,
&continuingBlockFrame);
if (NS_FAILED(rv)) {
newFrame->Destroy();
*aContinuingFrame = nsnull;
return rv;
}
// Set the table cell's initial child list
newFrame->SetInitialChildList(nsnull, continuingBlockFrame);
}
} else if (nsGkAtoms::lineFrame == frameType) {
newFrame = NS_NewFirstLineFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::letterFrame == frameType) {
newFrame = NS_NewFirstLetterFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else if (nsGkAtoms::imageFrame == frameType) {
newFrame = NS_NewImageFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
}
} else if (nsGkAtoms::imageControlFrame == frameType) {
newFrame = NS_NewImageControlFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
}
} else if (nsGkAtoms::placeholderFrame == frameType) {
// create a continuing out of flow frame
nsIFrame* oofFrame = nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame);
nsIFrame* oofContFrame;
rv = CreateContinuingFrame(aPresContext, oofFrame, aParentFrame, &oofContFrame);
if (NS_FAILED(rv)) {
*aContinuingFrame = nsnull;
return rv;
}
// create a continuing placeholder frame
rv = CreatePlaceholderFrameFor(shell, content, oofContFrame, styleContext,
aParentFrame, aFrame, &newFrame);
if (NS_FAILED(rv)) {
oofContFrame->Destroy();
*aContinuingFrame = nsnull;
return rv;
}
} else if (nsGkAtoms::fieldSetFrame == frameType) {
newFrame = NS_NewFieldSetFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
// Create a continuing area frame
// XXXbz we really shouldn't have to do this by hand!
nsIFrame* continuingBlockFrame;
nsIFrame* blockFrame = GetFieldSetBlockFrame(aFrame);
rv = CreateContinuingFrame(aPresContext, blockFrame, newFrame,
&continuingBlockFrame);
if (NS_FAILED(rv)) {
newFrame->Destroy();
*aContinuingFrame = nsnull;
return rv;
}
// Set the fieldset's initial child list
newFrame->SetInitialChildList(nsnull, continuingBlockFrame);
}
} else if (nsGkAtoms::legendFrame == frameType) {
newFrame = NS_NewLegendFrame(shell, styleContext);
if (newFrame) {
newFrame->Init(content, aParentFrame, aFrame);
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
}
} else {
NS_NOTREACHED("unexpected frame type");
*aContinuingFrame = nsnull;
return NS_ERROR_UNEXPECTED;
}
*aContinuingFrame = newFrame;
if (!newFrame) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Init() set newFrame to be a fluid continuation of aFrame.
// If we want a non-fluid continuation, we need to call SetPrevContinuation()
// to reset NS_FRAME_IS_FLUID_CONTINUATION.
if (!aIsFluid) {
newFrame->SetPrevContinuation(aFrame);
}
// A continuation of generated content is also generated content
if (aFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT) {
newFrame->AddStateBits(NS_FRAME_GENERATED_CONTENT);
}
// A continuation of an out-of-flow is also an out-of-flow
if (aFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
newFrame->AddStateBits(NS_FRAME_OUT_OF_FLOW);
}
if (nextInFlow) {
nextInFlow->SetPrevInFlow(newFrame);
newFrame->SetNextInFlow(nextInFlow);
} else if (nextContinuation) {
nextContinuation->SetPrevContinuation(newFrame);
newFrame->SetNextContinuation(nextContinuation);
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::ReplicateFixedFrames(nsPageContentFrame* aParentFrame)
{
// Now deal with fixed-pos things.... They should appear on all pages,
// so we want to move over the placeholders when processing the child
// of the pageContentFrame.
nsIFrame* prevPageContentFrame = aParentFrame->GetPrevInFlow();
if (!prevPageContentFrame) {
return NS_OK;
}
nsIFrame* canvasFrame = aParentFrame->GetFirstChild(nsnull);
nsIFrame* prevCanvasFrame = prevPageContentFrame->GetFirstChild(nsnull);
if (!canvasFrame || !prevCanvasFrame) {
// document's root element frame missing
return NS_ERROR_UNEXPECTED;
}
nsFrameItems fixedPlaceholders;
nsIFrame* firstFixed = prevPageContentFrame->GetFirstChild(nsGkAtoms::fixedList);
if (!firstFixed) {
return NS_OK;
}
// Don't allow abs-pos descendants of the fixed content to escape the content.
// This should not normally be possible (because fixed-pos elements should
// be absolute containers) but fixed-pos tables currently aren't abs-pos
// containers.
nsFrameConstructorState state(mPresShell, aParentFrame,
nsnull,
mRootElementFrame);
// Iterate across fixed frames and replicate each whose placeholder is a
// descendant of aFrame. (We don't want to explicitly copy placeholders that
// are within fixed frames, because that would cause duplicates on the new
// page - bug 389619)
for (nsIFrame* fixed = firstFixed; fixed; fixed = fixed->GetNextSibling()) {
nsIFrame* prevPlaceholder = nsnull;
mPresShell->GetPlaceholderFrameFor(fixed, &prevPlaceholder);
if (prevPlaceholder &&
nsLayoutUtils::IsProperAncestorFrame(prevCanvasFrame, prevPlaceholder)) {
nsresult rv = ConstructFrame(state, fixed->GetContent(),
canvasFrame, fixedPlaceholders);
NS_ENSURE_SUCCESS(rv, rv);
}
}
// Add the placeholders to our primary child list.
// XXXbz this is a little screwed up, since the fixed frames will have
// broken auto-positioning. Oh, well.
NS_ASSERTION(!canvasFrame->GetFirstChild(nsnull),
"leaking frames; doc root continuation must be empty");
canvasFrame->SetInitialChildList(nsnull, fixedPlaceholders.childList);
return NS_OK;
}
static PRBool
IsBindingAncestor(nsIContent* aContent, nsIContent* aBindingRoot)
{
while (PR_TRUE) {
// Native-anonymous content doesn't contain insertion points, so
// we don't need to search through it.
if (aContent->IsRootOfNativeAnonymousSubtree())
return PR_FALSE;
nsIContent* bindingParent = aContent->GetBindingParent();
if (!bindingParent)
return PR_FALSE;
if (bindingParent == aBindingRoot)
return PR_TRUE;
aContent = bindingParent;
}
}
// Helper function that searches the immediate child frames
// (and their children if the frames are "special")
// for a frame that maps the specified content object
nsIFrame*
nsCSSFrameConstructor::FindFrameWithContent(nsFrameManager* aFrameManager,
nsIFrame* aParentFrame,
nsIContent* aParentContent,
nsIContent* aContent,
nsFindFrameHint* aHint)
{
NS_PRECONDITION(aParentFrame, "Must have a frame");
#ifdef NOISY_FINDFRAME
FFWC_totalCount++;
printf("looking for content=%p, given aParentFrame %p parentContent %p, hint is %s\n",
aContent, aParentFrame, aParentContent, aHint ? "set" : "NULL");
#endif
// Search for the frame in each child list that aParentFrame supports.
nsIAtom* listName = nsnull;
PRInt32 listIndex = 0;
PRBool searchAgain;
do {
#ifdef NOISY_FINDFRAME
FFWC_doLoop++;
#endif
nsIFrame* kidFrame = nsnull;
searchAgain = PR_FALSE;
// if we were given an hint, try to use it here to find a good
// previous frame to start our search (|kidFrame|).
if (aHint) {
#ifdef NOISY_FINDFRAME
printf(" hint frame is %p\n", aHint->mPrimaryFrameForPrevSibling);
#endif
// start with the primary frame for aContent's previous sibling
kidFrame = aHint->mPrimaryFrameForPrevSibling;
// But if it's out of flow, start from its placeholder.
if (kidFrame && (kidFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
kidFrame = aFrameManager->GetPlaceholderFrameFor(kidFrame);
}
if (kidFrame) {
// then use the next sibling frame as our starting point
if (kidFrame->GetNextSibling()) {
kidFrame = kidFrame->GetNextSibling();
}
else {
// The hint frame had no next sibling. Try the next-in-flow or
// special sibling of the parent of the hint frame (or its
// associated placeholder).
nsIFrame *parentFrame = kidFrame->GetParent();
kidFrame = nsnull;
if (parentFrame) {
parentFrame = nsLayoutUtils::GetNextContinuationOrSpecialSibling(parentFrame);
}
if (parentFrame) {
// Found it, continue the search with its first child.
kidFrame = parentFrame->GetFirstChild(listName);
// Leave |aParentFrame| as-is, since the only time we'll
// reuse it is if the hint fails.
}
}
#ifdef NOISY_FINDFRAME
printf(" hint gives us kidFrame=%p with parent frame %p content %p\n",
kidFrame, aParentFrame, aParentContent);
#endif
}
}
if (!kidFrame) { // we didn't have enough info to prune, start searching from the beginning
kidFrame = aParentFrame->GetFirstChild(listName);
}
while (kidFrame) {
// See if the child frame points to the content object we're
// looking for
nsIContent* kidContent = kidFrame->GetContent();
if (kidContent == aContent) {
// We found a match. Return the out-of-flow if it's a placeholder.
return nsPlaceholderFrame::GetRealFrameFor(kidFrame);
}
// only do this if there is content
if (kidContent) {
// We search the immediate children only, but if the child frame has
// the same content pointer as its parent then we need to search its
// child frames, too.
// We also need to search if the child content is anonymous and scoped
// to the parent content.
// XXXldb What makes us continue the search once we're inside
// the anonymous subtree?
if (aParentContent == kidContent ||
(aParentContent && IsBindingAncestor(kidContent, aParentContent))) {
#ifdef NOISY_FINDFRAME
FFWC_recursions++;
printf(" recursing with new parent set to kidframe=%p, parentContent=%p\n",
kidFrame, aParentContent);
#endif
nsIFrame* matchingFrame =
FindFrameWithContent(aFrameManager,
nsPlaceholderFrame::GetRealFrameFor(kidFrame),
aParentContent, aContent, nsnull);
if (matchingFrame) {
return matchingFrame;
}
}
}
kidFrame = kidFrame->GetNextSibling();
#ifdef NOISY_FINDFRAME
if (kidFrame) {
FFWC_doSibling++;
printf(" searching sibling frame %p\n", kidFrame);
}
#endif
}
if (aHint) {
// If we get here, and we had a hint, then we didn't find a frame.
// The hint may have been a frame whose location in the frame tree
// doesn't match the location of its corresponding element in the
// DOM tree, e.g. a floated or absolutely positioned frame, or e.g.
// a <col> frame, in which case we'd be off in the weeds looking
// through something other than the primary frame list.
// Reboot the search from scratch, without the hint, but using the
// null child list again.
aHint = nsnull;
searchAgain = PR_TRUE;
}
else {
do {
listName = aParentFrame->GetAdditionalChildListName(listIndex++);
} while (IsOutOfFlowList(listName));
}
} while (listName || searchAgain);
return nsnull;
}
// Request to find the primary frame associated with a given content object.
// This is typically called by the pres shell when there is no mapping in
// the pres shell hash table
nsresult
nsCSSFrameConstructor::FindPrimaryFrameFor(nsFrameManager* aFrameManager,
nsIContent* aContent,
nsIFrame** aFrame,
nsFindFrameHint* aHint)
{
NS_ASSERTION(aFrameManager && aContent && aFrame, "bad arg");
*aFrame = nsnull; // initialize OUT parameter
// We want to be able to quickly map from a content object to its frame,
// but we also want to keep the hash table small. Therefore, many frames
// are not added to the hash table when they're first created:
// - text frames
// - inline frames (often things like FONT and B)
// - BR frames
// - internal table frames (row-group, row, cell, col-group, col)
//
// That means we need to need to search for the frame
nsIFrame* parentFrame; // this pointer is used to iterate across all frames that map to parentContent
// Get the frame that corresponds to the parent content object.
// Note that this may recurse indirectly, because the pres shell will
// call us back if there is no mapping in the hash table
nsCOMPtr<nsIContent> parentContent = aContent->GetParent(); // Get this once
if (parentContent) {
parentFrame = aFrameManager->GetPrimaryFrameFor(parentContent, -1);
while (parentFrame) {
// Search the child frames for a match
*aFrame = FindFrameWithContent(aFrameManager, parentFrame,
parentContent, aContent, aHint);
#ifdef NOISY_FINDFRAME
printf("FindFrameWithContent returned %p\n", *aFrame);
#endif
#ifdef DEBUG
// if we're given a hint and we were told to verify, then compare the resulting frame with
// the frame we get by calling FindFrameWithContent *without* the hint.
// Assert if they do not match
// Note that this makes finding frames *slower* than it was before the fix.
if (gVerifyFastFindFrame && aHint) {
#ifdef NOISY_FINDFRAME
printf("VERIFYING...\n");
#endif
nsIFrame *verifyTestFrame =
FindFrameWithContent(aFrameManager, parentFrame,
parentContent, aContent, nsnull);
#ifdef NOISY_FINDFRAME
printf("VERIFY returned %p\n", verifyTestFrame);
#endif
NS_ASSERTION(verifyTestFrame == *aFrame, "hint shortcut found wrong frame");
}
#endif
// If we found a match, then add a mapping to the hash table so
// next time this will be quick
if (*aFrame) {
aFrameManager->SetPrimaryFrameFor(aContent, *aFrame);
break;
}
// We didn't find a matching frame. If parentFrame has a next-in-flow
// or special sibling, then continue looking there.
parentFrame = nsLayoutUtils::GetNextContinuationOrSpecialSibling(parentFrame);
#ifdef NOISY_FINDFRAME
if (parentFrame) {
FFWC_nextInFlows++;
printf(" searching NIF frame %p\n", parentFrame);
}
#endif
}
}
#ifdef NOISY_FINDFRAME
printf("%10s %10s %10s %10s %10s\n",
"total", "doLoop", "doSibling", "recur", "nextIF");
printf("%10d %10d %10d %10d %10d\n",
FFWC_totalCount, FFWC_doLoop, FFWC_doSibling, FFWC_recursions,
FFWC_nextInFlows);
#endif
return NS_OK;
}
nsresult
nsCSSFrameConstructor::GetInsertionPoint(nsIFrame* aParentFrame,
nsIContent* aChildContent,
nsIFrame** aInsertionPoint,
PRBool* aMultiple)
{
// Make the insertion point be the parent frame by default, in case
// we have to bail early.
*aInsertionPoint = aParentFrame;
nsIContent* container = aParentFrame->GetContent();
if (!container)
return NS_OK;
nsBindingManager *bindingManager = mDocument->BindingManager();
nsIContent* insertionElement;
if (aChildContent) {
// We've got an explicit insertion child. Check to see if it's
// anonymous.
if (aChildContent->GetBindingParent() == container) {
// This child content is anonymous. Don't use the insertion
// point, since that's only for the explicit kids.
return NS_OK;
}
PRUint32 index;
insertionElement = bindingManager->GetInsertionPoint(container,
aChildContent,
&index);
}
else {
PRBool multiple;
PRUint32 index;
insertionElement = bindingManager->GetSingleInsertionPoint(container,
&index,
&multiple);
if (multiple && aMultiple)
*aMultiple = multiple; // Record the fact that filters are in use.
}
if (insertionElement) {
nsIFrame* insertionPoint = mPresShell->GetPrimaryFrameFor(insertionElement);
if (insertionPoint) {
// Use the content insertion frame of the insertion point.
insertionPoint = insertionPoint->GetContentInsertionFrame();
if (insertionPoint && insertionPoint != aParentFrame)
GetInsertionPoint(insertionPoint, aChildContent, aInsertionPoint, aMultiple);
}
else {
// There was no frame created yet for the insertion point.
*aInsertionPoint = nsnull;
}
}
// fieldsets have multiple insertion points. Note that we might
// have to look at insertionElement here...
if (aMultiple && !*aMultiple) {
nsIContent* content = insertionElement ? insertionElement : container;
if (content->IsNodeOfType(nsINode::eHTML) &&
content->Tag() == nsGkAtoms::fieldset) {
*aMultiple = PR_TRUE;
}
}
return NS_OK;
}
// Capture state for the frame tree rooted at the frame associated with the
// content object, aContent
nsresult
nsCSSFrameConstructor::CaptureStateForFramesOf(nsIContent* aContent,
nsILayoutHistoryState* aHistoryState)
{
nsIFrame* frame = mPresShell->GetPrimaryFrameFor(aContent);
if (frame) {
CaptureStateFor(frame, aHistoryState);
}
return NS_OK;
}
// Capture state for the frame tree rooted at aFrame.
nsresult
nsCSSFrameConstructor::CaptureStateFor(nsIFrame* aFrame,
nsILayoutHistoryState* aHistoryState)
{
if (aFrame && aHistoryState) {
mPresShell->FrameManager()->CaptureFrameState(aFrame, aHistoryState);
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::MaybeRecreateFramesForContent(nsIContent* aContent)
{
nsresult result = NS_OK;
nsFrameManager *frameManager = mPresShell->FrameManager();
nsStyleContext *oldContext = frameManager->GetUndisplayedContent(aContent);
if (oldContext) {
// The parent has a frame, so try resolving a new context.
nsRefPtr<nsStyleContext> newContext = mPresShell->StyleSet()->
ResolveStyleFor(aContent, oldContext->GetParent());
frameManager->ChangeUndisplayedContent(aContent, newContext);
if (newContext->GetStyleDisplay()->mDisplay != NS_STYLE_DISPLAY_NONE) {
result = RecreateFramesForContent(aContent);
}
}
return result;
}
PRBool
nsCSSFrameConstructor::MaybeRecreateContainerForIBSplitterFrame(nsIFrame* aFrame,
nsresult* aResult)
{
NS_PRECONDITION(aFrame, "Must have a frame");
NS_PRECONDITION(aFrame->GetParent(), "Frame shouldn't be root");
NS_PRECONDITION(aResult, "Null out param?");
NS_PRECONDITION(aFrame == aFrame->GetFirstContinuation(),
"aFrame not the result of GetPrimaryFrameFor()?");
if (IsFrameSpecial(aFrame)) {
// The removal functions can't handle removal of an {ib} split directly; we
// need to rebuild the containing block.
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::MaybeRecreateContainerForIBSplitterFrame: "
"frame=");
nsFrame::ListTag(stdout, aFrame);
printf(" is special\n");
}
#endif
*aResult = ReframeContainingBlock(aFrame);
return PR_TRUE;
}
// We might still need to reconstruct things if the parent of aFrame is
// special, since in that case the removal of aFrame might affect the
// splitting of its parent.
nsIFrame* parent = aFrame->GetParent();
if (!IsFrameSpecial(parent)) {
return PR_FALSE;
}
// If aFrame is an inline, then it cannot possibly have caused the splitting.
// If the frame is being reconstructed and being changed to a block, the
// ContentInserted call will handle the containing block reframe. So in this
// case, we don't need to reframe.
if (IsInlineOutside(aFrame)) {
return PR_FALSE;
}
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::MaybeRecreateContainerForIBSplitterFrame: "
"frame=");
nsFrame::ListTag(stdout, parent);
printf(" is special\n");
}
#endif
*aResult = ReframeContainingBlock(parent);
return PR_TRUE;
}
nsresult
nsCSSFrameConstructor::RecreateFramesForContent(nsIContent* aContent)
{
// If there is no document, we don't want to recreate frames for it. (You
// shouldn't generally be giving this method content without a document
// anyway).
// Rebuilding the frame tree can have bad effects, especially if it's the
// frame tree for chrome (see bug 157322).
NS_ENSURE_TRUE(aContent->GetDocument(), NS_ERROR_FAILURE);
// Is the frame `special'? If so, we need to reframe the containing
// block *here*, rather than trying to remove and re-insert the
// content (which would otherwise result in *two* nested reframe
// containing block from ContentRemoved() and ContentInserted(),
// below!). We'd really like to optimize away one of those
// containing block reframes, hence the code here.
nsIFrame* frame = mPresShell->GetPrimaryFrameFor(aContent);
if (frame && frame->IsFrameOfType(nsIFrame::eMathML)) {
// Reframe the topmost MathML element to prevent exponential blowup
// (see bug 397518)
while (PR_TRUE) {
nsIContent* parentContent = aContent->GetParent();
nsIFrame* parentContentFrame = mPresShell->GetPrimaryFrameFor(parentContent);
if (!parentContentFrame || !parentContentFrame->IsFrameOfType(nsIFrame::eMathML))
break;
aContent = parentContent;
frame = parentContentFrame;
}
}
if (frame) {
nsIFrame* nonGeneratedAncestor = nsLayoutUtils::GetNonGeneratedAncestor(frame);
if (nonGeneratedAncestor->GetContent() != aContent) {
return RecreateFramesForContent(nonGeneratedAncestor->GetContent());
}
}
nsresult rv = NS_OK;
if (frame && MaybeRecreateContainerForIBSplitterFrame(frame, &rv)) {
return rv;
}
nsCOMPtr<nsIContent> container = aContent->GetParent();
if (container) {
// XXXbz what if this is anonymous content?
PRInt32 indexInContainer = container->IndexOf(aContent);
// Before removing the frames associated with the content object,
// ask them to save their state onto a temporary state object.
CaptureStateForFramesOf(aContent, mTempFrameTreeState);
// Remove the frames associated with the content object on which
// the attribute change occurred.
PRBool didReconstruct;
rv = ContentRemoved(container, aContent, indexInContainer, &didReconstruct);
if (NS_SUCCEEDED(rv) && !didReconstruct) {
// Now, recreate the frames associated with this content object. If
// ContentRemoved triggered reconstruction, then we don't need to do this
// because the frames will already have been built.
rv = ContentInserted(container, aContent,
indexInContainer, mTempFrameTreeState);
}
} else {
// The content is the root node, so just rebuild the world.
ReconstructDocElementHierarchy();
}
#ifdef ACCESSIBILITY
if (mPresShell->IsAccessibilityActive()) {
PRUint32 event;
if (frame) {
nsIFrame *newFrame = mPresShell->GetPrimaryFrameFor(aContent);
event = newFrame ? PRUint32(nsIAccessibleEvent::EVENT_ASYNCH_SIGNIFICANT_CHANGE) :
PRUint32(nsIAccessibleEvent::EVENT_ASYNCH_HIDE);
}
else {
event = nsIAccessibleEvent::EVENT_ASYNCH_SHOW;
}
// A significant enough change occured that this part
// of the accessible tree is no longer valid.
nsCOMPtr<nsIAccessibilityService> accService =
do_GetService("@mozilla.org/accessibilityService;1");
if (accService) {
accService->InvalidateSubtreeFor(mPresShell, aContent, event);
}
}
#endif
return rv;
}
//////////////////////////////////////////////////////////////////////
// Block frame construction code
already_AddRefed<nsStyleContext>
nsCSSFrameConstructor::GetFirstLetterStyle(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
if (aContent) {
return mPresShell->StyleSet()->
ResolvePseudoStyleFor(aContent,
nsCSSPseudoElements::firstLetter, aStyleContext);
}
return nsnull;
}
already_AddRefed<nsStyleContext>
nsCSSFrameConstructor::GetFirstLineStyle(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
if (aContent) {
return mPresShell->StyleSet()->
ResolvePseudoStyleFor(aContent,
nsCSSPseudoElements::firstLine, aStyleContext);
}
return nsnull;
}
// Predicate to see if a given content (block element) has
// first-letter style applied to it.
PRBool
nsCSSFrameConstructor::ShouldHaveFirstLetterStyle(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
return nsLayoutUtils::HasPseudoStyle(aContent, aStyleContext,
nsCSSPseudoElements::firstLetter,
mPresShell->GetPresContext());
}
PRBool
nsCSSFrameConstructor::HasFirstLetterStyle(nsIFrame* aBlockFrame)
{
NS_PRECONDITION(aBlockFrame, "Need a frame");
NS_ASSERTION(nsLayoutUtils::GetAsBlock(aBlockFrame),
"Not a block frame?");
return (aBlockFrame->GetStateBits() & NS_BLOCK_HAS_FIRST_LETTER_STYLE) != 0;
}
PRBool
nsCSSFrameConstructor::ShouldHaveFirstLineStyle(nsIContent* aContent,
nsStyleContext* aStyleContext)
{
PRBool hasFirstLine =
nsLayoutUtils::HasPseudoStyle(aContent, aStyleContext,
nsCSSPseudoElements::firstLine,
mPresShell->GetPresContext());
if (hasFirstLine) {
// But disable for fieldsets
PRInt32 namespaceID;
nsIAtom* tag = mDocument->BindingManager()->ResolveTag(aContent,
&namespaceID);
// This check must match the one in FindHTMLData.
hasFirstLine = tag != nsGkAtoms::fieldset ||
(namespaceID != kNameSpaceID_XHTML &&
!aContent->IsNodeOfType(nsINode::eHTML));
}
return hasFirstLine;
}
void
nsCSSFrameConstructor::ShouldHaveSpecialBlockStyle(nsIContent* aContent,
nsStyleContext* aStyleContext,
PRBool* aHaveFirstLetterStyle,
PRBool* aHaveFirstLineStyle)
{
*aHaveFirstLetterStyle =
ShouldHaveFirstLetterStyle(aContent, aStyleContext);
*aHaveFirstLineStyle =
ShouldHaveFirstLineStyle(aContent, aStyleContext);
}
nsresult
nsCSSFrameConstructor::ConstructFramesFromItemList(nsFrameConstructorState& aState,
FrameConstructionItemList& aItems,
nsIFrame* aParentFrame,
nsFrameItems& aFrameItems)
{
// save the incoming pseudo frame state
nsPseudoFrames priorPseudoFrames;
aState.mPseudoFrames.Reset(&priorPseudoFrames);
for (FCItemIterator iter(aItems); !iter.IsDone(); iter.Next()) {
nsresult rv =
ConstructFramesFromItem(aState, iter, aParentFrame, aFrameItems);
NS_ENSURE_SUCCESS(rv, rv);
}
NS_ASSERTION(!aState.mHavePendingPopupgroup,
"Should have proccessed it by now");
// process the current pseudo frame state
if (!aState.mPseudoFrames.IsEmpty()) {
ProcessPseudoFrames(aState, aFrameItems);
}
// restore the incoming pseudo frame state
aState.mPseudoFrames = priorPseudoFrames;
return NS_OK;
}
/**
* Request to process the child content elements and create frames.
*
* @param aContent the content object whose child elements to process
* @param aFrame the frame associated with aContent. This will be the
* parent frame (both content and geometric) for the flowed
* child frames
*/
nsresult
nsCSSFrameConstructor::ProcessChildren(nsFrameConstructorState& aState,
nsIContent* aContent,
nsStyleContext* aStyleContext,
nsIFrame* aFrame,
const PRBool aCanHaveGeneratedContent,
nsFrameItems& aFrameItems,
const PRBool aAllowBlockStyles)
{
NS_PRECONDITION(aFrame, "Must have parent frame here");
NS_PRECONDITION(aFrame->GetContentInsertionFrame() == aFrame,
"Parent frame in ProcessChildren should be its own "
"content insertion frame");
// XXXbz ideally, this would do all the pushing of various
// containing blocks as needed, so callers don't have to do it...
PRBool haveFirstLetterStyle = PR_FALSE, haveFirstLineStyle = PR_FALSE;
if (aAllowBlockStyles) {
ShouldHaveSpecialBlockStyle(aContent, aStyleContext, &haveFirstLetterStyle,
&haveFirstLineStyle);
}
// The logic here needs to match the logic in GetFloatContainingBlock()
nsFrameConstructorSaveState floatSaveState;
if (aFrame->IsFrameOfType(nsIFrame::eMathML) ||
aFrame->IsBoxFrame()) {
aState.PushFloatContainingBlock(nsnull, floatSaveState);
} else if (aFrame->IsFloatContainingBlock()) {
aState.PushFloatContainingBlock(aFrame, floatSaveState);
}
FrameConstructionItemList itemsToConstruct;
nsresult rv = NS_OK;
if (aFrame == mRootElementFrame) {
// Create any anonymous frames the initial containing block frame requires.
// This must happen before the rest of ProcessChildren to ensure that
// popups are never constructed before the popupset.
nsAutoTArray<nsIContent*, 4> anonymousItems;
GetAnonymousContent(aContent, aFrame, anonymousItems);
for (PRUint32 i = 0; i < anonymousItems.Length(); ++i) {
#ifdef DEBUG
nsIAnonymousContentCreator* creator = do_QueryFrame(aFrame);
NS_ASSERTION(!creator || !creator->CreateFrameFor(anonymousItems[i]),
"If you need to use CreateFrameFor, you need to call "
"CreateAnonymousFrames manually and not follow the standard "
"ProcessChildren() codepath for this frame");
#endif
AddFrameConstructionItems(aState, anonymousItems[i], aFrame,
itemsToConstruct);
}
}
if (!aFrame->IsLeaf() &&
mDocument->BindingManager()->ShouldBuildChildFrames(aContent)) {
// :before/:after content should have the same style context parent
// as normal kids.
// Note that we don't use this style context for looking up things like
// special block styles because in some cases involving table pseudo-frames
// it has nothing to do with the parent frame's desired behavior.
nsStyleContext* styleContext;
if (aCanHaveGeneratedContent) {
styleContext =
nsFrame::CorrectStyleParentFrame(aFrame, nsnull)->GetStyleContext();
// Probe for generated content before
CreateGeneratedContentItem(aState, aFrame, aContent,
styleContext, nsCSSPseudoElements::before,
itemsToConstruct);
}
ChildIterator iter, last;
for (ChildIterator::Init(aContent, &iter, &last);
iter != last;
++iter) {
AddFrameConstructionItems(aState, *iter, aFrame, itemsToConstruct);
}
if (aCanHaveGeneratedContent) {
// Probe for generated content after
CreateGeneratedContentItem(aState, aFrame, aContent,
styleContext, nsCSSPseudoElements::after,
itemsToConstruct);
}
}
if (aFrame != mRootElementFrame) {
nsAutoTArray<nsIContent*, 4> anonymousItems;
GetAnonymousContent(aContent, aFrame, anonymousItems);
for (PRUint32 i = 0; i < anonymousItems.Length(); ++i) {
#ifdef DEBUG
nsIAnonymousContentCreator* creator = do_QueryFrame(aFrame);
NS_ASSERTION(!creator || !creator->CreateFrameFor(anonymousItems[i]),
"If you need to use CreateFrameFor, you need to call "
"CreateAnonymousFrames manually and not follow the standard "
"ProcessChildren() codepath for this frame");
#endif
AddFrameConstructionItems(aState, anonymousItems[i], aFrame,
itemsToConstruct);
}
}
rv = ConstructFramesFromItemList(aState, itemsToConstruct, aFrame,
aFrameItems);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(!aAllowBlockStyles || !aFrame->IsBoxFrame(),
"can't be both block and box");
if (haveFirstLetterStyle) {
rv = WrapFramesInFirstLetterFrame(aContent, aFrame, aFrameItems);
}
if (haveFirstLineStyle) {
rv = WrapFramesInFirstLineFrame(aState, aContent, aFrame, aFrameItems);
}
nsIContent *badKid;
if (aFrame->IsBoxFrame() &&
(badKid = AnyKidsNeedBlockParent(aFrameItems.childList))) {
nsAutoString parentTag, kidTag;
aContent->Tag()->ToString(parentTag);
badKid->Tag()->ToString(kidTag);
const PRUnichar* params[] = { parentTag.get(), kidTag.get() };
nsStyleContext *frameStyleContext = aFrame->GetStyleContext();
const nsStyleDisplay *display = frameStyleContext->GetStyleDisplay();
const char *message =
(display->mDisplay == NS_STYLE_DISPLAY_INLINE_BOX)
? "NeededToWrapXULInlineBox" : "NeededToWrapXUL";
nsContentUtils::ReportToConsole(nsContentUtils::eXUL_PROPERTIES,
message,
params, NS_ARRAY_LENGTH(params),
mDocument->GetDocumentURI(),
EmptyString(), 0, 0, // not useful
nsIScriptError::warningFlag,
"FrameConstructor");
nsRefPtr<nsStyleContext> blockSC = mPresShell->StyleSet()->
ResolvePseudoStyleFor(aContent,
nsCSSAnonBoxes::mozXULAnonymousBlock,
frameStyleContext);
nsIFrame *blockFrame = NS_NewBlockFrame(mPresShell, blockSC);
// We might, in theory, want to set NS_BLOCK_FLOAT_MGR and
// NS_BLOCK_MARGIN_ROOT, but I think it's a bad idea given that
// a real block placed here wouldn't get those set on it.
InitAndRestoreFrame(aState, aContent, aFrame, nsnull,
blockFrame, PR_FALSE);
NS_ASSERTION(!blockFrame->HasView(), "need to do view reparenting");
for (nsIFrame *f = aFrameItems.childList; f; f = f->GetNextSibling()) {
ReparentFrame(aState.mFrameManager, blockFrame, f);
}
blockFrame->AppendFrames(nsnull, aFrameItems.childList);
aFrameItems = nsFrameItems();
aFrameItems.AddChild(blockFrame);
aFrame->AddStateBits(NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK);
}
return rv;
}
//----------------------------------------------------------------------
// Support for :first-line style
// Special routine to handle placing a list of frames into a block
// frame that has first-line style. The routine ensures that the first
// collection of inline frames end up in a first-line frame.
// NOTE: aState may have containing block information related to a
// different part of the frame tree than where the first line occurs.
// In particular aState may be set up for where ContentInserted or
// ContentAppended is inserting content, which may be some
// non-first-in-flow continuation of the block to which the first-line
// belongs. So this function needs to be careful about how it uses
// aState.
nsresult
nsCSSFrameConstructor::WrapFramesInFirstLineFrame(
nsFrameConstructorState& aState,
nsIContent* aBlockContent,
nsIFrame* aBlockFrame,
nsFrameItems& aFrameItems)
{
nsresult rv = NS_OK;
// Find the first and last inline frame in aFrameItems
nsIFrame* kid = aFrameItems.childList;
nsIFrame* firstInlineFrame = nsnull;
nsIFrame* lastInlineFrame = nsnull;
while (kid) {
if (IsInlineOutside(kid)) {
if (!firstInlineFrame) firstInlineFrame = kid;
lastInlineFrame = kid;
}
else {
break;
}
kid = kid->GetNextSibling();
}
// If we don't find any inline frames, then there is nothing to do
if (!firstInlineFrame) {
return rv;
}
// Create line frame
nsStyleContext* parentStyle =
nsFrame::CorrectStyleParentFrame(aBlockFrame,
nsCSSPseudoElements::firstLine)->
GetStyleContext();
nsRefPtr<nsStyleContext> firstLineStyle = GetFirstLineStyle(aBlockContent,
parentStyle);
nsIFrame* lineFrame = NS_NewFirstLineFrame(mPresShell, firstLineStyle);
if (lineFrame) {
// Initialize the line frame
rv = InitAndRestoreFrame(aState, aBlockContent, aBlockFrame, nsnull,
lineFrame);
// Mangle the list of frames we are giving to the block: first
// chop the list in two after lastInlineFrame
nsIFrame* secondBlockFrame = lastInlineFrame->GetNextSibling();
lastInlineFrame->SetNextSibling(nsnull);
// The lineFrame will be the block's first child; the rest of the
// frame list (after lastInlineFrame) will be the second and
// subsequent children; join the list together and reset
// aFrameItems appropriately.
if (secondBlockFrame) {
lineFrame->SetNextSibling(secondBlockFrame);
}
if (aFrameItems.childList == lastInlineFrame) {
// Just in case the block had exactly one inline child
aFrameItems.lastChild = lineFrame;
}
aFrameItems.childList = lineFrame;
// Give the inline frames to the lineFrame <b>after</b> reparenting them
kid = firstInlineFrame;
NS_ASSERTION(lineFrame->GetStyleContext() == firstLineStyle,
"Bogus style context on line frame");
while (kid) {
ReparentFrame(aState.mFrameManager, lineFrame, kid);
kid = kid->GetNextSibling();
}
lineFrame->SetInitialChildList(nsnull, firstInlineFrame);
}
else {
rv = NS_ERROR_OUT_OF_MEMORY;
}
return rv;
}
// Special routine to handle appending a new frame to a block frame's
// child list. Takes care of placing the new frame into the right
// place when first-line style is present.
nsresult
nsCSSFrameConstructor::AppendFirstLineFrames(
nsFrameConstructorState& aState,
nsIContent* aBlockContent,
nsIFrame* aBlockFrame,
nsFrameItems& aFrameItems)
{
// It's possible that aBlockFrame needs to have a first-line frame
// created because it doesn't currently have any children.
nsIFrame* blockKid = aBlockFrame->GetFirstChild(nsnull);
if (!blockKid) {
return WrapFramesInFirstLineFrame(aState, aBlockContent,
aBlockFrame, aFrameItems);
}
// Examine the last block child - if it's a first-line frame then
// appended frames need special treatment.
nsresult rv = NS_OK;
nsFrameList blockFrames(blockKid);
nsIFrame* lastBlockKid = blockFrames.LastChild();
if (lastBlockKid->GetType() != nsGkAtoms::lineFrame) {
// No first-line frame at the end of the list, therefore there is
// an interveening block between any first-line frame the frames
// we are appending. Therefore, we don't need any special
// treatment of the appended frames.
return rv;
}
nsIFrame* lineFrame = lastBlockKid;
// Find the first and last inline frame in aFrameItems
nsIFrame* kid = aFrameItems.childList;
nsIFrame* firstInlineFrame = nsnull;
nsIFrame* lastInlineFrame = nsnull;
while (kid) {
if (IsInlineOutside(kid)) {
if (!firstInlineFrame) firstInlineFrame = kid;
lastInlineFrame = kid;
}
else {
break;
}
kid = kid->GetNextSibling();
}
// If we don't find any inline frames, then there is nothing to do
if (!firstInlineFrame) {
return rv;
}
// The inline frames get appended to the lineFrame. Make sure they
// are reparented properly.
nsIFrame* remainingFrames = lastInlineFrame->GetNextSibling();
lastInlineFrame->SetNextSibling(nsnull);
kid = firstInlineFrame;
while (kid) {
ReparentFrame(aState.mFrameManager, lineFrame, kid);
kid = kid->GetNextSibling();
}
aState.mFrameManager->AppendFrames(lineFrame, nsnull, firstInlineFrame);
// The remaining frames get appended to the block frame
if (remainingFrames) {
aFrameItems.childList = remainingFrames;
}
else {
aFrameItems.childList = nsnull;
aFrameItems.lastChild = nsnull;
}
return rv;
}
// Special routine to handle inserting a new frame into a block
// frame's child list. Takes care of placing the new frame into the
// right place when first-line style is present.
nsresult
nsCSSFrameConstructor::InsertFirstLineFrames(
nsFrameConstructorState& aState,
nsIContent* aContent,
nsIFrame* aBlockFrame,
nsIFrame** aParentFrame,
nsIFrame* aPrevSibling,
nsFrameItems& aFrameItems)
{
nsresult rv = NS_OK;
// XXXbz If you make this method actually do something, check to make sure
// that the caller is passing what you expect. In particular, which content
// is aContent?
#if 0
nsIFrame* parentFrame = *aParentFrame;
nsIFrame* newFrame = aFrameItems.childList;
PRBool isInline = IsInlineOutside(newFrame);
if (!aPrevSibling) {
// Insertion will become the first frame. Two cases: we either
// already have a first-line frame or we don't.
nsIFrame* firstBlockKid = aBlockFrame->GetFirstChild(nsnull);
if (firstBlockKid->GetType() == nsGkAtoms::lineFrame) {
// We already have a first-line frame
nsIFrame* lineFrame = firstBlockKid;
if (isInline) {
// Easy case: the new inline frame will go into the lineFrame.
ReparentFrame(aState.mFrameManager, lineFrame, newFrame);
aState.mFrameManager->InsertFrames(lineFrame, nsnull, nsnull,
newFrame);
// Since the frame is going into the lineFrame, don't let it
// go into the block too.
aFrameItems.childList = nsnull;
aFrameItems.lastChild = nsnull;
}
else {
// Harder case: We are about to insert a block level element
// before the first-line frame.
// XXX need a method to steal away frames from the line-frame
}
}
else {
// We do not have a first-line frame
if (isInline) {
// We now need a first-line frame to contain the inline frame.
nsIFrame* lineFrame = NS_NewFirstLineFrame(firstLineStyle);
if (!lineFrame) {
rv = NS_ERROR_OUT_OF_MEMORY;
}
if (NS_SUCCEEDED(rv)) {
// Lookup first-line style context
nsStyleContext* parentStyle =
nsFrame::CorrectStyleParentFrame(aBlockFrame,
nsCSSPseudoElements::firstLine)->
GetStyleContext();
nsRefPtr<nsStyleContext> firstLineStyle =
GetFirstLineStyle(aContent, parentStyle);
// Initialize the line frame
rv = InitAndRestoreFrame(aState, aContent, aBlockFrame,
nsnull, lineFrame);
// Make sure the caller inserts the lineFrame into the
// blocks list of children.
aFrameItems.childList = lineFrame;
aFrameItems.lastChild = lineFrame;
// Give the inline frames to the lineFrame <b>after</b>
// reparenting them
NS_ASSERTION(lineFrame->GetStyleContext() == firstLineStyle,
"Bogus style context on line frame");
ReparentFrame(aPresContext, lineFrame, newFrame);
lineFrame->SetInitialChildList(nsnull, newFrame);
}
}
else {
// Easy case: the regular insertion logic can insert the new
// frame because it's a block frame.
}
}
}
else {
// Insertion will not be the first frame.
nsIFrame* prevSiblingParent = aPrevSibling->GetParent();
if (prevSiblingParent == aBlockFrame) {
// Easy case: The prev-siblings parent is the block
// frame. Therefore the prev-sibling is not currently in a
// line-frame. Therefore the new frame which is going after it,
// regardless of type, is not going into a line-frame.
}
else {
// If the prevSiblingParent is not the block-frame then it must
// be a line-frame (if it were a letter-frame, that logic would
// already have adjusted the prev-sibling to be the
// letter-frame).
if (isInline) {
// Easy case: the insertion can go where the caller thinks it
// should go (which is into prevSiblingParent).
}
else {
// Block elements don't end up in line-frames, therefore
// change the insertion point to aBlockFrame. However, there
// might be more inline elements following aPrevSibling that
// need to be pulled out of the line-frame and become children
// of the block.
nsIFrame* nextSibling = aPrevSibling->GetNextSibling();
nsIFrame* nextLineFrame = prevSiblingParent->GetNextInFlow();
if (nextSibling || nextLineFrame) {
// Oy. We have work to do. Create a list of the new frames
// that are going into the block by stripping them away from
// the line-frame(s).
nsFrameList list(nextSibling);
if (nextSibling) {
nsLineFrame* lineFrame = (nsLineFrame*) prevSiblingParent;
lineFrame->StealFramesFrom(nextSibling);
}
nsLineFrame* nextLineFrame = (nsLineFrame*) lineFrame;
for (;;) {
nextLineFrame = nextLineFrame->GetNextInFlow();
if (!nextLineFrame) {
break;
}
nsIFrame* kids = nextLineFrame->GetFirstChild(nsnull);
}
}
else {
// We got lucky: aPrevSibling was the last inline frame in
// the line-frame.
ReparentFrame(aState.mFrameManager, aBlockFrame, newFrame);
aState.mFrameManager->InsertFrames(aBlockFrame, nsnull,
prevSiblingParent, newFrame);
aFrameItems.childList = nsnull;
aFrameItems.lastChild = nsnull;
}
}
}
}
#endif
return rv;
}
//----------------------------------------------------------------------
// First-letter support
// Determine how many characters in the text fragment apply to the
// first letter
static PRInt32
FirstLetterCount(const nsTextFragment* aFragment)
{
PRInt32 count = 0;
PRInt32 firstLetterLength = 0;
PRBool done = PR_FALSE;
PRInt32 i, n = aFragment->GetLength();
for (i = 0; i < n; i++) {
PRUnichar ch = aFragment->CharAt(i);
if (XP_IS_SPACE(ch)) {
if (firstLetterLength) {
done = PR_TRUE;
break;
}
count++;
continue;
}
// XXX I18n
if ((ch == '\'') || (ch == '\"')) {
if (firstLetterLength) {
done = PR_TRUE;
break;
}
// keep looping
firstLetterLength = 1;
}
else {
count++;
done = PR_TRUE;
break;
}
}
return count;
}
static PRBool
NeedFirstLetterContinuation(nsIContent* aContent)
{
NS_PRECONDITION(aContent, "null ptr");
PRBool result = PR_FALSE;
if (aContent) {
const nsTextFragment* frag = aContent->GetText();
if (frag) {
PRInt32 flc = FirstLetterCount(frag);
PRInt32 tl = frag->GetLength();
if (flc < tl) {
result = PR_TRUE;
}
}
}
return result;
}
static PRBool IsFirstLetterContent(nsIContent* aContent)
{
return aContent->TextLength() &&
!aContent->TextIsOnlyWhitespace();
}
/**
* Create a letter frame, only make it a floating frame.
*/
void
nsCSSFrameConstructor::CreateFloatingLetterFrame(
nsFrameConstructorState& aState,
nsIFrame* aBlockFrame,
nsIContent* aTextContent,
nsIFrame* aTextFrame,
nsIContent* aBlockContent,
nsIFrame* aParentFrame,
nsStyleContext* aStyleContext,
nsFrameItems& aResult)
{
// Create the first-letter-frame
nsresult rv;
nsIFrame* letterFrame;
nsStyleSet *styleSet = mPresShell->StyleSet();
letterFrame = NS_NewFirstLetterFrame(mPresShell, aStyleContext);
// We don't want to use a text content for a non-text frame (because we want
// its primary frame to be a text frame). So use its parent for the
// first-letter.
nsIContent* letterContent = aTextContent->GetParent();
InitAndRestoreFrame(aState, letterContent,
aState.GetGeometricParent(aStyleContext->GetStyleDisplay(),
aParentFrame),
nsnull, letterFrame);
// Init the text frame to refer to the letter frame. Make sure we
// get a proper style context for it (the one passed in is for the
// letter frame and will have the float property set on it; the text
// frame shouldn't have that set).
nsRefPtr<nsStyleContext> textSC;
textSC = styleSet->ResolveStyleForNonElement(aStyleContext);
aTextFrame->SetStyleContextWithoutNotification(textSC);
InitAndRestoreFrame(aState, aTextContent, letterFrame, nsnull, aTextFrame);
// And then give the text frame to the letter frame
letterFrame->SetInitialChildList(nsnull, aTextFrame);
// See if we will need to continue the text frame (does it contain
// more than just the first-letter text or not?) If it does, then we
// create (in advance) a continuation frame for it.
nsIFrame* nextTextFrame = nsnull;
if (NeedFirstLetterContinuation(aTextContent)) {
// Create continuation
rv = CreateContinuingFrame(aState.mPresContext, aTextFrame, aParentFrame,
&nextTextFrame);
if (NS_FAILED(rv)) {
letterFrame->Destroy();
return;
}
// Repair the continuations style context
nsStyleContext* parentStyleContext = aStyleContext->GetParent();
if (parentStyleContext) {
nsRefPtr<nsStyleContext> newSC;
newSC = styleSet->ResolveStyleForNonElement(parentStyleContext);
if (newSC) {
nextTextFrame->SetStyleContext(newSC);
}
}
}
NS_ASSERTION(aResult.childList == nsnull,
"aResult should be an empty nsFrameItems!");
nsIFrame* insertAfter = nsnull;
nsIFrame* f;
// Put the new float before any of the floats in the block we're
// doing first-letter for, that is, before any floats whose parent is aBlockFrame
for (f = aState.mFloatedItems.childList; f; f = f->GetNextSibling()) {
if (f->GetParent() == aBlockFrame)
break;
insertAfter = f;
}
rv = aState.AddChild(letterFrame, aResult, letterContent, aStyleContext,
aParentFrame, PR_FALSE, PR_TRUE, PR_FALSE, PR_TRUE,
insertAfter);
if (nextTextFrame) {
if (NS_FAILED(rv)) {
nextTextFrame->Destroy();
} else {
aResult.AddChild(nextTextFrame);
}
}
}
/**
* Create a new letter frame for aTextFrame. The letter frame will be
* a child of aParentFrame.
*/
nsresult
nsCSSFrameConstructor::CreateLetterFrame(nsIFrame* aBlockFrame,
nsIContent* aTextContent,
nsIFrame* aParentFrame,
nsFrameItems& aResult)
{
NS_PRECONDITION(aTextContent->IsNodeOfType(nsINode::eTEXT),
"aTextContent isn't text");
NS_ASSERTION(nsLayoutUtils::GetAsBlock(aBlockFrame),
"Not a block frame?");
// Get style context for the first-letter-frame
nsStyleContext* parentStyleContext =
nsFrame::CorrectStyleParentFrame(aParentFrame,
nsCSSPseudoElements::firstLetter)->
GetStyleContext();
// Use content from containing block so that we can actually
// find a matching style rule.
nsIContent* blockContent = aBlockFrame->GetContent();
// Create first-letter style rule
nsRefPtr<nsStyleContext> sc = GetFirstLetterStyle(blockContent,
parentStyleContext);
if (sc) {
nsRefPtr<nsStyleContext> textSC;
textSC = mPresShell->StyleSet()->ResolveStyleForNonElement(sc);
// Create a new text frame (the original one will be discarded)
// pass a temporary stylecontext, the correct one will be set later
nsIFrame* textFrame = NS_NewTextFrame(mPresShell, textSC);
NS_ASSERTION(aBlockFrame == GetFloatContainingBlock(aParentFrame),
"Containing block is confused");
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(aParentFrame),
aBlockFrame);
// Create the right type of first-letter frame
const nsStyleDisplay* display = sc->GetStyleDisplay();
if (display->IsFloating()) {
// Make a floating first-letter frame
CreateFloatingLetterFrame(state, aBlockFrame, aTextContent, textFrame,
blockContent, aParentFrame,
sc, aResult);
}
else {
// Make an inflow first-letter frame
nsIFrame* letterFrame = NS_NewFirstLetterFrame(mPresShell, sc);
if (letterFrame) {
// Initialize the first-letter-frame. We don't want to use a text
// content for a non-text frame (because we want its primary frame to
// be a text frame). So use its parent for the first-letter.
nsIContent* letterContent = aTextContent->GetParent();
letterFrame->Init(letterContent, aParentFrame, nsnull);
InitAndRestoreFrame(state, aTextContent, letterFrame, nsnull,
textFrame);
letterFrame->SetInitialChildList(nsnull, textFrame);
aResult.childList = aResult.lastChild = letterFrame;
aBlockFrame->AddStateBits(NS_BLOCK_HAS_FIRST_LETTER_CHILD);
}
}
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::WrapFramesInFirstLetterFrame(
nsIContent* aBlockContent,
nsIFrame* aBlockFrame,
nsFrameItems& aBlockFrames)
{
nsresult rv = NS_OK;
aBlockFrame->AddStateBits(NS_BLOCK_HAS_FIRST_LETTER_STYLE);
nsIFrame* parentFrame = nsnull;
nsIFrame* textFrame = nsnull;
nsIFrame* prevFrame = nsnull;
nsFrameItems letterFrames;
PRBool stopLooking = PR_FALSE;
rv = WrapFramesInFirstLetterFrame(aBlockFrame, aBlockFrame,
aBlockFrames.childList,
&parentFrame, &textFrame, &prevFrame,
letterFrames, &stopLooking);
if (NS_FAILED(rv)) {
return rv;
}
if (parentFrame) {
if (parentFrame == aBlockFrame) {
// Text textFrame out of the blocks frame list and substitute the
// letter frame(s) instead.
nsIFrame* nextSibling = textFrame->GetNextSibling();
textFrame->SetNextSibling(nsnull);
if (prevFrame) {
prevFrame->SetNextSibling(letterFrames.childList);
}
else {
aBlockFrames.childList = letterFrames.childList;
}
letterFrames.lastChild->SetNextSibling(nextSibling);
// Destroy the old textFrame
textFrame->Destroy();
// Repair lastChild; the only time this needs to happen is when
// the block had one child (the text frame).
if (!nextSibling) {
aBlockFrames.lastChild = letterFrames.lastChild;
}
}
else {
// Take the old textFrame out of the inline parents child list
::DeletingFrameSubtree(mPresShell->FrameManager(), textFrame);
parentFrame->RemoveFrame(nsnull, textFrame);
// Insert in the letter frame(s)
parentFrame->InsertFrames(nsnull, prevFrame, letterFrames.childList);
}
}
return rv;
}
nsresult
nsCSSFrameConstructor::WrapFramesInFirstLetterFrame(
nsIFrame* aBlockFrame,
nsIFrame* aParentFrame,
nsIFrame* aParentFrameList,
nsIFrame** aModifiedParent,
nsIFrame** aTextFrame,
nsIFrame** aPrevFrame,
nsFrameItems& aLetterFrames,
PRBool* aStopLooking)
{
nsresult rv = NS_OK;
nsIFrame* prevFrame = nsnull;
nsIFrame* frame = aParentFrameList;
while (frame) {
nsIFrame* nextFrame = frame->GetNextSibling();
nsIAtom* frameType = frame->GetType();
if (nsGkAtoms::textFrame == frameType) {
// Wrap up first-letter content in a letter frame
nsIContent* textContent = frame->GetContent();
if (IsFirstLetterContent(textContent)) {
// Create letter frame to wrap up the text
rv = CreateLetterFrame(aBlockFrame, textContent,
aParentFrame, aLetterFrames);
if (NS_FAILED(rv)) {
return rv;
}
// Provide adjustment information for parent
*aModifiedParent = aParentFrame;
*aTextFrame = frame;
*aPrevFrame = prevFrame;
*aStopLooking = PR_TRUE;
return NS_OK;
}
}
else if (IsInlineFrame(frame) && frameType != nsGkAtoms::brFrame) {
nsIFrame* kids = frame->GetFirstChild(nsnull);
WrapFramesInFirstLetterFrame(aBlockFrame, frame, kids,
aModifiedParent, aTextFrame,
aPrevFrame, aLetterFrames, aStopLooking);
if (*aStopLooking) {
return NS_OK;
}
}
else {
// This will stop us looking to create more letter frames. For
// example, maybe the frame-type is "letterFrame" or
// "placeholderFrame". This keeps us from creating extra letter
// frames, and also prevents us from creating letter frames when
// the first real content child of a block is not text (e.g. an
// image, hr, etc.)
*aStopLooking = PR_TRUE;
break;
}
prevFrame = frame;
frame = nextFrame;
}
return rv;
}
nsresult
nsCSSFrameConstructor::RemoveFloatingFirstLetterFrames(
nsPresContext* aPresContext,
nsIPresShell* aPresShell,
nsFrameManager* aFrameManager,
nsIFrame* aBlockFrame,
PRBool* aStopLooking)
{
// First look for the float frame that is a letter frame
nsIFrame* floatFrame = aBlockFrame->GetFirstChild(nsGkAtoms::floatList);
while (floatFrame) {
// See if we found a floating letter frame
if (nsGkAtoms::letterFrame == floatFrame->GetType()) {
break;
}
floatFrame = floatFrame->GetNextSibling();
}
if (!floatFrame) {
// No such frame
return NS_OK;
}
// Take the text frame away from the letter frame (so it isn't
// destroyed when we destroy the letter frame).
nsIFrame* textFrame = floatFrame->GetFirstChild(nsnull);
if (!textFrame) {
return NS_OK;
}
// Discover the placeholder frame for the letter frame
nsIFrame* parentFrame;
nsPlaceholderFrame* placeholderFrame =
aFrameManager->GetPlaceholderFrameFor(floatFrame);
if (!placeholderFrame) {
// Somethings really wrong
return NS_OK;
}
parentFrame = placeholderFrame->GetParent();
if (!parentFrame) {
// Somethings really wrong
return NS_OK;
}
// Create a new text frame with the right style context that maps
// all of the content that was previously part of the letter frame
// (and probably continued elsewhere).
nsStyleContext* parentSC = parentFrame->GetStyleContext();
if (!parentSC) {
return NS_OK;
}
nsIContent* textContent = textFrame->GetContent();
if (!textContent) {
return NS_OK;
}
nsRefPtr<nsStyleContext> newSC;
newSC = aPresShell->StyleSet()->ResolveStyleForNonElement(parentSC);
if (!newSC) {
return NS_OK;
}
nsIFrame* newTextFrame = NS_NewTextFrame(aPresShell, newSC);
if (NS_UNLIKELY(!newTextFrame)) {
return NS_ERROR_OUT_OF_MEMORY;;
}
newTextFrame->Init(textContent, parentFrame, nsnull);
// Destroy the old text frame's continuations (the old text frame
// will be destroyed when its letter frame is destroyed).
nsIFrame* nextTextFrame = textFrame->GetNextContinuation();
while (nextTextFrame) {
nsIFrame* nextTextParent = nextTextFrame->GetParent();
if (nextTextParent) {
nsSplittableFrame::RemoveFromFlow(nextTextFrame);
::DeletingFrameSubtree(aFrameManager, nextTextFrame);
aFrameManager->RemoveFrame(nextTextParent, nsnull, nextTextFrame);
}
nextTextFrame = textFrame->GetNextContinuation();
}
// First find out where (in the content) the placeholder frames
// text is and its previous sibling frame, if any. Note that:
// 1) The placeholder had better be in the principal child list of
// parentFrame.
// 2) It's probably near the beginning (since we're a first-letter frame),
// so just doing a linear search for the prevSibling is ok.
// 3) Trying to use FindPreviousSibling will fail if the first-letter is in
// anonymous content (eg generated content).
nsFrameList siblingList(parentFrame->GetFirstChild(nsnull));
NS_ASSERTION(siblingList.ContainsFrame(placeholderFrame),
"Placeholder not in parent's principal child list?");
nsIFrame* prevSibling = siblingList.GetPrevSiblingFor(placeholderFrame);
// Now that everything is set...
#ifdef NOISY_FIRST_LETTER
printf("RemoveFloatingFirstLetterFrames: textContent=%p oldTextFrame=%p newTextFrame=%p\n",
textContent.get(), textFrame, newTextFrame);
#endif
UnregisterPlaceholderChain(aFrameManager, placeholderFrame);
// Remove the float frame
::DeletingFrameSubtree(aFrameManager, floatFrame);
aFrameManager->RemoveFrame(aBlockFrame, nsGkAtoms::floatList,
floatFrame);
// Remove placeholder frame
::DeletingFrameSubtree(aFrameManager, placeholderFrame);
aFrameManager->RemoveFrame(parentFrame, nsnull, placeholderFrame);
// Insert text frame in its place
aFrameManager->InsertFrames(parentFrame, nsnull,
prevSibling, newTextFrame);
return NS_OK;
}
nsresult
nsCSSFrameConstructor::RemoveFirstLetterFrames(nsPresContext* aPresContext,
nsIPresShell* aPresShell,
nsFrameManager* aFrameManager,
nsIFrame* aFrame,
PRBool* aStopLooking)
{
nsIFrame* prevSibling = nsnull;
nsIFrame* kid = aFrame->GetFirstChild(nsnull);
while (kid) {
if (nsGkAtoms::letterFrame == kid->GetType()) {
// Bingo. Found it. First steal away the text frame.
nsIFrame* textFrame = kid->GetFirstChild(nsnull);
if (!textFrame) {
break;
}
// Create a new textframe
nsStyleContext* parentSC = aFrame->GetStyleContext();
if (!parentSC) {
break;
}
nsIContent* textContent = textFrame->GetContent();
if (!textContent) {
break;
}
nsRefPtr<nsStyleContext> newSC;
newSC = aPresShell->StyleSet()->ResolveStyleForNonElement(parentSC);
if (!newSC) {
break;
}
textFrame = NS_NewTextFrame(aPresShell, newSC);
textFrame->Init(textContent, aFrame, nsnull);
// Next rip out the kid and replace it with the text frame
::DeletingFrameSubtree(aFrameManager, kid);
aFrameManager->RemoveFrame(aFrame, nsnull, kid);
// Insert text frame in its place
aFrameManager->InsertFrames(aFrame, nsnull, prevSibling, textFrame);
*aStopLooking = PR_TRUE;
aFrame->RemoveStateBits(NS_BLOCK_HAS_FIRST_LETTER_CHILD);
break;
}
else if (IsInlineFrame(kid)) {
// Look inside child inline frame for the letter frame
RemoveFirstLetterFrames(aPresContext, aPresShell, aFrameManager, kid,
aStopLooking);
if (*aStopLooking) {
break;
}
}
prevSibling = kid;
kid = kid->GetNextSibling();
}
return NS_OK;
}
nsresult
nsCSSFrameConstructor::RemoveLetterFrames(nsPresContext* aPresContext,
nsIPresShell* aPresShell,
nsFrameManager* aFrameManager,
nsIFrame* aBlockFrame)
{
aBlockFrame = aBlockFrame->GetFirstContinuation();
PRBool stopLooking = PR_FALSE;
nsresult rv;
do {
rv = RemoveFloatingFirstLetterFrames(aPresContext, aPresShell,
aFrameManager,
aBlockFrame, &stopLooking);
if (NS_SUCCEEDED(rv) && !stopLooking) {
rv = RemoveFirstLetterFrames(aPresContext, aPresShell, aFrameManager,
aBlockFrame, &stopLooking);
}
if (stopLooking) {
break;
}
aBlockFrame = aBlockFrame->GetNextContinuation();
} while (aBlockFrame);
return rv;
}
// Fixup the letter frame situation for the given block
nsresult
nsCSSFrameConstructor::RecoverLetterFrames(nsIFrame* aBlockFrame)
{
aBlockFrame = aBlockFrame->GetFirstContinuation();
nsIFrame* parentFrame = nsnull;
nsIFrame* textFrame = nsnull;
nsIFrame* prevFrame = nsnull;
nsFrameItems letterFrames;
PRBool stopLooking = PR_FALSE;
nsresult rv;
do {
// XXX shouldn't this bit be set already (bug 408493), assert instead?
aBlockFrame->AddStateBits(NS_BLOCK_HAS_FIRST_LETTER_STYLE);
rv = WrapFramesInFirstLetterFrame(aBlockFrame, aBlockFrame,
aBlockFrame->GetFirstChild(nsnull),
&parentFrame, &textFrame, &prevFrame,
letterFrames, &stopLooking);
if (NS_FAILED(rv)) {
return rv;
}
if (stopLooking) {
break;
}
aBlockFrame = aBlockFrame->GetNextContinuation();
} while (aBlockFrame);
if (parentFrame) {
// Take the old textFrame out of the parents child list
::DeletingFrameSubtree(mPresShell->FrameManager(), textFrame);
parentFrame->RemoveFrame(nsnull, textFrame);
// Insert in the letter frame(s)
parentFrame->InsertFrames(nsnull, prevFrame, letterFrames.childList);
}
return rv;
}
//----------------------------------------------------------------------
// listbox Widget Routines
nsresult
nsCSSFrameConstructor::CreateListBoxContent(nsPresContext* aPresContext,
nsIFrame* aParentFrame,
nsIFrame* aPrevFrame,
nsIContent* aChild,
nsIFrame** aNewFrame,
PRBool aIsAppend,
PRBool aIsScrollbar,
nsILayoutHistoryState* aFrameState)
{
#ifdef MOZ_XUL
nsresult rv = NS_OK;
// Construct a new frame
if (nsnull != aParentFrame) {
nsFrameItems frameItems;
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(aParentFrame),
GetFloatContainingBlock(aParentFrame),
mTempFrameTreeState);
nsRefPtr<nsStyleContext> styleContext;
styleContext = ResolveStyleContext(aParentFrame, aChild);
// Pre-check for display "none" - only if we find that, do we create
// any frame at all
const nsStyleDisplay* display = styleContext->GetStyleDisplay();
if (NS_STYLE_DISPLAY_NONE == display->mDisplay) {
*aNewFrame = nsnull;
return NS_OK;
}
BeginUpdate();
FrameConstructionItemList items;
AddFrameConstructionItemsInternal(state, aChild, aParentFrame,
aChild->Tag(), aChild->GetNameSpaceID(),
styleContext, ITEM_ALLOW_XBL_BASE,
items);
ConstructFramesFromItemList(state, items, aParentFrame, frameItems);
nsIFrame* newFrame = frameItems.childList;
*aNewFrame = newFrame;
if (NS_SUCCEEDED(rv) && (nsnull != newFrame)) {
// Notify the parent frame
if (aIsAppend)
rv = ((nsListBoxBodyFrame*)aParentFrame)->ListBoxAppendFrames(newFrame);
else
rv = ((nsListBoxBodyFrame*)aParentFrame)->ListBoxInsertFrames(aPrevFrame, newFrame);
}
EndUpdate();
}
return rv;
#else
return NS_ERROR_FAILURE;
#endif
}
//----------------------------------------
nsresult
nsCSSFrameConstructor::ConstructBlock(nsFrameConstructorState& aState,
const nsStyleDisplay* aDisplay,
nsIContent* aContent,
nsIFrame* aParentFrame,
nsIFrame* aContentParentFrame,
nsStyleContext* aStyleContext,
nsIFrame** aNewFrame,
nsFrameItems& aFrameItems,
PRBool aAbsPosContainer)
{
// Create column wrapper if necessary
nsIFrame* blockFrame = *aNewFrame;
nsIFrame* parent = aParentFrame;
nsRefPtr<nsStyleContext> blockStyle = aStyleContext;
const nsStyleColumn* columns = aStyleContext->GetStyleColumn();
if (columns->mColumnCount != NS_STYLE_COLUMN_COUNT_AUTO
|| columns->mColumnWidth.GetUnit() != eStyleUnit_Auto) {
nsIFrame* columnSetFrame = nsnull;
columnSetFrame = NS_NewColumnSetFrame(mPresShell, aStyleContext, 0);
if (!columnSetFrame) {
return NS_ERROR_OUT_OF_MEMORY;
}
InitAndRestoreFrame(aState, aContent, aParentFrame, nsnull, columnSetFrame);
// See if we need to create a view
nsHTMLContainerFrame::CreateViewForFrame(columnSetFrame, PR_FALSE);
blockStyle = mPresShell->StyleSet()->
ResolvePseudoStyleFor(aContent, nsCSSAnonBoxes::columnContent,
aStyleContext);
parent = columnSetFrame;
*aNewFrame = columnSetFrame;
columnSetFrame->SetInitialChildList(nsnull, blockFrame);
}
blockFrame->SetStyleContextWithoutNotification(blockStyle);
InitAndRestoreFrame(aState, aContent, parent, nsnull, blockFrame);
nsresult rv = aState.AddChild(*aNewFrame, aFrameItems, aContent,
aStyleContext,
aContentParentFrame ? aContentParentFrame :
aParentFrame);
if (NS_FAILED(rv)) {
return rv;
}
// See if we need to create a view, e.g. the frame is absolutely positioned
nsHTMLContainerFrame::CreateViewForFrame(blockFrame, PR_FALSE);
if (!mRootElementFrame) {
// The frame we're constructing will be the root element frame.
// Set mRootElementFrame before processing children.
mRootElementFrame = *aNewFrame;
}
// We should make the outer frame be the absolute containing block,
// if one is required. We have to do this because absolute
// positioning must be computed with respect to the CSS dimensions
// of the element, which are the dimensions of the outer block. But
// we can't really do that because only blocks can have absolute
// children. So use the block and try to compensate with hacks
// in nsBlockFrame::CalculateContainingBlockSizeForAbsolutes.
nsFrameConstructorSaveState absoluteSaveState;
if (aAbsPosContainer) {
// NS_ASSERTION(aRelPos, "should have made area frame for this");
aState.PushAbsoluteContainingBlock(blockFrame, absoluteSaveState);
}
// Process the child content
nsFrameItems childItems;
rv = ProcessChildren(aState, aContent, aStyleContext, blockFrame, PR_TRUE,
childItems, PR_TRUE);
// Set the frame's initial child list
blockFrame->SetInitialChildList(nsnull, childItems.childList);
return rv;
}
nsresult
nsCSSFrameConstructor::ConstructInline(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsIFrame* aParentFrame,
const nsStyleDisplay* aDisplay,
nsFrameItems& aFrameItems,
nsIFrame** aNewFrame)
{
nsIContent* const content = aItem.mContent;
nsStyleContext* const styleContext = aItem.mStyleContext;
nsIFrame *newFrame;
PRBool positioned =
NS_STYLE_DISPLAY_INLINE == aDisplay->mDisplay &&
(NS_STYLE_POSITION_RELATIVE == aDisplay->mPosition ||
aDisplay->HasTransform());
if (positioned) {
newFrame = NS_NewPositionedInlineFrame(mPresShell, styleContext);
} else {
newFrame = NS_NewInlineFrame(mPresShell, styleContext);
}
// Initialize the frame
InitAndRestoreFrame(aState, content, aParentFrame, nsnull, newFrame);
nsFrameConstructorSaveState absoluteSaveState; // definition cannot be inside next block
// because the object's destructor is significant
// this is part of the fix for bug 42372
// Any inline frame might need a view (because of opacity, or fixed background)
nsHTMLContainerFrame::CreateViewForFrame(newFrame, PR_FALSE);
if (positioned) {
// Relatively positioned frames becomes a container for child
// frames that are positioned
aState.PushAbsoluteContainingBlock(newFrame, absoluteSaveState);
}
// Process the child content
nsFrameItems childItems;
nsresult rv = ConstructFramesFromItemList(aState, aItem.mChildItems,
newFrame, childItems);
if (NS_FAILED(rv)) {
// Clean up?
return rv;
}
nsIFrame* list1 = childItems.childList;
nsIFrame* prevToFirstBlock;
nsIFrame* list2;
if (aItem.mIsAllInline ||
// Note: This really is meant to be an assignment to list2 followed by a
// test of !list2.
!(list2 = FindFirstBlock(list1, &prevToFirstBlock))) {
// This part is easy. We either already know we have no non-inline kids,
// or haven't found any when constructing actual frames (the latter can
// happen only if out-of-flows that we thought had no containing block
// acquired one when ancestor inline frames and {ib} splits got
// constructed). Just put all the kids into the single inline frame and
// bail.
newFrame->SetInitialChildList(nsnull, childItems.childList);
if (NS_SUCCEEDED(rv)) {
aState.AddChild(newFrame, aFrameItems, content, styleContext, aParentFrame);
*aNewFrame = newFrame;
}
return rv;
}
// This inline frame contains several types of children. Therefore
// this frame has to be chopped into several pieces. We will produce
// as a result of this 3 lists of children. The first list contains
// all of the inline children that precede the first block child
// (and may be empty). The second list contains all of the block
// children and any inlines that are between them (and must not be
// empty, otherwise - why are we here?). The final list contains all
// of the inline children that follow the final block child.
// Find the first block child which defines list1 and list2
if (prevToFirstBlock) {
prevToFirstBlock->SetNextSibling(nsnull);
}
else {
list1 = nsnull;
}
// Find the last block child which defines the end of list2 and the
// start of list3
nsIFrame* afterFirstBlock = list2->GetNextSibling();
nsIFrame* list3 = nsnull;
nsIFrame* lastBlock = FindLastBlock(afterFirstBlock);
if (!lastBlock) {
lastBlock = list2;
}
list3 = lastBlock->GetNextSibling();
lastBlock->SetNextSibling(nsnull);
// list1's frames belong to this inline frame so go ahead and take them
newFrame->SetInitialChildList(nsnull, list1);
// list2's frames belong to an anonymous block that we create right
// now. The anonymous block will be the parent of the block children
// of the inline.
nsIAtom* blockStyle;
nsRefPtr<nsStyleContext> blockSC;
nsIFrame* blockFrame;
if (positioned) {
blockStyle = nsCSSAnonBoxes::mozAnonymousPositionedBlock;
blockSC = mPresShell->StyleSet()->
ResolvePseudoStyleFor(content, blockStyle, styleContext);
}
else {
blockStyle = nsCSSAnonBoxes::mozAnonymousBlock;
blockSC = mPresShell->StyleSet()->
ResolvePseudoStyleFor(content, blockStyle, styleContext);
}
blockFrame = NS_NewBlockFrame(mPresShell, blockSC);
InitAndRestoreFrame(aState, content, aParentFrame, nsnull, blockFrame, PR_FALSE);
// Any inline frame could have a view (e.g., opacity)
nsHTMLContainerFrame::CreateViewForFrame(blockFrame, PR_FALSE);
if (blockFrame->HasView() || newFrame->HasView()) {
// Move list2's frames into the new view
nsHTMLContainerFrame::ReparentFrameViewList(aState.mPresContext, list2,
list2->GetParent(), blockFrame);
}
blockFrame->SetInitialChildList(nsnull, list2);
nsFrameConstructorState state(mPresShell, mFixedContainingBlock,
GetAbsoluteContainingBlock(blockFrame),
GetFloatContainingBlock(blockFrame));
// If we have an inline between two blocks all inside an inline and the inner
// inline contains a float, the float will end up in the float list of the
// parent block of the inline, but its parent pointer will be the anonymous
// block we create... AdjustFloatParentPtrs() deals with this by moving the
// float from the outer state |aState| to the inner |state|.
MoveChildrenTo(state.mFrameManager, blockFrame, list2, nsnull, &state,
&aState);
// list3's frames belong to another inline frame
nsIFrame* inlineFrame;
if (positioned) {
inlineFrame = NS_NewPositionedInlineFrame(mPresShell, styleContext);
}
else {
inlineFrame = NS_NewInlineFrame(mPresShell, styleContext);
}
InitAndRestoreFrame(aState, content, aParentFrame, nsnull, inlineFrame,
PR_FALSE);
// Any frame might need a view
nsHTMLContainerFrame::CreateViewForFrame(inlineFrame, PR_FALSE);
if (list3) {
MoveFramesToEndOfIBSplit(aState, inlineFrame, list3, blockFrame, nsnull);
}
// Mark the frames as special. That way if any of the append/insert/remove
// methods try to fiddle with the children, the containing block will be
// reframed instead.
SetFrameIsSpecial(newFrame, blockFrame);
SetFrameIsSpecial(blockFrame, inlineFrame);
SetFrameIsSpecial(inlineFrame, nsnull);
MarkIBSpecialPrevSibling(blockFrame, newFrame);
MarkIBSpecialPrevSibling(inlineFrame, blockFrame);
#ifdef DEBUG
if (gNoisyInlineConstruction) {
nsIFrameDebug* frameDebug;
printf("nsCSSFrameConstructor::ConstructInline:\n");
if ( (frameDebug = do_QueryFrame(*aNewFrame)) ) {
printf(" ==> leading inline frame:\n");
frameDebug->List(stdout, 2);
}
if ( (frameDebug = do_QueryFrame(blockFrame)) ) {
printf(" ==> block frame:\n");
frameDebug->List(stdout, 2);
}
if ( (frameDebug = do_QueryFrame(inlineFrame)) ) {
printf(" ==> trailing inline frame:\n");
frameDebug->List(stdout, 2);
}
}
#endif
if (NS_SUCCEEDED(rv)) {
aState.AddChild(newFrame, aFrameItems, content, styleContext, aParentFrame);
*aNewFrame = newFrame;
}
return rv;
}
void
nsCSSFrameConstructor::MoveFramesToEndOfIBSplit(nsFrameConstructorState& aState,
nsIFrame* aExistingEndFrame,
nsIFrame* aFramesToMove,
nsIFrame* aBlockPart,
nsFrameConstructorState* aTargetState)
{
NS_PRECONDITION(aBlockPart, "Must have a block part");
NS_PRECONDITION(aExistingEndFrame, "Must have trailing inline");
NS_PRECONDITION(aFramesToMove, "Must have frames to move");
if (aExistingEndFrame->HasView() || aFramesToMove->GetParent()->HasView()) {
// Move list3's frames into the new view
nsHTMLContainerFrame::ReparentFrameViewList(aState.mPresContext,
aFramesToMove,
aFramesToMove->GetParent(),
aExistingEndFrame);
}
// Reparent (cheaply) the frames in list3
nsIFrame* existingFirstChild = aExistingEndFrame->GetFirstChild(nsnull);
if (!existingFirstChild &&
(aExistingEndFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
aExistingEndFrame->SetInitialChildList(nsnull, aFramesToMove);
} else {
aExistingEndFrame->InsertFrames(nsnull, nsnull, aFramesToMove);
}
nsFrameConstructorState* startState = aTargetState ? &aState : nsnull;
MoveChildrenTo(aState.mFrameManager, aExistingEndFrame, aFramesToMove,
existingFirstChild, aTargetState, startState);
}
void
nsCSSFrameConstructor::BuildInlineChildItems(nsFrameConstructorState& aState,
FrameConstructionItem& aParentItem)
{
// XXXbz should we preallocate aParentItem.mChildItems to some sane
// length? Maybe even to parentContent->GetChildCount()?
// Probe for generated content before
nsStyleContext* const parentStyleContext = aParentItem.mStyleContext;
nsIContent* const parentContent = aParentItem.mContent;
CreateGeneratedContentItem(aState, nsnull, parentContent,
parentStyleContext, nsCSSPseudoElements::before,
aParentItem.mChildItems);
ChildIterator iter, last;
for (ChildIterator::Init(parentContent, &iter, &last);
iter != last;
++iter) {
// Manually check for comments/PIs, since we do't have a frame to pass to
// AddFrameConstructionItems. We know our parent is a non-replaced inline,
// so there is no need to do the NeedFrameFor check.
nsIContent* content = *iter;
if (content->IsNodeOfType(nsINode::eCOMMENT) ||
content->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION)) {
continue;
}
nsRefPtr<nsStyleContext> childContext =
ResolveStyleContext(parentStyleContext, content);
AddFrameConstructionItemsInternal(aState, content, nsnull, content->Tag(),
content->GetNameSpaceID(), childContext,
ITEM_ALLOW_XBL_BASE | ITEM_ALLOW_PAGE_BREAK,
aParentItem.mChildItems);
}
// Probe for generated content after
CreateGeneratedContentItem(aState, nsnull, parentContent,
parentStyleContext, nsCSSPseudoElements::after,
aParentItem.mChildItems);
aParentItem.mIsAllInline = aParentItem.mChildItems.AreAllItemsInline();
}
PRBool
nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
nsIFrame* aContainingBlock,
nsIFrame* aFrame,
const FrameConstructionItemList& aItems,
PRBool aIsAppend,
nsIFrame* aPrevSibling)
{
if (aItems.IsEmpty()) {
return PR_FALSE;
}
// Before we go and append the frames, we must check for two
// special situations.
// Situation #1 is a XUL frame that contains frames that are required
// to be wrapped in blocks.
if (aFrame->IsBoxFrame() &&
!(aFrame->GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK) &&
aItems.AnyItemsNeedBlockParent()) {
RecreateFramesForContent(aFrame->GetContent());
return PR_TRUE;
}
// Situation #2 is an inline frame that will now contain block
// frames. This is a no-no and the frame construction logic knows
// how to fix this. See defition of IsInlineFrame() for what "an
// inline" is. Whether we have "a block" is tested for by
// AreAllItemsInline.
// We also need to check for an append of content ending in an
// inline to the block in an {ib} split or an insert of content
// starting with an inline to the start of that block. If that
// happens, we also need to reframe, since that content needs to go
// into the following or preceding inline in the split.
if (IsInlineFrame(aFrame)) {
// Nothing to do if all kids are inline
if (aItems.AreAllItemsInline()) {
return PR_FALSE;
}
} else if (!IsFrameSpecial(aFrame)) {
return PR_FALSE;
} else {
// aFrame is the block in an {ib} split. Check that we're not
// messing up either end of it.
if (aIsAppend) {
// Will be handled in AppendFrames(), except the case when we might have
// floats that we won't be able to move out because there is no float
// containing block to move them into.
// Walk up until we get a float containing block that's not part of an
// {ib} split, since otherwise we might have to ship floats out of it
// too.
// XXXbz we could keep track of whether we have any descendants with
// float style in the FrameConstructionItem if we really want, but it's
// not clear to me that we need to. In any case, the right solution here
// is to construct with the right parents to start with.
nsIFrame* floatContainer = aFrame;
do {
floatContainer = GetFloatContainingBlock(
GetIBSplitSpecialPrevSiblingForAnonymousBlock(floatContainer));
if (!floatContainer) {
break;
}
if (!IsFrameSpecial(floatContainer)) {
return PR_FALSE;
}
} while (1);
}
if (aPrevSibling && !aPrevSibling->GetNextSibling()) {
// This is an append that won't go through AppendFrames. We can bail out
// if the last frame we're appending is not inline.
if (!aItems.IsStartInline()) {
return PR_FALSE;
}
} else {
// We can bail out if we're not inserting at the beginning or if
// the first frame we're inserting is not inline.
if (aPrevSibling || !aItems.IsEndInline()) {
return PR_FALSE;
}
}
}
// If we don't have a containing block, start with aFrame and look for one.
if (!aContainingBlock) {
aContainingBlock = aFrame;
}
// To find the right block to reframe, just walk up the tree until we find a
// frame that is:
// 1) Not part of an IB split (not special)
// 2) Not a pseudo-frame
// 3) Not an inline frame
// We're guaranteed to find one, since nsStyleContext::ApplyStyleFixups
// enforces that the root is display:none, display:table, or display:block.
// Note that walking up "too far" is OK in terms of correctness, even if it
// might be a little inefficient. This is why we walk out of all
// pseudo-frames -- telling which ones are or are not OK to walk out of is
// too hard (and I suspect that we do in fact need to walk out of all of
// them).
while (IsFrameSpecial(aContainingBlock) || IsInlineOutside(aContainingBlock) ||
aContainingBlock->GetStyleContext()->GetPseudoType()) {
aContainingBlock = aContainingBlock->GetParent();
NS_ASSERTION(aContainingBlock,
"Must have non-inline, non-special, non-pseudo frame as root "
"(or child of root, for a table root)!");
}
// Tell parent of the containing block to reformulate the
// entire block. This is painful and definitely not optimal
// but it will *always* get the right answer.
nsIContent *blockContent = aContainingBlock->GetContent();
nsCOMPtr<nsIContent> parentContainer = blockContent->GetParent();
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::WipeContainingBlock: blockContent=%p parentContainer=%p\n",
static_cast<void*>(blockContent),
static_cast<void*>(parentContainer));
}
#endif
if (parentContainer) {
ReinsertContent(parentContainer, blockContent);
}
else if (blockContent->GetCurrentDoc() == mDocument) {
ReconstructDocElementHierarchyInternal();
}
return PR_TRUE;
}
nsresult
nsCSSFrameConstructor::ReframeContainingBlock(nsIFrame* aFrame)
{
#ifdef DEBUG
// ReframeContainingBlock is a NASTY routine, it causes terrible performance problems
// so I want to see when it is happening! Unfortunately, it is happening way to often because
// so much content on the web causes 'special' block-in-inline frame situations and we handle them
// very poorly
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::ReframeContainingBlock frame=%p\n",
static_cast<void*>(aFrame));
}
#endif
PRBool isReflowing;
mPresShell->IsReflowLocked(&isReflowing);
if(isReflowing) {
// don't ReframeContainingBlock, this will result in a crash
// if we remove a tree that's in reflow - see bug 121368 for testcase
NS_ASSERTION(0, "Atemptted to nsCSSFrameConstructor::ReframeContainingBlock during a Reflow!!!");
return NS_OK;
}
// Get the first "normal" ancestor of the target frame.
nsIFrame* containingBlock = GetIBContainingBlockFor(aFrame);
if (containingBlock) {
// From here we look for the containing block in case the target
// frame is already a block (which can happen when an inline frame
// wraps some of its content in an anonymous block; see
// ConstructInline)
// NOTE: We used to get the FloatContainingBlock here, but it was often wrong.
// GetIBContainingBlock works much better and provides the correct container in all cases
// so GetFloatContainingBlock(aFrame) has been removed
// And get the containingBlock's content
nsCOMPtr<nsIContent> blockContent = containingBlock->GetContent();
if (blockContent) {
// Now find the containingBlock's content's parent
nsCOMPtr<nsIContent> parentContainer = blockContent->GetParent();
if (parentContainer) {
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf(" ==> blockContent=%p, parentContainer=%p\n",
static_cast<void*>(blockContent),
static_cast<void*>(parentContainer));
}
#endif
return ReinsertContent(parentContainer, blockContent);
}
}
}
// If we get here, we're screwed!
return ReconstructDocElementHierarchyInternal();
}
nsresult
nsCSSFrameConstructor::RemoveFixedItems(const nsFrameConstructorState& aState,
nsIFrame *aRootElementFrame)
{
nsresult rv=NS_OK;
if (mFixedContainingBlock) {
nsIFrame *fixedChild = nsnull;
do {
fixedChild = mFixedContainingBlock->GetFirstChild(nsGkAtoms::fixedList);
if (fixedChild && fixedChild == aRootElementFrame) {
// Skip the root element frame, if it happens to be fixed-positioned
// It will be explicitly removed later in
// ReconstructDocElementHierarchyInternal
fixedChild = fixedChild->GetNextSibling();
}
if (fixedChild) {
// Remove the placeholder so it doesn't end up sitting about pointing
// to the removed fixed frame.
nsPlaceholderFrame *placeholderFrame =
aState.mFrameManager->GetPlaceholderFrameFor(fixedChild);
NS_ASSERTION(placeholderFrame, "no placeholder for fixed-pos frame");
NS_ASSERTION(placeholderFrame->GetType() ==
nsGkAtoms::placeholderFrame,
"Wrong type");
UnregisterPlaceholderChain(aState.mFrameManager, placeholderFrame);
nsIFrame* placeholderParent = placeholderFrame->GetParent();
::DeletingFrameSubtree(aState.mFrameManager, placeholderFrame);
rv = aState.mFrameManager->RemoveFrame(placeholderParent, nsnull,
placeholderFrame);
if (NS_FAILED(rv)) {
NS_WARNING("Error removing placeholder for fixed frame in RemoveFixedItems");
break;
}
::DeletingFrameSubtree(aState.mFrameManager, fixedChild);
rv = aState.mFrameManager->RemoveFrame(mFixedContainingBlock,
nsGkAtoms::fixedList,
fixedChild);
if (NS_FAILED(rv)) {
NS_WARNING("Error removing frame from fixed containing block in RemoveFixedItems");
break;
}
}
} while(fixedChild);
} else {
NS_WARNING( "RemoveFixedItems called with no FixedContainingBlock data member set");
}
return rv;
}
void
nsCSSFrameConstructor::RestyleForAppend(nsIContent* aContainer,
PRInt32 aNewIndexInContainer)
{
NS_ASSERTION(aContainer, "must have container for append");
#ifdef DEBUG
{
for (PRInt32 index = aNewIndexInContainer;; ++index) {
nsIContent *content = aContainer->GetChildAt(index);
if (!content) {
NS_ASSERTION(index != aNewIndexInContainer, "yikes, nothing appended");
break;
}
NS_ASSERTION(!content->IsRootOfAnonymousSubtree(),
"anonymous nodes should not be in child lists");
}
}
#endif
PRUint32 selectorFlags =
aContainer->GetFlags() & (NODE_ALL_SELECTOR_FLAGS &
~NODE_HAS_SLOW_SELECTOR_NOAPPEND);
if (selectorFlags == 0)
return;
if (selectorFlags & NODE_HAS_SLOW_SELECTOR) {
PostRestyleEvent(aContainer, eReStyle_Self, NS_STYLE_HINT_NONE);
// Restyling the container is the most we can do here, so we're done.
return;
}
if (selectorFlags & NODE_HAS_EMPTY_SELECTOR) {
// see whether we need to restyle the container
PRBool wasEmpty = PR_TRUE; // :empty or :-moz-only-whitespace
for (PRInt32 index = 0; index < aNewIndexInContainer; ++index) {
// We don't know whether we're testing :empty or :-moz-only-whitespace,
// so be conservative and assume :-moz-only-whitespace (i.e., make
// IsSignificantChild less likely to be true, and thus make us more
// likely to restyle).
if (nsStyleUtil::IsSignificantChild(aContainer->GetChildAt(index),
PR_TRUE, PR_FALSE)) {
wasEmpty = PR_FALSE;
break;
}
}
if (wasEmpty) {
PostRestyleEvent(aContainer, eReStyle_Self, NS_STYLE_HINT_NONE);
// Restyling the container is the most we can do here, so we're done.
return;
}
}
if (selectorFlags & NODE_HAS_EDGE_CHILD_SELECTOR) {
// restyle the last element child before this node
for (PRInt32 index = aNewIndexInContainer - 1; index >= 0; --index) {
nsIContent *content = aContainer->GetChildAt(index);
if (content->IsNodeOfType(nsINode::eELEMENT)) {
PostRestyleEvent(content, eReStyle_Self, NS_STYLE_HINT_NONE);
break;
}
}
}
}
// Restyling for a ContentInserted or CharacterDataChanged notification.
// This could be used for ContentRemoved as well if we got the
// notification before the removal happened (and sometimes
// CharacterDataChanged is more like a removal than an addition).
// The comments are written and variables are named in terms of it being
// a ContentInserted notification.
void
nsCSSFrameConstructor::RestyleForInsertOrChange(nsIContent* aContainer,
nsIContent* aChild)
{
NS_ASSERTION(!aChild->IsRootOfAnonymousSubtree(),
"anonymous nodes should not be in child lists");
PRUint32 selectorFlags =
aContainer ? (aContainer->GetFlags() & NODE_ALL_SELECTOR_FLAGS) : 0;
if (selectorFlags == 0)
return;
if (selectorFlags & (NODE_HAS_SLOW_SELECTOR |
NODE_HAS_SLOW_SELECTOR_NOAPPEND)) {
PostRestyleEvent(aContainer, eReStyle_Self, NS_STYLE_HINT_NONE);
// Restyling the container is the most we can do here, so we're done.
return;
}
if (selectorFlags & NODE_HAS_EMPTY_SELECTOR) {
// see whether we need to restyle the container
PRBool wasEmpty = PR_TRUE; // :empty or :-moz-only-whitespace
for (PRInt32 index = 0; ; ++index) {
nsIContent *child = aContainer->GetChildAt(index);
if (!child) // last child
break;
if (child == aChild)
continue;
// We don't know whether we're testing :empty or :-moz-only-whitespace,
// so be conservative and assume :-moz-only-whitespace (i.e., make
// IsSignificantChild less likely to be true, and thus make us more
// likely to restyle).
if (nsStyleUtil::IsSignificantChild(child, PR_TRUE, PR_FALSE)) {
wasEmpty = PR_FALSE;
break;
}
}
if (wasEmpty) {
PostRestyleEvent(aContainer, eReStyle_Self, NS_STYLE_HINT_NONE);
// Restyling the container is the most we can do here, so we're done.
return;
}
}
if (selectorFlags & NODE_HAS_EDGE_CHILD_SELECTOR) {
// restyle the previously-first element child if it is after this node
PRBool passedChild = PR_FALSE;
for (PRInt32 index = 0; ; ++index) {
nsIContent *content = aContainer->GetChildAt(index);
if (!content)
break; // went through all children
if (content == aChild) {
passedChild = PR_TRUE;
continue;
}
if (content->IsNodeOfType(nsINode::eELEMENT)) {
if (passedChild) {
PostRestyleEvent(content, eReStyle_Self, NS_STYLE_HINT_NONE);
}
break;
}
}
// restyle the previously-last element child if it is before this node
passedChild = PR_FALSE;
for (PRInt32 index = aContainer->GetChildCount() - 1;
index >= 0; --index) {
nsIContent *content = aContainer->GetChildAt(index);
if (content == aChild) {
passedChild = PR_TRUE;
continue;
}
if (content->IsNodeOfType(nsINode::eELEMENT)) {
if (passedChild) {
PostRestyleEvent(content, eReStyle_Self, NS_STYLE_HINT_NONE);
}
break;
}
}
}
}
void
nsCSSFrameConstructor::RestyleForRemove(nsIContent* aContainer,
nsIContent* aOldChild,
PRInt32 aIndexInContainer)
{
NS_ASSERTION(!aOldChild->IsRootOfAnonymousSubtree(),
"anonymous nodes should not be in child lists");
PRUint32 selectorFlags =
aContainer ? (aContainer->GetFlags() & NODE_ALL_SELECTOR_FLAGS) : 0;
if (selectorFlags == 0)
return;
if (selectorFlags & (NODE_HAS_SLOW_SELECTOR |
NODE_HAS_SLOW_SELECTOR_NOAPPEND)) {
PostRestyleEvent(aContainer, eReStyle_Self, NS_STYLE_HINT_NONE);
// Restyling the container is the most we can do here, so we're done.
return;
}
if (selectorFlags & NODE_HAS_EMPTY_SELECTOR) {
// see whether we need to restyle the container
PRBool isEmpty = PR_TRUE; // :empty or :-moz-only-whitespace
for (PRInt32 index = 0; ; ++index) {
nsIContent *child = aContainer->GetChildAt(index);
if (!child) // last child
break;
// We don't know whether we're testing :empty or :-moz-only-whitespace,
// so be conservative and assume :-moz-only-whitespace (i.e., make
// IsSignificantChild less likely to be true, and thus make us more
// likely to restyle).
if (nsStyleUtil::IsSignificantChild(child, PR_TRUE, PR_FALSE)) {
isEmpty = PR_FALSE;
break;
}
}
if (isEmpty) {
PostRestyleEvent(aContainer, eReStyle_Self, NS_STYLE_HINT_NONE);
// Restyling the container is the most we can do here, so we're done.
return;
}
}
if (selectorFlags & NODE_HAS_EDGE_CHILD_SELECTOR) {
// restyle the previously-first element child if it is after aOldChild
for (PRInt32 index = 0; ; ++index) {
nsIContent *content = aContainer->GetChildAt(index);
if (!content)
break; // went through all children
if (content->IsNodeOfType(nsINode::eELEMENT)) {
if (index >= aIndexInContainer) {
PostRestyleEvent(content, eReStyle_Self, NS_STYLE_HINT_NONE);
}
break;
}
}
// restyle the previously-last element child if it is before aOldChild
for (PRInt32 index = aContainer->GetChildCount() - 1;
index >= 0; --index) {
nsIContent *content = aContainer->GetChildAt(index);
if (content->IsNodeOfType(nsINode::eELEMENT)) {
if (index < aIndexInContainer) {
PostRestyleEvent(content, eReStyle_Self, NS_STYLE_HINT_NONE);
}
break;
}
}
}
}
static PLDHashOperator
CollectRestyles(nsISupports* aContent,
nsCSSFrameConstructor::RestyleData& aData,
void* aRestyleArrayPtr)
{
nsCSSFrameConstructor::RestyleEnumerateData** restyleArrayPtr =
static_cast<nsCSSFrameConstructor::RestyleEnumerateData**>
(aRestyleArrayPtr);
nsCSSFrameConstructor::RestyleEnumerateData* currentRestyle =
*restyleArrayPtr;
currentRestyle->mContent = static_cast<nsIContent*>(aContent);
currentRestyle->mRestyleHint = aData.mRestyleHint;
currentRestyle->mChangeHint = aData.mChangeHint;
// Increment to the next slot in the array
*restyleArrayPtr = currentRestyle + 1;
return PL_DHASH_NEXT;
}
void
nsCSSFrameConstructor::ProcessOneRestyle(nsIContent* aContent,
nsReStyleHint aRestyleHint,
nsChangeHint aChangeHint)
{
NS_PRECONDITION(aContent, "Must have content node");
if (!aContent->IsInDoc() ||
aContent->GetCurrentDoc() != mDocument) {
// Content node has been removed from our document; nothing else
// to do here
return;
}
nsIFrame* primaryFrame = mPresShell->GetPrimaryFrameFor(aContent);
if (aRestyleHint & eReStyle_Self) {
RestyleElement(aContent, primaryFrame, aChangeHint);
} else if (aChangeHint &&
(primaryFrame ||
(aChangeHint & nsChangeHint_ReconstructFrame))) {
// Don't need to recompute style; just apply the hint
nsStyleChangeList changeList;
changeList.AppendChange(primaryFrame, aContent, aChangeHint);
ProcessRestyledFrames(changeList);
}
if (aRestyleHint & eReStyle_LaterSiblings) {
RestyleLaterSiblings(aContent);
}
}
#define RESTYLE_ARRAY_STACKSIZE 128
void
nsCSSFrameConstructor::RebuildAllStyleData(nsChangeHint aExtraHint)
{
NS_ASSERTION(!(aExtraHint & nsChangeHint_ReconstructFrame),
"Should not reconstruct the root of the frame tree. "
"Use ReconstructDocElementHierarchy instead.");
mRebuildAllStyleData = PR_FALSE;
NS_UpdateHint(aExtraHint, mRebuildAllExtraHint);
mRebuildAllExtraHint = nsChangeHint(0);
if (!mPresShell || !mPresShell->GetRootFrame())
return;
nsAutoScriptBlocker scriptBlocker;
// Make sure that the viewmanager will outlive the presshell
nsIViewManager::UpdateViewBatch batch(mPresShell->GetViewManager());
// Processing the style changes could cause a flush that propagates to
// the parent frame and thus destroys the pres shell.
nsCOMPtr<nsIPresShell> kungFuDeathGrip(mPresShell);
// Tell the style set to get the old rule tree out of the way
// so we can recalculate while maintaining rule tree immutability
nsresult rv = mPresShell->StyleSet()->BeginReconstruct();
if (NS_FAILED(rv)) {
batch.EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
return;
}
// Recalculate all of the style contexts for the document
// Note that we can ignore the return value of ComputeStyleChangeFor
// because we never need to reframe the root frame
// XXX This could be made faster by not rerunning rule matching
// (but note that nsPresShell::SetPreferenceStyleRules currently depends
// on us re-running rule matching here
nsStyleChangeList changeList;
// XXX Does it matter that we're passing aExtraHint to the real root
// frame and not the root node's primary frame?
mPresShell->FrameManager()->ComputeStyleChangeFor(mPresShell->GetRootFrame(),
&changeList, aExtraHint);
// Process the required changes
ProcessRestyledFrames(changeList);
// Tell the style set it's safe to destroy the old rule tree. We
// must do this after the ProcessRestyledFrames call in case the
// change list has frame reconstructs in it (since frames to be
// reconstructed will still have their old style context pointers
// until they are destroyed).
mPresShell->StyleSet()->EndReconstruct();
batch.EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
}
void
nsCSSFrameConstructor::ProcessPendingRestyles()
{
NS_PRECONDITION(mDocument, "No document? Pshaw!\n");
NS_PRECONDITION(!nsContentUtils::IsSafeToRunScript(),
"Missing a script blocker!");
PRUint32 count = mPendingRestyles.Count();
if (count) {
// Use the stack if we can, otherwise fall back on heap-allocation.
nsAutoTArray<RestyleEnumerateData, RESTYLE_ARRAY_STACKSIZE> restyleArr;
RestyleEnumerateData* restylesToProcess = restyleArr.AppendElements(count);
if (!restylesToProcess) {
return;
}
RestyleEnumerateData* lastRestyle = restylesToProcess;
mPendingRestyles.Enumerate(CollectRestyles, &lastRestyle);
NS_ASSERTION(lastRestyle - restylesToProcess == PRInt32(count),
"Enumeration screwed up somehow");
// Clear the hashtable so we don't end up trying to process a restyle we're
// already processing, sending us into an infinite loop.
mPendingRestyles.Clear();
// Make sure to not rebuild quote or counter lists while we're
// processing restyles
BeginUpdate();
for (RestyleEnumerateData* currentRestyle = restylesToProcess;
currentRestyle != lastRestyle;
++currentRestyle) {
ProcessOneRestyle(currentRestyle->mContent,
currentRestyle->mRestyleHint,
currentRestyle->mChangeHint);
}
EndUpdate();
#ifdef DEBUG
mPresShell->VerifyStyleTree();
#endif
}
if (mRebuildAllStyleData) {
// We probably wasted a lot of work up above, but this seems safest
// and it should be rarely used.
RebuildAllStyleData(nsChangeHint(0));
}
}
void
nsCSSFrameConstructor::PostRestyleEvent(nsIContent* aContent,
nsReStyleHint aRestyleHint,
nsChangeHint aMinChangeHint)
{
if (NS_UNLIKELY(mIsDestroyingFrameTree)) {
NS_NOTREACHED("PostRestyleEvent after the shell is destroyed (bug 279505)");
return;
}
if (aRestyleHint == 0 && !aMinChangeHint) {
// Nothing to do here
return;
}
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eELEMENT),
"Shouldn't be trying to restyle non-elements directly");
RestyleData existingData;
existingData.mRestyleHint = nsReStyleHint(0);
existingData.mChangeHint = NS_STYLE_HINT_NONE;
mPendingRestyles.Get(aContent, &existingData);
existingData.mRestyleHint =
nsReStyleHint(existingData.mRestyleHint | aRestyleHint);
NS_UpdateHint(existingData.mChangeHint, aMinChangeHint);
mPendingRestyles.Put(aContent, existingData);
PostRestyleEventInternal();
}
void
nsCSSFrameConstructor::PostRestyleEventInternal()
{
if (!mRestyleEvent.IsPending()) {
nsRefPtr<RestyleEvent> ev = new RestyleEvent(this);
if (NS_FAILED(NS_DispatchToCurrentThread(ev))) {
NS_WARNING("failed to dispatch restyle event");
// XXXbz and what?
} else {
mRestyleEvent = ev;
}
}
}
void
nsCSSFrameConstructor::PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint)
{
NS_ASSERTION(!(aExtraHint & nsChangeHint_ReconstructFrame),
"Should not reconstruct the root of the frame tree. "
"Use ReconstructDocElementHierarchy instead.");
mRebuildAllStyleData = PR_TRUE;
NS_UpdateHint(mRebuildAllExtraHint, aExtraHint);
// Get a restyle event posted if necessary
PostRestyleEventInternal();
}
NS_IMETHODIMP nsCSSFrameConstructor::RestyleEvent::Run()
{
if (!mConstructor)
return NS_OK; // event was revoked
// Make sure that any restyles that happen from now on will go into
// a new event.
mConstructor->mRestyleEvent.Forget();
return mConstructor->mPresShell->FlushPendingNotifications(Flush_Style);
}
NS_IMETHODIMP
nsCSSFrameConstructor::LazyGenerateChildrenEvent::Run()
{
mPresShell->GetDocument()->FlushPendingNotifications(Flush_Layout);
// this is hard-coded to handle only menu popup frames
nsIFrame* frame = mPresShell->GetPrimaryFrameFor(mContent);
if (frame && frame->GetType() == nsGkAtoms::menuPopupFrame) {
#ifdef MOZ_XUL
// it is possible that the frame is different than the one that requested
// the lazy generation, but as long as it's a popup frame that hasn't
// generated its children yet, that's OK.
nsMenuPopupFrame* menuPopupFrame = static_cast<nsMenuPopupFrame *>(frame);
if (menuPopupFrame->HasGeneratedChildren()) {
if (mCallback)
mCallback(mContent, frame, mArg);
return NS_OK;
}
// indicate that the children have been generated
menuPopupFrame->SetGeneratedChildren();
#endif
{
nsAutoScriptBlocker scriptBlocker;
nsCSSFrameConstructor* fc = mPresShell->FrameConstructor();
fc->BeginUpdate();
nsFrameItems childItems;
nsFrameConstructorState state(mPresShell, nsnull, nsnull, nsnull);
nsresult rv = fc->ProcessChildren(state, mContent, frame->GetStyleContext(),
frame, PR_FALSE, childItems, PR_FALSE);
if (NS_FAILED(rv)) {
fc->EndUpdate();
return rv;
}
frame->SetInitialChildList(nsnull, childItems.childList);
fc->EndUpdate();
}
if (mCallback)
mCallback(mContent, frame, mArg);
// call XBL constructors after the frames are created
mPresShell->GetDocument()->BindingManager()->ProcessAttachedQueue();
}
return NS_OK;
}
View git blame Copy permalink