| blob | d7fd0bb6e09e2dea69268a95b4db5534178b4ee8 |
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 // vim:cindent:ts=2:et:sw=2:
3 /* ***** BEGIN LICENSE BLOCK *****
4 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5 *
6 * The contents of this file are subject to the Mozilla Public License Version
7 * 1.1 (the "License"); you may not use this file except in compliance with
8 * the License. You may obtain a copy of the License at
9 * http://www.mozilla.org/MPL/
10 *
11 * Software distributed under the License is distributed on an "AS IS" basis,
12 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13 * for the specific language governing rights and limitations under the
14 * License.
15 *
16 * The Original Code is mozilla.org code.
17 *
18 * The Initial Developer of the Original Code is
19 * Netscape Communications Corporation.
20 * Portions created by the Initial Developer are Copyright (C) 1998
21 * the Initial Developer. All Rights Reserved.
22 *
23 * Contributor(s):
24 * Dan Rosen <dr@netscape.com>
25 * Mats Palmgren <matspal@gmail.com>
26 *
27 * Alternatively, the contents of this file may be used under the terms of
28 * either of the GNU General Public License Version 2 or later (the "GPL"),
29 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
30 * in which case the provisions of the GPL or the LGPL are applicable instead
31 * of those above. If you wish to allow use of your version of this file only
32 * under the terms of either the GPL or the LGPL, and not to allow others to
33 * use your version of this file under the terms of the MPL, indicate your
34 * decision by deleting the provisions above and replace them with the notice
35 * and other provisions required by the GPL or the LGPL. If you do not delete
36 * the provisions above, a recipient may use your version of this file under
37 * the terms of any one of the MPL, the GPL or the LGPL.
38 *
39 * ***** END LICENSE BLOCK ***** */
41 /*
42 * construction of a frame tree that is nearly isomorphic to the content
43 * tree and updating of that tree in response to dynamic changes
44 */
125 #ifdef MOZ_XUL
130 #endif
131 #ifdef ACCESSIBILITY
134 #endif
143 #undef NOISY_FIRST_LETTER
145 #ifdef MOZ_MATHML
147 #endif
148 #ifdef MOZ_SVG
153 #endif
160 nsIFrame*
163 #if defined(MOZ_MEDIA)
164 nsIFrame*
166 #endif
168 #ifdef MOZ_SVG
171 PRBool
173 nsIFrame*
175 nsIFrame*
177 nsIFrame*
179 nsIFrame*
181 nsIFrame*
183 nsIFrame*
185 nsIFrame*
187 nsIFrame*
189 nsIFrame*
191 nsIFrame*
193 nsIFrame*
195 nsIFrame*
197 nsIFrame*
205 nsIFrame*
209 nsIFrame*
211 nsIFrame*
213 nsIFrame*
215 nsIFrame*
217 nsIFrame*
219 nsIFrame*
221 #endif
236 // Global object maintenance
239 #ifdef DEBUG
240 // Set the environment variable GECKO_FRAMECTOR_DEBUG_FLAGS to one or
241 // more of the following flags (comma separated) for handy debug
242 // output.
250 };
256 };
258 #define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
259 #endif
262 #ifdef MOZ_XUL
273 //------------------------------------------------------------------
275 nsIFrame*
278 nsIFrame*
281 nsIFrame*
284 nsIFrame*
287 nsIFrame*
290 nsIFrame*
293 nsIFrame*
296 nsIFrame*
299 nsIFrame*
302 nsIFrame*
305 nsIFrame*
308 nsIFrame*
311 nsIFrame*
314 nsIFrame*
317 nsIFrame*
320 nsIFrame*
323 nsIFrame*
326 nsIFrame*
329 // grid
330 nsresult
332 nsIFrame*
334 nsIFrame*
337 // end grid
339 nsIFrame*
342 nsIFrame*
346 #endif
348 nsIFrame*
351 nsIFrame*
354 nsIFrame*
357 nsIFrame*
360 nsIFrame*
364 #ifdef NOISY_FINDFRAME
370 #endif
374 {
375 // Depends on the fieldset child frame order - see ConstructFieldSetFrame() below.
378 }
380 #define FCDATA_DECL(_flags, _func) \
381 { _flags, { (FrameCreationFunc)_func } }
383 //----------------------------------------------------------------------
385 static PRBool
387 {
389 }
391 /**
392 * True if aFrame is an actual inline frame in the sense of non-replaced
393 * display:inline CSS boxes. In other words, it can be affected by {ib}
394 * splitting and can contain first-letter frames. Basically, this is either an
395 * inline frame (positioned or otherwise) or an line frame (this last because
396 * it can contain first-letter and because inserting blocks in the middle of it
397 * needs to terminate it).
398 */
399 static PRBool
401 {
403 }
405 /**
406 * If any children require a block parent, return the first such child.
407 * Otherwise return null.
408 */
411 {
413 // Line participants, such as text and inline frames, can't be
414 // directly inside a XUL box; they must be wrapped in an
415 // intermediate block.
418 }
419 }
421 }
423 // Reparent a frame into a wrapper frame that is a child of its old parent.
424 static void
428 {
431 }
433 static void
437 {
440 }
441 }
443 //----------------------------------------------------------------------
444 //
445 // When inline frames get weird and have block frames in them, we
446 // annotate them to help us respond to incremental content changes
447 // more easily.
451 {
453 }
456 {
459 // We only store the "special sibling" annotation with the first
460 // frame in the continuation chain. Walk back to find that frame now.
464 }
467 {
470 // We only store the "special sibling" annotation with the first
471 // frame in the continuation chain. Walk back to find that frame now.
475 }
479 {
488 }
489 }
492 }
494 static void
496 {
499 // We should be the only continuation
506 // Mark the frame as "special".
511 "assigning something other than the first continuation as the "
514 // Store the "special sibling" (if we were given one) with the
515 // first frame in the flow.
519 }
520 }
524 {
528 // Get the first "normal" ancestor of the target frame.
536 }
538 // Note that we ignore non-special frames which have a pseudo on their
539 // style context -- they're not the frames we're looking for! In
540 // particular, they may be hiding a real parent that _is_ special.
548 // post-conditions
549 NS_ASSERTION(parentFrame, "no normal ancestor found for special frame in GetIBContainingBlockFor");
553 }
555 //----------------------------------------------------------------------
557 // Block/inline frame construction logic. We maintain a few invariants here:
558 //
559 // 1. Block frames contain block and inline frames.
560 //
561 // 2. Inline frames only contain inline frames. If an inline parent has a block
562 // child then the block child is migrated upward until it lands in a block
563 // parent (the inline frames containing block is where it will end up).
565 // After this function returns, aLink is pointing to the first link at or
566 // after its starting position for which the next frame is a block. If there
567 // is no such link, it points to the end of the list.
568 static void
570 {
574 }
575 }
576 }
578 // This function returns a frame link enumerator pointing to the first link in
579 // the list for which the next frame is not block. If there is no such link,
580 // it points to the end of the list.
583 {
588 }
589 }
591 }
595 {
599 }
601 // -----------------------------------------------------------
603 // Structure used when constructing formatting object trees.
605 {
606 // Appends the frame to the end of the list
608 };
610 void
612 {
615 // It'd be really nice if we could just AppendFrames(nsnull, aChild) here,
616 // but some of our callers put frames that have different
617 // parents (caption, I'm looking at you) on the same framelist, and
618 // nsFrameList asserts if you try to do that.
621 }
627 }
628 }
630 // -----------------------------------------------------------
632 // Structure used when constructing formatting object trees. Contains
633 // state information needed for absolutely positioned elements
635 // containing block for absolutely positioned elements
639 #ifdef DEBUG
640 // XXXbz Does this need a debug-only assignment operator that nulls out the
641 // childList in the nsAbsoluteItems we're copying? Introducing a difference
642 // between debug and non-debug behavior seems bad, so I guess not...
646 }
647 #endif
649 // Appends the frame to the end of the list
651 };
655 {
656 }
658 // Additional behavior is that it sets the frame's NS_FRAME_OUT_OF_FLOW flag
659 void
661 {
667 }
669 // -----------------------------------------------------------
671 // Structure for saving the existing state when pushing/poping containing
672 // blocks. The destructor restores the state to its previous state
683 PRPackedBool mSavedFixedPosIsAbsPos;
685 // The name of the child list in which our frames would belong
690 };
692 // Structure used to keep track of a list of bindings we need to call
693 // AddToAttachedQueue on. These should be in post-order depth-first
694 // flattened tree traversal order.
696 {
697 #ifdef NS_BUILD_REFCNT_LOGGING
700 }
703 }
704 #endif
707 };
709 // Structure used for maintaining state information during the
710 // frame construction process
717 #ifdef MOZ_XUL
718 // Frames destined for the nsGkAtoms::popupList.
719 nsAbsoluteItems mPopupItems;
720 #endif
722 // Containing block information for out-of-flow frames.
723 nsAbsoluteItems mFixedItems;
724 nsAbsoluteItems mAbsoluteItems;
725 nsAbsoluteItems mFloatedItems;
728 // These bits will be added to the state bits of any frame we construct
729 // using this state.
730 nsFrameState mAdditionalStateBits;
732 // When working with the -moz-transform property, we want to hook
733 // the abs-pos and fixed-pos lists together, since transformed
734 // elements are fixed-pos containing blocks. This flag determines
735 // whether or not we want to wire the fixed-pos and abs-pos lists
736 // together.
737 PRPackedBool mFixedPosIsAbsPos;
739 // A boolean to indicate whether we have a "pending" popupgroup. That is, we
740 // have already created the FrameConstructionItem for the root popupgroup but
741 // we have not yet created the relevant frame.
742 PRPackedBool mHavePendingPopupgroup;
744 // If true (which is the default) then call SetPrimaryFrame() as needed
745 // during frame construction. If false, don't make any SetPrimaryFrame()
746 // calls. The mSetPrimaryFrames == PR_FALSE mode is meant to be used for
747 // construction of random "extra" frames for elements via normal frame
748 // construction APIs (e.g. replication of things across pages in paginated
749 // mode).
750 PRPackedBool mSetPrimaryFrames;
754 // Constructor
755 // Use the passed-in history state.
761 // Get the history state from the pres context's pres shell.
769 // Function to push the existing absolute containing block state and
770 // create a new scope. Code that uses this function should get matching
771 // logic in GetAbsoluteContainingBlock.
775 // Function to push the existing float containing block state and
776 // create a new scope. Code that uses this function should get matching
777 // logic in GetFloatContainingBlock.
778 // Pushing a null float containing block forbids any frames from being
779 // floated until a new float containing block is pushed.
780 // XXX we should get rid of null float containing blocks and teach the
781 // various frame classes to deal with floats instead.
785 // Function to return the proper geometric parent for a frame with display
786 // struct given by aStyleDisplay and parent's frame given by
787 // aContentParentFrame.
791 /**
792 * Function to add a new frame to the right frame list. This MUST be called
793 * on frames before their children have been processed if the frames might
794 * conceivably be out-of-flow; otherwise cleanup in error cases won't work
795 * right. Also, this MUST be called on frames after they have been
796 * initialized.
797 * @param aNewFrame the frame to add
798 * @param aFrameItems the list to add in-flow frames to
799 * @param aContent the content pointer for aNewFrame
800 * @param aStyleContext the style context resolved for aContent
801 * @param aParentFrame the parent frame for the content if it were in-flow
802 * @param aCanBePositioned pass false if the frame isn't allowed to be
803 * positioned
804 * @param aCanBeFloated pass false if the frame isn't allowed to be
805 * floated
806 * @param aIsOutOfFlowPopup pass true if the frame is an out-of-flow popup
807 * (XUL-only)
808 * @throws NS_ERROR_OUT_OF_MEMORY if it happens.
809 * @note If this method throws, that means that aNewFrame was not inserted
810 * into any frame lists. Furthermore, this method will handle cleanup
811 * of aNewFrame (via calling Destroy() on it).
812 */
824 /**
825 * Function to return the fixed-pos element list. Normally this will just hand back the
826 * fixed-pos element list, but in case we're dealing with a transformed element that's
827 * acting as an abs-pos and fixed-pos container, we'll hand back the abs-pos list. Callers should
828 * use this function if they want to get the list acting as the fixed-pos item parent.
829 */
831 {
833 }
835 {
837 }
840 /**
841 * class to automatically push and pop a pending binding in the frame
842 * constructor state. See nsCSSFrameConstructor::FrameConstructionItem
843 * mPendingBinding documentation.
844 */
853 {
857 }
858 }
861 {
863 }
868 };
870 /**
871 * Add a new pending binding to the list
872 */
875 }
880 /**
881 * ProcessFrameInsertions takes the frames in aFrameItems and adds them as
882 * kids to the aChildListName child list of |aFrameItems.containingBlock|.
883 */
887 // Our list of all pending bindings. When we're done, we need to call
888 // AddToAttachedQueue on all of them, in order.
889 PRCList mPendingBindings;
892 };
902 #ifdef MOZ_XUL
904 #endif
908 // See PushAbsoluteContaningBlock below
917 {
918 #ifdef MOZ_XUL
922 }
923 #endif
926 }
935 #ifdef MOZ_XUL
937 #endif
941 // See PushAbsoluteContaningBlock below
949 {
950 #ifdef MOZ_XUL
954 }
955 #endif
959 }
962 {
963 // Frame order comparison functions only work properly when the placeholders
964 // have been inserted into the frame tree. So for example if we have a new float
965 // containing the placeholder for a new abs-pos frame, and we process the abs-pos
966 // insertion first, then we won't be able to find the right place to insert in
967 // in the abs-pos list. So put floats in first, because they can contain placeholders
968 // for abs-pos and fixed-pos items whose containing blocks are outside the floats.
969 // Then put abs-pos frames in, because they can contain placeholders for fixed-pos
970 // items whose containing block is outside the abs-pos frames.
975 #ifdef MOZ_XUL
977 #endif
981 }
991 }
992 }
996 {
999 }
1001 // Always use the container's first continuation. (Inline frames can have
1002 // non-fluid bidi continuations...)
1004 }
1006 void
1009 {
1015 /* Store whether we're wiring the abs-pos and fixed-pos lists together. */
1019 mAbsoluteItems =
1022 /* See if we're wiring the fixed-pos and abs-pos lists together. This happens iff
1023 * we're a transformed element.
1024 */
1027 }
1029 void
1032 {
1041 }
1043 nsIFrame*
1046 {
1049 // If there is no container for a fixed, absolute, or floating root
1050 // frame, we will ignore the positioning. This hack is originally
1051 // brought to you by the letter T: tables, since other roots don't
1052 // even call into this code. See bug 178855.
1053 //
1054 // XXX Disabling positioning in this case is a hack. If one was so inclined,
1055 // one could support this either by (1) inserting a dummy block between the
1056 // table and the canvas or (2) teaching the canvas how to reflow positioned
1057 // elements. (1) has the usual problems when multiple frames share the same
1058 // content (notice all the special cases in this file dealing with inner
1059 // tables and outer tables which share the same content). (2) requires some
1060 // work and possible factoring.
1061 //
1062 // XXXbz couldn't we just force position to "static" on roots and
1063 // float to "none"? That's OK per CSS 2.1, as far as I can tell.
1069 }
1074 }
1079 }
1082 }
1084 nsresult
1090 PRBool aCanBePositioned,
1091 PRBool aCanBeFloated,
1092 PRBool aIsOutOfFlowPopup,
1093 PRBool aInsertAfter,
1095 {
1100 // The comments in GetGeometricParent regarding root table frames
1101 // all apply here, unfortunately.
1104 nsFrameState placeholderType;
1106 #ifdef MOZ_XUL
1114 }
1115 else
1124 }
1133 }
1141 }
1142 }
1148 nsresult rv =
1150 aContent,
1151 aNewFrame,
1152 aStyleContext,
1153 aParentFrame,
1154 nsnull,
1155 placeholderType,
1158 // Note that aNewFrame could be the top frame for a scrollframe setup,
1159 // hence already set as the primary frame. So we have to clean up here.
1160 // But it shouldn't have any out-of-flow kids.
1161 // XXXbz Maybe add a utility function to assert that?
1164 }
1167 // Add the placeholder frame to the flow
1169 }
1170 #ifdef DEBUG
1174 }
1175 #endif
1181 }
1184 }
1186 void
1189 {
1190 #define NS_NONXUL_LIST_TEST (&aFrameItems == &mFloatedItems && \
1191 aChildListName == nsGkAtoms::floatList) || \
1192 (&aFrameItems == &mAbsoluteItems && \
1193 aChildListName == nsGkAtoms::absoluteList) || \
1194 (&aFrameItems == &mFixedItems && \
1195 aChildListName == nsGkAtoms::fixedList)
1196 #ifdef MOZ_XUL
1201 #else
1204 #endif
1208 }
1215 // Insert the frames hanging out in aItems. We can use SetInitialChildList()
1216 // if the containing block hasn't been reflowed yet (so NS_FRAME_FIRST_REFLOW
1217 // is set) and doesn't have any frames in the aChildListName child list yet.
1224 // Note that whether the frame construction context is doing an append or
1225 // not is not helpful here, since it could be appending to some frame in
1226 // the middle of the document, which means we're not necessarily
1227 // appending to the children of the containing block.
1228 //
1229 // We need to make sure the 'append to the end of document' case is fast.
1230 // So first test the last child of the containing block
1233 // CompareTreePosition uses placeholder hierarchy for out of flow frames,
1234 // so this will make out-of-flows respect the ordering of placeholders,
1235 // which is great because it takes care of anonymous content.
1239 // no lastChild, or lastChild comes before the new children, so just append
1242 // try the other children
1246 PRInt32 compare =
1249 // f comes after the new children, so stop here and insert after
1250 // the previous frame
1252 }
1254 }
1256 aFrameItems);
1257 }
1258 }
1262 // XXXbz And if NS_FAILED(rv), what? I guess we need to clean up the list
1263 // and deal with all the placeholders... but what if the placeholders aren't
1264 // in the document yet? Could that happen?
1266 }
1276 {
1277 }
1280 {
1281 // Restore the state
1286 #ifdef DEBUG
1287 // We've transferred the child list, so drop the pointer we held to it.
1288 // Note that this only matters for the assert in ~nsAbsoluteItems.
1290 #endif
1291 }
1294 }
1295 }
1297 static
1299 {
1303 }
1304 }
1307 }
1309 /**
1310 * Moves aFrameList from aOldParent to aNewParent. This updates the parent
1311 * pointer of the frames in the list, and reparents their views as needed.
1312 * nsFrame::SetParent sets the NS_FRAME_HAS_VIEW bit on aNewParent and its
1313 * ancestors as needed. Then it sets the list as the initial child list
1314 * on aNewParent, unless aNewParent either already has kids or has been
1315 * reflowed; in that case it appends the new frames. Note that this
1316 * method differs from ReparentFrames in that it doesn't change the kids'
1317 * style contexts.
1318 */
1319 // XXXbz Since this is only used for {ib} splits, could we just copy the view
1320 // bits from aOldParent to aNewParent and then use the
1321 // nsFrameList::ApplySetParent? That would still leave us doing two passes
1322 // over the list, of course; if we really wanted to we could factor out the
1323 // relevant part of ReparentFrameViewList, I suppose... Or just get rid of
1324 // views, which would make most of this function go away.
1325 static void
1330 {
1334 // Move the frames into the new view
1337 }
1341 }
1348 }
1349 }
1351 //----------------------------------------------------------------------
1377 {
1378 // XXXbz this should be in Init() or something!
1380 // now what?
1381 }
1383 #ifdef DEBUG
1404 }
1406 }
1416 }
1425 }
1428 }
1429 }
1430 }
1431 #endif
1432 }
1435 {
1440 }
1443 }
1445 void
1447 {
1454 }
1457 // Technically we don't need to update anything if we destroyed only
1458 // USE nodes. However, this is unlikely to happen in the real world
1459 // since USE nodes generally go along with INCREMENT nodes.
1461 }
1462 }
1472 };
1474 static void
1479 {
1481 }
1488 {
1492 // XXX The quotes/counters code doesn't like the text pointer
1493 // being null in case of dynamic changes!
1496 }
1500 }
1503 DestroyGenConInitializer);
1505 }
1507 }
1513 PRUint32 aContentIndex)
1514 {
1515 // Get the content value
1522 // CSS had something specified that couldn't be converted to an
1523 // image object
1525 }
1527 // Create an image content object and pass it the image request.
1528 // XXX Check if it's an image type we can handle...
1531 nodeInfo = mDocument->NodeInfoManager()->GetNodeInfo(nsGkAtoms::mozgeneratedcontentimage, nsnull,
1532 kNameSpaceID_XHTML);
1538 }
1547 {
1554 nsAutoString nameSpaceVal;
1556 PRInt32 error;
1562 }
1564 }
1565 }
1569 }
1571 }
1575 }
1581 }
1585 {
1602 initializer);
1603 }
1613 {
1623 initializer);
1624 }
1627 {
1628 // Use the "alt" attribute; if that fails and the node is an HTML
1629 // <input>, try the value attribute and then fall back to some default
1630 // localized text we have.
1631 // XXX what if the 'alt' attribute is added later, how will we
1632 // detect that and do the right thing here?
1638 }
1647 }
1649 nsXPIDLString temp;
1653 }
1656 }
1660 }
1662 /*
1663 * aParentFrame - the frame that should be the parent of the generated
1664 * content. This is the frame for the corresponding content node,
1665 * which must not be a leaf frame.
1666 *
1667 * Any items created are added to aItems.
1668 *
1669 * We create an XML element (tag _moz_generated_content_before or
1670 * _moz_generated_content_after) representing the pseudoelement. We
1671 * create a DOM node for each 'content' item and make those nodes the
1672 * children of the XML element. Then we create a frame subtree for
1673 * the XML element as if it were a regular child of
1674 * aParentFrame/aParentContent, giving the XML element the ::before or
1675 * ::after style.
1676 */
1677 void
1684 {
1685 // XXXbz is this ever true?
1689 }
1693 // Probe for the existence of the pseudo-element
1695 pseudoStyleContext =
1697 aPseudoElement,
1698 aStyleContext);
1701 // |ProbePseudoStyleFor| checked the 'display' property and the
1702 // |ContentCount()| of the 'content' property for us.
1707 kNameSpaceID_None);
1718 }
1724 contentIndex);
1727 }
1728 }
1732 pseudoStyleContext,
1734 }
1736 /****************************************************
1737 ** BEGIN TABLE SECTION
1738 ****************************************************/
1740 // The term pseudo frame is being used instead of anonymous frame, since anonymous
1741 // frame has been used elsewhere to refer to frames that have generated content
1743 static PRBool
1745 {
1746 return
1755 }
1757 // Return whether the given frame is a table pseudo-frame. Note that
1758 // cell-content and table-outer frames have pseudo-types, but are always
1759 // created, even for non-anonymous cells and tables respectively. So for those
1760 // we have to examine the cell or table frame to see whether it's a pseudo
1761 // frame. In particular, a lone table caption will have an outer table as its
1762 // parent, but will also trigger construction of an empty inner table, which
1763 // will be the one we can examine to see whether the outer was a pseudo-frame.
1764 static PRBool
1766 {
1783 }
1785 /* static */
1788 {
1791 }
1794 }
1797 }
1800 }
1803 }
1807 {
1810 }
1812 }
1814 /**
1815 * If the parent frame is a |tableFrame| and the child is a
1816 * |captionFrame|, then we want to insert the frames beneath the
1817 * |tableFrame|'s parent frame. Returns |PR_TRUE| if the parent frame
1818 * needed to be fixed up.
1819 */
1820 static PRBool
1824 {
1831 }
1833 }
1835 void
1839 {
1846 NS_STYLE_DISPLAY_TABLE_CAPTION) {
1848 }
1849 }
1851 // Pull all the captions present in aItems out into aCaptions
1852 static void
1854 {
1861 }
1863 }
1864 }
1867 // Construct the outer, inner table frames and the children frames for the table.
1868 // XXX Page break frames for pseudo table frames are not constructed to avoid the risk
1869 // associated with revising the pseudo frame mechanism. The long term solution
1870 // of having frames handle page-break-before/after will solve the problem.
1871 nsresult
1878 {
1889 // create the pseudo SC for the outer table as a child of the inner SC
1894 // Create the outer table frame which holds the caption and inner table frame
1896 #ifdef MOZ_MATHML
1899 else
1900 #endif
1905 aParentFrame);
1907 // Init the table outer frame and see if we need to create a view, e.g.
1908 // the frame is absolutely positioned
1912 // Create the inner table frame
1914 #ifdef MOZ_MATHML
1917 else
1918 #endif
1923 // Put the newly created frames into the right child list
1927 aParentFrame);
1930 }
1933 // The frame we're constructing will be the root element frame.
1934 // Set mRootElementFrame before processing children.
1936 }
1938 nsFrameItems childItems;
1945 }
1946 // XXXbz what about cleaning up?
1949 nsFrameItems captionItems;
1952 // Set the inner table frame's initial primary list
1955 // Set the outer table frame's secondary childlist lists
1958 }
1962 }
1964 nsresult
1971 {
1979 #ifdef MOZ_MATHML
1982 else
1983 #endif
1988 }
1992 nsFrameItems childItems;
1993 nsresult rv;
1996 childItems);
2000 }
2008 }
2010 nsresult
2017 {
2024 }
2033 // construct additional col frames if the col frame has a span > 1
2039 }
2041 PR_FALSE);
2046 }
2049 }
2051 nsresult
2058 {
2068 #ifdef MOZ_MATHML
2069 // <mtable> is border separate in mathml.css and the MathML code doesn't implement
2070 // border collapse. For those users who style <mtable> with border collapse,
2071 // give them the default non-MathML table frames that understand border collapse.
2072 // This won't break us because MathML table frames are all subclasses of the default
2073 // table code, and so we can freely mix <mtable> with <mtr> or <tr>, <mtd> or <td>.
2074 // What will happen is just that non-MathML frames won't understand MathML attributes
2075 // and will therefore miss the special handling that the MathML code does.
2078 else
2079 #endif
2080 // Warning: If you change this and add a wrapper frame around table cell
2081 // frames, make sure Bug 368554 doesn't regress!
2082 // See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.
2087 }
2089 // Initialize the table cell frame
2093 // Resolve pseudo style and initialize the body cell frame
2098 // Create a block frame that will format the cell's content
2099 PRBool isBlock;
2101 #ifdef MOZ_MATHML
2105 }
2106 else
2107 #endif
2108 {
2111 }
2116 }
2120 nsFrameItems childItems;
2121 nsresult rv;
2123 // Need to push ourselves as a float containing block.
2124 // XXXbz it might be nice to work on getting the parent
2125 // FrameConstructionItem down into ProcessChildren and just making use of
2126 // the push there, but that's a bit of work.
2127 nsFrameConstructorSaveState floatSaveState;
2132 }
2135 childItems);
2137 // Process the child content
2140 }
2143 // Clean up
2144 // XXXbz kids of this stuff need to be cleaned up too!
2148 }
2156 }
2162 {
2163 // XXX the GetContent() != aChildContent check is needed due to bug 135040.
2164 // Remove it once that's fixed.
2170 // don't create a whitespace frame if aParentFrame doesn't want it.
2171 // always create frames for children in generated content. counter(),
2172 // quotes, and attr() content can easily change dynamically and we don't
2173 // want to be reconstructing frames. It's not even clear that these
2174 // should be considered ignorable just because they evaluate to
2175 // whitespace.
2177 // We could handle all this in CreateNeededTablePseudos or some other place
2178 // after we build our frame construction items, but that would involve
2179 // creating frame construction items for whitespace kids of
2180 // eExcludesIgnorableWhitespace frames, where we know we'll be dropping them
2181 // all anyway, and involve an extra walk down the frame construction item
2182 // list.
2187 }
2190 NS_REFRAME_IF_WHITESPACE);
2192 }
2194 /***********************************************
2195 * END TABLE SECTION
2196 ***********************************************/
2200 {
2206 NS_STYLE_OVERFLOW_HIDDEN);
2207 else
2211 }
2213 /**
2214 * This checks the root element and the HTML BODY, if any, for an "overflow" property
2215 * that should be applied to the viewport. If one is found then we return the
2216 * element that we took the overflow from (which should then be treated as
2217 * "overflow:visible"), and we store the overflow style in the prescontext.
2218 * @return if scroll was propagated from some content node, the content node it
2219 * was propagated from.
2220 */
2221 nsIContent*
2223 {
2224 // Set default
2227 NS_STYLE_OVERFLOW_AUTO);
2229 // We never mess with the viewport scroll state
2230 // when printing or in print preview
2233 }
2237 // Check the style on the document root element
2243 }
2245 // tell caller we stole the overflow style from the root element
2247 }
2249 // Don't look in the BODY for non-HTML documents or HTML documents
2250 // with non-HTML roots
2251 // XXX this should be earlier; we shouldn't even look at the document root
2252 // for non-HTML documents. Fix this once we support explicit CSS styling
2253 // of the viewport
2254 // XXX what about XHTML?
2258 }
2266 // The body is not a <body> tag, it's a <frameset>.
2268 }
2274 }
2277 // tell caller we stole the overflow style from the body element
2279 }
2282 }
2284 nsresult
2288 {
2298 // Make sure to call PropagateScrollToViewport before
2299 // SetUpDocElementContainingBlock, since it sets up our scrollbar state
2300 // properly.
2310 // XXXbz why, exactly?
2314 // Make sure that we'll handle restyles for this document element in
2315 // the future. We need this, because the document element might
2316 // have stale restyle bits from a previous frame constructor for
2317 // this document. Unlike in AddFrameConstructionItems, it's safe to
2318 // unset all element restyle flags, since we don't have any
2319 // siblings.
2322 // --------- CREATE AREA OR BOX FRAME -------
2325 nsnull);
2329 // Ensure that our XBL bindings are installed.
2331 // Get the XBL loader.
2332 nsresult rv;
2333 PRBool resolveStyle;
2348 // For backwards compat, keep firing the root's constructor
2349 // after all of its kids' constructors. So tell the binding
2350 // manager about it right now.
2352 }
2356 nsnull);
2358 }
2359 }
2361 // --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------
2363 #ifdef DEBUG
2368 #endif
2373 }
2375 nsFrameConstructorSaveState absoluteSaveState;
2377 // Push the absolute containing block now so we can absolutely position
2378 // the root element
2380 absoluteSaveState);
2381 }
2383 nsresult rv;
2385 // The rules from CSS 2.1, section 9.2.4, have already been applied
2386 // by the style system, so we can assume that display->mDisplay is
2387 // either NONE, BLOCK, or TABLE.
2389 // contentFrame is the primary frame for the root element. *aNewFrame
2390 // is the frame that will be the child of the initial containing block.
2391 // These are usually the same frame but they can be different, in
2392 // particular if the root frame is positioned, in which case
2393 // contentFrame is the out-of-flow frame and *aNewFrame is the
2394 // placeholder.
2398 // Check whether we need to build a XUL box or SVG root frame
2399 #ifdef MOZ_XUL
2404 }
2406 contentFrame);
2409 }
2410 else
2411 #endif
2412 #ifdef MOZ_SVG
2418 }
2421 mDocElementContainingBlock),
2424 // AddChild takes care of transforming the frame tree for fixed-pos
2425 // or abs-pos situations
2426 nsFrameItems frameItems;
2431 }
2435 // See if we need to create a view
2439 }
2440 }
2441 else
2442 #endif
2443 {
2446 // We're going to call the right function ourselves, so no need to give a
2447 // function to this FrameConstructionData.
2449 // XXXbz on the other hand, if we converted this whole function to
2450 // FrameConstructionData/Item, then we'd need the right function
2451 // here... but would probably be able to get away with less code in this
2452 // function in general.
2453 // Use a null PendingBinding, since our binding is not in fact pending.
2460 nsFrameItems frameItems;
2461 // if the document is a table then just populate it.
2476 nsFrameItems frameItems;
2477 // Use a null PendingBinding, since our binding is not in fact pending.
2480 mDocElementContainingBlock),
2483 nsnull);
2488 }
2489 }
2491 // set the primary frame
2499 // Figure out which frame has the main style for the document element,
2500 // assigning it to mRootElementStyleFrame.
2501 // Backgrounds should be propagated from that frame to the viewport.
2502 PRBool isChild;
2507 }
2510 // Still need to process the child content
2511 nsFrameItems childItems;
2515 // Use a null PendingBinding, since our binding is not in fact pending.
2519 // Set the initial child lists
2521 }
2526 }
2529 nsresult
2531 {
2537 // Set up our style rule observer.
2538 // XXXbz wouldn't this make more sense as part of presshell init?
2539 {
2541 }
2543 // --------- BUILD VIEWPORT -----------
2547 viewportPseudoStyle =
2552 // XXXbz do we _have_ to pass a null content pointer to that frame?
2553 // Would it really kill us to pass in the root element or something?
2554 // What would that break?
2557 // Bind the viewport frame to the root view
2565 rootView);
2567 // The viewport is the containing block for 'fixed' elements
2572 }
2574 nsresult
2576 {
2583 /*
2584 how the root frame hierarchy should look
2586 Galley presentation, non-XUL, with scrolling (i.e. not a frameset):
2588 ViewportFrame [fixed-cb]
2589 nsHTMLScrollFrame
2590 nsCanvasFrame [abs-cb]
2591 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
2592 nsTableOuterFrame, nsPlaceholderFrame)
2594 Galley presentation, non-XUL, without scrolling (i.e. a frameset):
2596 ViewportFrame [fixed-cb]
2597 nsCanvasFrame [abs-cb]
2598 root element frame (nsBlockFrame)
2600 Galley presentation, XUL
2602 ViewportFrame [fixed-cb]
2603 nsRootBoxFrame
2604 root element frame (nsDocElementBoxFrame)
2606 Print presentation, non-XUL
2608 ViewportFrame
2609 nsSimplePageSequenceFrame
2610 nsPageFrame [fixed-cb]
2611 nsPageContentFrame
2612 nsCanvasFrame [abs-cb]
2613 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
2614 nsTableOuterFrame, nsPlaceholderFrame)
2616 Print-preview presentation, non-XUL
2618 ViewportFrame
2619 nsHTMLScrollFrame
2620 nsSimplePageSequenceFrame
2621 nsPageFrame [fixed-cb]
2622 nsPageContentFrame
2623 nsCanvasFrame [abs-cb]
2624 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
2625 nsTableOuterFrame, nsPlaceholderFrame)
2627 Print/print preview of XUL is not supported.
2628 [fixed-cb]: the default containing block for fixed-pos content
2629 [abs-cb]: the default containing block for abs-pos content
2631 Meaning of nsCSSFrameConstructor fields:
2632 mRootElementFrame is "root element frame". This is the primary frame for
2633 the root element.
2634 mDocElementContainingBlock is the parent of mRootElementFrame
2635 (i.e. nsCanvasFrame or nsRootBoxFrame)
2636 mFixedContainingBlock is the [fixed-cb]
2637 mGfxScrollFrame is the nsHTMLScrollFrame mentioned above, or null if there isn't one
2638 mPageSequenceFrame is the nsSimplePageSequenceFrame, or null if there isn't one
2639 */
2641 // --------- CREATE ROOT FRAME -------
2644 // Create the root frame. The document element's frame is a child of the
2645 // root frame.
2646 //
2647 // The root frame serves two purposes:
2648 // - reserves space for any margins needed for the document element's frame
2649 // - renders the document element's background. This ensures the background covers
2650 // the entire canvas as specified by the CSS2 spec
2661 #ifdef MOZ_XUL
2663 {
2664 // pass a temporary stylecontext, the correct one will be set later
2667 #endif
2668 {
2669 // pass a temporary stylecontext, the correct one will be set later
2672 }
2677 // Create a page sequence frame
2681 }
2684 // --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------
2686 // If the device supports scrolling (e.g., in galley mode on the screen and
2687 // for print-preview, but not when printing), then create a scroll frame that
2688 // will act as the scrolling mechanism for the viewport.
2689 // XXX Do we even need a viewport when printing to a printer?
2691 // As long as the docshell doesn't prohibit it, and the device supports
2692 // it, create a scroll frame that will act as the scolling mechanism for
2693 // the viewport.
2694 //
2695 // Threre are three possible values stored in the docshell:
2696 // 1) nsIScrollable::Scrollbar_Never = no scrollbars
2697 // 2) nsIScrollable::Scrollbar_Auto = scrollbars appear if needed
2698 // 3) nsIScrollable::Scrollbar_Always = scrollbars always
2699 // Only need to create a scroll frame/view for cases 2 and 3.
2706 }
2708 // Never create scrollbars for XUL documents
2711 // Never create scrollbars for frameset documents.
2716 }
2720 }
2722 // We no longer need to do overflow propagation here. It's taken care of
2723 // when we construct frames for the element whose overflow might be
2724 // propagated
2730 // we must create a state because if the scrollbars are GFX it needs the
2731 // state to build the scrollbar frames.
2734 // Start off with the viewport as parent; we'll adjust it as needed.
2738 // If paginated, make sure we don't put scrollbars in
2741 viewportPseudoStyle);
2749 }
2751 // Build the frame. We give it the content we are wrapping which is the
2752 // document element, the root frame, the parent view port frame, and we
2753 // should get back the new frame and the scrollable view if one was
2754 // created.
2756 // resolve a context for the scrollframe
2759 viewportPseudoStyle);
2761 // Note that the viewport scrollframe is always built with
2762 // overflow:auto style. This forces the scroll frame to create
2763 // anonymous content for both scrollbars. This is necessary even
2764 // if the HTML or BODY elements are overriding the viewport
2765 // scroll style to 'hidden' --- dynamic style changes might put
2766 // scrollbars back on the viewport and we don't want to have to
2767 // reframe the viewport to create the scrollbar content.
2770 aDocElement,
2771 styleContext,
2772 viewportFrame,
2773 rootPseudo,
2774 PR_TRUE,
2775 newFrame);
2778 }
2785 }
2788 // Create the first page
2789 // Set the initial child lists
2795 // The eventual parent of the document element frame.
2796 // XXX should this be set for every new page (in ConstructPageFrame)?
2799 }
2806 }
2809 }
2811 nsresult
2818 {
2824 parentStyleContext);
2830 // Initialize the page frame and force it to have a view. This makes printing of
2831 // the pages easier and faster.
2835 pageContentPseudoStyle =
2837 pagePseudoStyle);
2843 // Initialize the page content frame and force it to have a view. Also make it the
2844 // containing block for fixed elements which are repeated on every page.
2849 }
2856 pageContentPseudoStyle);
2866 }
2871 }
2873 /* static */
2874 nsresult
2881 nsFrameState aTypeBit,
2883 {
2887 // The placeholder frame gets a pseudo style context
2890 aTypeBit);
2895 // The placeholder frame has a pointer back to the out-of-flow frame
2900 // Add mapping from absolutely positioned frame to its placeholder frame
2906 }
2909 }
2910 }
2912 // Clears any lazy bits set in the range [aStartContent, aEndContent). If
2913 // aEndContent is null, that means to clear bits in all siblings starting with
2914 // aStartContent. aStartContent must not be null unless aEndContent is also
2915 // null. We do this so that when new children are inserted under elements whose
2916 // frame is a leaf the new children don't cause us to try to construct frames
2917 // for the existing children again.
2920 {
2926 }
2927 }
2929 nsresult
2936 {
2944 }
2947 }
2950 }
2951 // Initialize the button frame
2958 }
2959 // See if we need to create a view
2963 innerBlockContext =
2965 styleContext);
2968 NS_BLOCK_FLOAT_MGR);
2973 }
2979 }
2982 aParentFrame);
2987 }
2990 #ifdef DEBUG
2991 // Make sure that we're an anonymous content creator exactly when we're a
2992 // leaf
2996 #endif
2999 // Process children
3000 nsFrameConstructorSaveState absoluteSaveState;
3001 nsFrameItems childItems;
3004 // The area frame becomes a container for child frames that are
3005 // absolutely positioned
3007 }
3009 #ifdef DEBUG
3010 // Make sure that anonymous child creation will have no effect in this case
3013 #endif
3020 // Set the areas frame's initial child lists
3022 }
3029 nsFrameItems anonymousChildItems;
3030 // if there are any anonymous children create frames for them. Note that
3031 // we're doing this using a different parent frame from the one we pass to
3032 // ProcessChildren!
3034 anonymousChildItems);
3036 // the anonymous content is already parented to the area frame
3038 anonymousChildItems);
3039 }
3040 }
3042 // our new button frame returned is the top frame.
3046 }
3048 nsresult
3055 {
3062 // Construct a frame-based listbox or combobox
3069 // Construct a combobox if size=1 or no size is specified and its multiple select
3070 if (((1 == size || 0 == size) || (kNoSizeSpecified == size)) && (PR_FALSE == multipleSelect)) {
3071 // Construct a frame-based combo box.
3072 // The frame-based combo box is built out of three parts. A display area, a button and
3073 // a dropdown list. The display area and button are created through anonymous content.
3074 // The drop-down list's frame is created explicitly. The combobox frame shares its content
3075 // with the drop-down list.
3079 // Save the history state so we don't restore during construction
3080 // since the complete tree is required before we restore.
3083 // Initialize the combobox frame
3091 aParentFrame);
3094 }
3096 ///////////////////////////////////////////////////////////////////
3097 // Combobox - Old Native Implementation
3098 ///////////////////////////////////////////////////////////////////
3103 // Resolve pseudo element style for the dropdown list
3108 // Create a listbox
3111 // Notify the listbox that it is being used as a dropdown list.
3115 }
3116 // Notify combobox that it should use the listbox as it's popup
3124 // Initialize the scroll frame positioned. Note that it is NOT
3125 // initialized as absolutely positioned.
3132 // Set flag so the events go to the listFrame not child frames.
3133 // XXX: We should replace this with a real widget manager similar
3134 // to how the nsFormControlFrame works. Re-directing events is a temporary Kludge.
3136 //listFrame->GetView()->SetViewFlags(NS_VIEW_PUBLIC_FLAG_DONT_CHECK_CHILDREN);
3138 // Create display and button frames from the combobox's anonymous content.
3139 // The anonymous content is appended to existing anonymous content for this
3140 // element (the scrollbars).
3142 nsFrameItems childItems;
3148 // Initialize the additional popup child list which contains the
3149 // dropdown list frame.
3150 nsFrameItems popupItems;
3153 popupItems);
3158 // Restore frame state for the entire subtree of |comboboxFrame|.
3161 }
3163 ///////////////////////////////////////////////////////////////////
3164 // ListBox - Old Native Implementation
3165 ///////////////////////////////////////////////////////////////////
3169 }
3172 }
3177 // ******* this code stolen from Initialze ScrollFrame ********
3178 // please adjust this code to use BuildScrollFrame.
3185 }
3186 }
3189 }
3191 /**
3192 * Used to be InitializeScrollFrame but now it's only used for the select tag
3193 * But the select tag should really be fixed to use GFX scrollbars that can
3194 * be create with BuildScrollFrame.
3195 */
3196 nsresult
3203 PRBool aBuildCombobox,
3206 {
3209 // Initialize it
3212 // We don't call InitAndRestoreFrame for scrollFrame because we can only
3213 // restore the frame state after its parts have been created (in particular,
3214 // the scrollable view). So we have to split Init and Restore.
3216 // Initialize the frame
3224 }
3225 }
3229 // Give the drop-down list a popup widget
3235 nsWidgetInitData widgetData;
3239 }
3240 }
3246 // Restore frame state for the scroll frame
3248 }
3250 // Process children
3251 nsFrameConstructorSaveState absoluteSaveState;
3252 nsFrameItems childItems;
3255 // The area frame becomes a container for child frames that are
3256 // absolutely positioned
3258 }
3263 // Set the scrolled frame's initial child lists
3266 }
3268 nsresult
3275 {
3282 }
3284 // Initialize it
3289 // See if we need to create a view, e.g. the frame is absolutely
3290 // positioned
3293 // Resolve style and initialize the frame
3299 NS_BLOCK_FLOAT_MGR |
3300 NS_BLOCK_MARGIN_ROOT);
3304 aParentFrame);
3307 }
3309 // Process children
3310 nsFrameConstructorSaveState absoluteSaveState;
3311 nsFrameItems childItems;
3314 // The area frame becomes a container for child frames that are
3315 // absolutely positioned
3316 // XXXbz this is probably wrong, and once arbitrary frames can be absolute
3317 // containing blocks we should fix this..
3319 }
3324 nsFrameItems fieldsetKids;
3330 // We want the legend to be the first frame in the fieldset child list.
3331 // That way the EventStateManager will do the right thing when tabbing
3332 // from a selection point within the legend (bug 236071), which is
3333 // used for implementing legend access keys (bug 81481).
3334 // GetAdjustedParentFrame() below depends on this frame order.
3336 // Make sure to reparent the legend so it has the fieldset as the parent.
3339 }
3340 }
3342 // Set the inner frame's initial child lists
3345 // Set the outer frame's initial child list
3348 // our new frame returned is the top frame which is the list frame.
3352 }
3356 {
3364 }
3366 }
3368 #define SIMPLE_FCDATA(_func) FCDATA_DECL(0, _func)
3369 #define FULL_CTOR_FCDATA(_flags, _func) \
3370 { _flags | FCDATA_FUNC_IS_FULL_CTOR, { nsnull }, _func }
3372 /* static */
3375 {
3376 #ifdef MOZ_SVG
3386 }
3387 }
3389 }
3390 #endif
3395 }
3397 nsresult
3404 {
3418 }
3420 // We never need to create a view for a text frame.
3424 initializer =
3431 }
3433 }
3434 }
3436 // Add the newly constructed frame to the flow
3443 }
3445 /* static */
3451 PRUint32 aDataLength)
3452 {
3461 }
3464 }
3465 }
3468 }
3470 /* static */
3476 PRUint32 aDataLength)
3477 {
3486 }
3489 }
3490 }
3493 }
3495 #define SUPPRESS_FCDATA() FCDATA_DECL(FCDATA_SUPPRESS_FRAME, nsnull)
3496 #define SIMPLE_INT_CREATE(_int, _func) { _int, SIMPLE_FCDATA(_func) }
3497 #define SIMPLE_INT_CHAIN(_int, _func) \
3498 { _int, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) }
3499 #define COMPLEX_INT_CREATE(_int, _func) \
3500 { _int, FULL_CTOR_FCDATA(0, _func) }
3502 #define SIMPLE_TAG_CREATE(_tag, _func) \
3503 { &nsGkAtoms::_tag, SIMPLE_FCDATA(_func) }
3504 #define SIMPLE_TAG_CHAIN(_tag, _func) \
3505 { &nsGkAtoms::_tag, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) }
3506 #define COMPLEX_TAG_CREATE(_tag, _func) \
3507 { &nsGkAtoms::_tag, FULL_CTOR_FCDATA(0, _func) }
3509 /* static */
3513 PRInt32 aNameSpaceID,
3516 {
3517 // Ignore the tag if it's not HTML content and if it doesn't extend (via XBL)
3518 // a valid HTML namespace. This check must match the one in
3519 // ShouldHaveFirstLineStyle.
3522 }
3539 // <legend> is only special inside fieldset, check both the frame tree
3540 // parent and content tree parent due to XBL issues. For floated or
3541 // absolutely positioned legends we want to construct by display type and
3542 // not do special legend stuff.
3543 // XXXbz it would be nice if we could just decide this based on the parent
3544 // tag, and hence just use a SIMPLE_TAG_CHAIN for legend below, but the
3545 // fact that with XBL we could end up with this legend element in some
3546 // totally weird insertion point makes that chancy, I think.
3548 }
3556 NS_NewBRFrame) },
3572 #if defined(MOZ_MEDIA)
3575 #endif
3577 };
3581 }
3583 /* static */
3587 {
3590 }
3594 }
3596 /* static */
3600 {
3603 }
3608 }
3610 /* static */
3614 {
3633 // Keeping hidden inputs out of here on purpose for so they get frames by
3634 // display (in practice, none).
3635 };
3642 }
3644 /* static */
3648 {
3649 // GetDisplayedType isn't necessarily nsIObjectLoadingContent::TYPE_NULL for
3650 // cases when the object is broken/suppressed/etc (e.g. a broken image), but
3651 // we want to treat those cases as TYPE_NULL
3652 PRUint32 type;
3655 NS_EVENT_STATE_SUPPRESSED)) {
3660 "applet, embed and object must implement "
3664 }
3668 NS_NewEmptyFrame),
3670 NS_NewObjectFrame),
3672 NS_NewImageFrame),
3674 NS_NewSubDocumentFrame)
3675 // Nothing for TYPE_NULL so we'll construct frames by display there
3676 };
3680 }
3682 nsresult
3687 {
3696 // Some sets of bits are not compatible with each other
3697 #define CHECK_ONLY_ONE_BIT(_bit1, _bit2) \
3698 NS_ASSERTION(!(bits & _bit1) || !(bits & _bit2), \
3701 #ifdef MOZ_MATHML
3703 #endif
3709 FCDATA_DISALLOW_GENERATED_CONTENT);
3712 #undef CHECK_ONLY_ONE_BIT
3720 nsresult rv =
3725 }
3731 newFrame =
3735 }
3752 // Must init frameToAddToList to null, since it's inout
3760 newFrame);
3762 // See whether we need to create a view
3766 }
3768 // Use frameToAddToList as the primary frame. In the non-scrollframe case
3769 // they're equal, but in the scrollframe case newFrame is the scrolled
3770 // frame, while frameToAddToList is the scrollframe (and should be the
3771 // primary frame).
3778 }
3780 #ifdef MOZ_XUL
3781 // Icky XUL stuff, sadly
3786 newFrame,
3790 }
3793 // Process the child content if requested
3794 nsFrameItems childItems;
3795 nsFrameConstructorSaveState absoluteSaveState;
3801 }
3805 childItems);
3807 // Process the child frames.
3810 childItems,
3813 }
3815 #ifdef MOZ_XUL
3816 // More icky XUL stuff
3824 }
3825 }
3826 #endif
3828 #ifdef MOZ_MATHML
3830 nsFrameItems newItems;
3831 nsFrameItems currentBlock;
3839 }
3846 }
3847 }
3851 // an error must have occurred, delete unprocessed frames
3853 }
3856 }
3857 #endif
3859 // Set the frame's initial child list
3860 // Note that MathML depends on this being called even if
3861 // childItems is empty!
3863 }
3871 }
3874 }
3876 // after the node has been constructed and initialized create any
3877 // anonymous content a node needs.
3878 nsresult
3884 {
3892 }
3895 aPendingBinding);
3910 }
3912 // create the frame and attach it to our frame
3914 }
3915 }
3918 }
3920 nsresult
3924 {
3934 // get our child's content and set its parent to our content
3938 #ifdef MOZ_SVG
3939 // least-surprise CSS binding until we do the SVG specified
3940 // cascading rules for <svg:use> - bug 265894
3945 #endif
3946 {
3948 }
3954 }
3955 }
3958 }
3960 static
3962 {
3964 #ifdef MOZ_XUL
3967 #endif
3969 #ifdef MOZ_XUL
3977 #endif
3978 );
3979 }
3982 // XUL frames are not allowed to be out of flow.
3983 #define SIMPLE_XUL_FCDATA(_func) \
3984 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH, \
3985 _func)
3986 #define SCROLLABLE_XUL_FCDATA(_func) \
3987 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH | \
3988 FCDATA_MAY_NEED_SCROLLFRAME, _func)
3989 #define SIMPLE_XUL_CREATE(_tag, _func) \
3990 { &nsGkAtoms::_tag, SIMPLE_XUL_FCDATA(_func) }
3991 #define SCROLLABLE_XUL_CREATE(_tag, _func) \
3992 { &nsGkAtoms::_tag, SCROLLABLE_XUL_FCDATA(_func) }
3993 #define SIMPLE_XUL_INT_CREATE(_int, _func) \
3994 { _int, SIMPLE_XUL_FCDATA(_func) }
3995 #define SCROLLABLE_XUL_INT_CREATE(_int, _func) \
3996 { _int, SCROLLABLE_XUL_FCDATA(_func) }
3998 static
4001 {
4006 }
4009 }
4011 /* static */
4015 PRInt32 aNameSpaceID,
4017 {
4020 }
4023 #ifdef MOZ_XUL
4041 #ifdef XP_MACOSX
4043 #else
4059 };
4063 }
4065 #ifdef MOZ_XUL
4066 /* static */
4070 {
4073 }
4078 }
4080 /* static */
4084 /* static */
4088 {
4091 }
4096 }
4100 {
4101 // XXXbz do we really need to set those flags? If the parent is not
4102 // a block we'll get them anyway, and if it is, do we want them?
4105 }
4107 /* static */
4111 {
4114 }
4119 }
4121 #ifdef XP_MACOSX
4122 /* static */
4126 {
4132 PRInt32 type;
4138 // This is the root. Suppress the menubar, since on Mac
4139 // window menus are not attached to the window.
4142 }
4143 }
4144 }
4145 }
4150 }
4153 /* static */
4157 {
4159 NS_STYLE_DISPLAY_GRID_GROUP) {
4161 }
4166 }
4168 /* static */
4172 {
4174 NS_STYLE_DISPLAY_GRID_LINE) {
4176 }
4181 }
4185 /* static */
4190 {
4194 #ifdef MOZ_XUL
4198 NS_NewGridRowGroupFrame),
4200 NS_NewGridRowLeafFrame),
4209 };
4211 // Processing by display here:
4214 }
4222 PRBool aIsRoot,
4224 {
4227 nsFrameItems anonymousItems;
4232 // Build a XULScrollFrame when the child is a box, otherwise an
4233 // HTMLScrollFrame
4234 // XXXbz this is the lone remaining consumer of IsXULDisplayType.
4235 // I wonder whether we can eliminate that somehow.
4240 }
4244 // Create a view
4246 }
4248 // if there are any anonymous children for the scroll frame, create
4249 // frames for them.
4250 // Pass a null pending binding: we don't care how constructors for any of
4251 // this anonymous content order with anything else. It's never been
4252 // consistent anyway.
4254 anonymousItems);
4258 // we used the style that was passed in. So resolve another one.
4265 }
4268 }
4270 void
4273 {
4276 }
4279 /**
4280 * Called to wrap a gfx scrollframe around a frame. The hierarchy will look like this
4281 *
4282 * ------- for gfx scrollbars ------
4283 *
4284 *
4285 * ScrollFrame
4286 * ^
4287 * |
4288 * Frame (scrolled frame you passed in)
4289 *
4290 *
4291 *-----------------------------------
4292 * LEGEND:
4293 *
4294 * ScrollFrame: This is a frame that manages gfx cross platform frame based scrollbars.
4295 *
4296 * @param aContent the content node of the child to wrap.
4297 * @param aScrolledFrame The frame of the content to wrap. This should not be
4298 * Initialized. This method will initialize it with a scrolled pseudo
4299 * and no nsIContent. The content will be attached to the scrollframe
4300 * returned.
4301 * @param aContentStyle the style context that has already been resolved for the content being passed in.
4302 *
4303 * @param aParentFrame The parent to attach the scroll frame to
4304 *
4305 * @param aNewFrame The new scrollframe or gfx scrollframe that we create. It will contain the
4306 * scrolled frame you passed in. (returned)
4307 * If this is not null, we'll just use it
4308 * @param aScrolledContentStyle the style that was resolved for the scrolled frame. (returned)
4309 */
4310 nsresult
4317 {
4328 }
4334 {
4337 // The style system ensures that floated and positioned frames are
4338 // block-level.
4344 // If this is "body", try propagating its scroll style to the viewport
4345 // Note that we need to do this even if the body is NOT scrollable;
4346 // it might have dynamically changed from scrollable to not scrollable,
4347 // and that might need to be propagated.
4348 // XXXbz is this the right place to do this? If this code moves,
4349 // make this function static.
4353 propagatedScrollToViewport =
4355 }
4357 // If the frame is a block-level frame and is scrollable, then wrap it
4358 // in a scroll frame.
4359 // XXX Ignore tables for the time being
4360 // XXXbz it would be nice to combine this with the other block
4361 // case... Think about how do do this?
4368 }
4370 // Handle various non-scrollable blocks
4377 }
4380 // To keep the hash table small don't add inline frames (they're
4381 // typically things like FONT and B), because we can quickly
4382 // find them if we need to.
4383 // XXXbz the "quickly" part is a bald-faced lie!
4398 NS_NewTableCaptionFrame) },
4401 FCDATA_SKIP_ABSPOS_PUSH |
4403 NS_NewTableRowGroupFrame) },
4406 FCDATA_SKIP_ABSPOS_PUSH |
4408 NS_NewTableRowGroupFrame) },
4411 FCDATA_SKIP_ABSPOS_PUSH |
4413 NS_NewTableRowGroupFrame) },
4416 FCDATA_SKIP_ABSPOS_PUSH |
4418 NS_NewTableColGroupFrame) },
4431 };
4435 }
4437 nsresult
4444 {
4455 // Create our block frame
4456 // pass a temporary stylecontext, the correct one will be set later
4460 nsFrameItems blockItem;
4467 // XXXbz any cleanup needed here?
4469 }
4476 aParentFrame);
4478 }
4480 nsresult
4487 {
4496 }
4503 }
4506 nsresult
4512 PRBool aAllowCounters)
4513 {
4523 // Initialize the frame
4528 // Restore frame state for just the newly created frame.
4530 }
4535 }
4538 }
4543 {
4550 // Resolve the style context based on the content object and the parent
4551 // style context
4554 // Perhaps aParentFrame is a canvasFrame and we're replicating
4555 // fixed-pos frames.
4556 // XXX should we create a way to tell ConstructFrame which style
4557 // context to use, and pass it the style context for the
4558 // previous page's fixed-pos frame?
4559 }
4562 }
4567 {
4572 }
4575 "shouldn't waste time creating style contexts for "
4579 }
4581 // MathML Mod - RBS
4582 #ifdef MOZ_MATHML
4583 nsresult
4589 {
4591 // Nothing to do
4593 }
4602 parentContext);
4604 // then, create a block frame that will wrap the child frames. Make it a
4605 // MathML frame so that Get(Absolute/Float)ContainingBlockFor know that this
4606 // is not a suitable block.
4614 // abs-pos and floats are disabled in MathML children so we don't have to
4615 // worry about messing up those.
4621 }
4623 // Only <math> elements can be floated or positioned. All other MathML
4624 // should be in-flow.
4625 #define SIMPLE_MATHML_CREATE(_tag, _func) \
4626 { &nsGkAtoms::_tag, \
4627 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \
4628 FCDATA_FORCE_NULL_ABSPOS_CONTAINER | \
4629 FCDATA_WRAP_KIDS_IN_BLOCKS, _func) }
4631 /* static */
4635 PRInt32 aNameSpaceID,
4637 {
4638 // Make sure that we remain confined in the MathML world
4642 // Handle <math> specially, because it sometimes produces inlines
4644 // This needs to match the test in EnsureBlockDisplay in
4645 // nsRuleNode.cpp. Though the behavior here for the display:table
4646 // case is pretty weird...
4650 FCDATA_WRAP_KIDS_IN_BLOCKS,
4651 NS_CreateNewMathMLmathBlockFrame);
4653 }
4657 FCDATA_IS_LINE_PARTICIPANT |
4658 FCDATA_WRAP_KIDS_IN_BLOCKS,
4659 NS_NewMathMLmathInlineFrame);
4661 }
4692 };
4696 }
4699 #ifdef MOZ_SVG
4700 // Only outer <svg> elements can be floated or positioned. All other SVG
4701 // should be in-flow.
4702 #define SIMPLE_SVG_FCDATA(_func) \
4703 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \
4704 FCDATA_SKIP_ABSPOS_PUSH | \
4705 FCDATA_DISALLOW_GENERATED_CONTENT, _func)
4706 #define SIMPLE_SVG_CREATE(_tag, _func) \
4707 { &nsGkAtoms::_tag, SIMPLE_SVG_FCDATA(_func) }
4709 /* static */
4713 PRInt32 aNameSpaceID,
4716 {
4719 }
4728 // XXXbz should this really be based on the XBL-resolved tag of the parent
4729 // frame's content? Should it not be based on the type of the parent frame
4730 // (e.g. whether it's an SVG frame)?
4732 PRInt32 parentNSID;
4737 // It's not clear whether the SVG spec intends to allow any SVG
4738 // content within svg:foreignObject at all (SVG 1.1, section
4739 // 23.2), but if it does, it better be svg:svg. So given that
4740 // we're allowing it, treat it as a non-SVG parent.
4743 }
4747 // Sections 5.1 and G.4 of SVG 1.1 say that SVG elements other than
4748 // svg:svg not contained within svg:svg are incorrect, although they
4749 // don't seem to specify error handling. Ignore them, since many of
4750 // our frame classes can't deal. It *may* be that the document
4751 // should at that point be considered in error according to F.2, but
4752 // it's hard to tell.
4753 //
4754 // Style mutation can't change this situation, so don't bother
4755 // adding to the undisplayed content map.
4756 //
4757 // We don't currently handle any UI for desc/title
4759 }
4761 // We don't need frames for animation elements
4764 }
4766 // Reduce the number of frames we create unnecessarily. Note that this is not
4767 // where we select which frame in a <switch> to render! That happens in
4768 // nsSVGSwitchFrame::PaintSVG.
4770 // Note that just returning is probably not right. According
4771 // to the spec, <use> is allowed to use an element that fails its
4772 // conditional, but because we never actually create the frame when
4773 // a conditional fails and when we use GetReferencedFrame to find the
4774 // references, things don't work right.
4775 // XXX FIXME XXX
4777 }
4779 // Special case for aTag == nsGkAtoms::svg because we don't want to
4780 // have to recompute parentIsSVG for it.
4786 }
4790 FCDATA_DISALLOW_GENERATED_CONTENT,
4791 NS_NewSVGOuterSVGFrame);
4793 }
4795 // Special cases for text/tspan/textpath, because the kind of frame
4796 // they get depends on the parent frame.
4803 // Text cannot be nested
4806 }
4807 }
4808 }
4817 }
4818 }
4819 }
4827 }
4828 }
4879 };
4887 }
4890 }
4892 nsresult
4899 {
4906 }
4908 // We don't allow this frame to be out of flow
4916 }
4923 NS_BLOCK_FLOAT_MGR |
4924 NS_BLOCK_MARGIN_ROOT);
4928 }
4930 nsFrameItems childItems;
4931 // Claim to be relatively positioned so that we end up being the
4932 // absolute containing block.
4938 // Give the blockFrame a view so that GetOffsetTo works for descendants
4939 // of blockFrame with views...
4947 }
4951 void
4955 {
4957 // Use the same parent style context that |aMainStyleContext| has, since
4958 // that's easier to re-resolve and it doesn't matter in practice.
4959 // (Getting different parents can result in framechange hints, e.g.,
4960 // for user-modify.)
4961 pseudoStyle =
4972 // Lie about the tag and namespace so we don't trigger anything
4973 // interesting during frame construction.
4976 }
4978 nsresult
4984 {
4986 FrameConstructionItemList items;
4992 nsresult rv =
4995 }
4998 }
5000 void
5003 PRBool aSuppressWhiteSpaceOptimizations,
5006 {
5009 // We can't just remove our pending restyle flags, since we may
5010 // have restyle-later-siblings set on us. But we _can_ remove the
5011 // "is possible restyle root" flags, and need to. Otherwise we can
5012 // end up with stale such flags (e.g. if we used to have a
5013 // display:none parent when our last restyle was posted and
5014 // processed and now no longer do).
5017 }
5019 // don't create a whitespace frame if aParent doesn't want it
5022 }
5024 // never create frames for comments or PIs
5034 aSuppressWhiteSpaceOptimizations,
5035 styleContext,
5037 aItems);
5038 }
5040 /**
5041 * Set aContent as undisplayed content with style context aStyleContext. This
5042 * method enforces the invariant that all style contexts in the undisplayed
5043 * content map must be non-pseudo contexts and also handles unbinding
5044 * undisplayed generated content as needed.
5045 */
5046 static void
5049 PRBool aIsGeneratedContent)
5050 {
5054 }
5056 }
5060 }
5062 void
5067 PRInt32 aNameSpaceID,
5068 PRBool aSuppressWhiteSpaceOptimizations,
5070 PRUint32 aFlags,
5072 {
5073 // The following code allows the user to specify the base tag
5074 // of an element using XBL. XUL and HTML objects (like boxes, menus, etc.)
5075 // can then be extended arbitrarily.
5080 {
5081 // Ensure that our XBL bindings are installed.
5087 PRBool resolveStyle;
5092 }
5095 PR_FALSE,
5103 // aState takes over owning newPendingBinding
5105 }
5111 }
5114 }
5118 // Pre-check for display "none" - if we find that, don't create
5119 // any frame at all
5122 isGeneratedContent);
5124 }
5128 // Try to find frame construction data for this content
5132 #ifdef MOZ_SVG
5134 // Nothing to do here; suppressed text inside SVG
5136 }
5139 #ifdef MOZ_SVG
5140 // Don't create frames for non-SVG element children of SVG elements.
5142 aParentFrame &&
5145 ) {
5147 isGeneratedContent);
5149 }
5153 styleContext);
5156 }
5157 #ifdef MOZ_MATHML
5160 }
5161 #endif
5162 #ifdef MOZ_SVG
5165 styleContext);
5166 }
5169 // Now check for XUL display types
5172 }
5174 // And general display types
5177 }
5183 isGeneratedContent);
5185 }
5187 #ifdef MOZ_XUL
5194 isGeneratedContent);
5196 }
5199 }
5201 }
5205 // Inside colgroups, suppress everything except columns.
5211 isGeneratedContent);
5213 }
5215 PRBool canHavePageBreak =
5223 }
5228 aSuppressWhiteSpaceOptimizations);
5232 }
5234 }
5240 }
5246 }
5251 }
5254 // To correctly set item->mIsAllInline we need to build up our child items
5255 // right now.
5260 // Compute a boolean isInline which is guaranteed to be false for blocks
5261 // (but may also be false for some inlines).
5262 PRBool isInline =
5263 // Table-internal things are inline-outside if and only if they're kids of
5264 // inlines, since they'll trigger construction of inline-table
5265 // pseudos.
5269 // Things that are inline-outside but aren't inline frames are inline
5271 // Popups that are certainly out of flow.
5272 isPopup;
5274 // Set mIsAllInline conservatively. It just might be that even an inline
5275 // that has mIsAllInline false doesn't need an {ib} split. So this is just
5276 // an optimization to keep from doing too much work in cases when we can
5277 // show that mIsAllInline is true..
5279 // Figure out whether we're guaranteed this item will be out of flow.
5280 // This is not a precise test, since one of our ancestor inlines might add
5281 // an absolute containing block (if it's relatively positioned) when there
5282 // wasn't such a containing block before. But it's conservative in the
5283 // sense that anything that will really end up as an in-flow non-inline
5284 // will test false here. In other words, if this test is true we're
5285 // guaranteed to be inline; if it's false we don't know what we'll end up
5286 // as.
5287 //
5288 // If we make this test precise, we can remove some of the code dealing
5289 // with the imprecision in ConstructInline and adjust the comments on
5290 // mIsAllInline and mIsBlock in the header. And probably remove mIsBlock
5291 // altogether, since then it will always be equal to !mHasInlineEnds.
5295 // Set mIsBlock conservatively. It's OK to set it false for some real
5296 // blocks, but not OK to set it true for things that aren't blocks. Since
5297 // isOutOfFlow might be false even in cases when the frame will end up
5298 // out-of-flow, we can't use it here. But we _can_ say that the frame will
5299 // for sure end up in-flow if it's not floated or absolutely positioned.
5302 }
5308 }
5310 // Our item should be treated as a line participant if we have the relevant
5311 // bit and are going to be in-flow. Note that this really only matters if
5312 // our ancestor is a box or some such, so the fact that we might have an
5313 // inline ancestor that might become a containing block is not relevant here.
5319 }
5320 }
5322 static void
5324 {
5328 }
5335 {
5341 }
5343 /**
5344 * Return true if the frame construction item pointed to by aIter will
5345 * create a frame adjacent to a line boundary in the frame tree, and that
5346 * line boundary is induced by a content node adjacent to the frame's
5347 * content node in the content tree. The latter condition is necessary so
5348 * that ContentAppended/ContentInserted/ContentRemoved can easily find any
5349 * text nodes that were suppressed here.
5350 */
5351 PRBool
5353 {
5356 }
5369 }
5382 }
5385 }
5387 nsresult
5392 {
5399 // If this is collapsible whitespace next to a line boundary,
5400 // don't create a frame. item.IsWhitespace() also sets the
5401 // NS_CREATE_FRAME_IF_NON_WHITESPACE flag in the text node. (If we
5402 // end up creating a frame, nsTextFrame::Init will clear the flag.)
5403 // We don't do this for generated content, because some generated
5404 // text content is empty text nodes that are about to be initialized.
5405 // (We check mAdditionalStateBits because only the generated content
5406 // container's frame construction item is marked with
5407 // mIsGeneratedContent, and we might not have an aParentFrame.)
5408 // We don't do it for content that may have XBL anonymous siblings,
5409 // because they make it difficult to correctly create the frame
5410 // due to dynamic changes.
5411 // We don't do it for text that's not a line participant (i.e. SVG text).
5422 aFrameItems);
5423 }
5425 // Start background loads during frame construction. This is just
5426 // a hint; the paint code will do the right thing in any case.
5427 {
5429 }
5433 // Ensure that frames created here are all tagged with
5434 // NS_FRAME_GENERATED_CONTENT.
5437 // Note that we're not necessarily setting this property on the primary
5438 // frame for the content for which this is generated content. We might be
5439 // setting it on a table pseudo-frame inserted under that instead. That's
5440 // OK, though; we just need to do the property set so that the content will
5441 // get cleaned up when the frame is destroyed.
5445 // Now that we've passed ownership of item.mContent to the frame, unset
5446 // our generated content flag so we don't release or unbind it ourselves.
5448 }
5450 // XXXbz maybe just inline ConstructFrameFromItemInternal here or something?
5452 aFrameItems);
5457 }
5460 inline PRBool
5462 {
5464 }
5466 nsresult
5468 {
5470 PR_FALSE);
5471 }
5473 nsIFrame*
5475 {
5476 // Get the primary frame associated with the content
5482 // If the content of the frame is not the desired content then this is not
5483 // really a frame for the desired content.
5484 // XXX This check is needed due to bug 135040. Remove it once that's fixed.
5487 }
5495 }
5497 nsIFrame*
5499 {
5502 // Starting with aFrame, look for a frame that is absolutely positioned or
5503 // relatively positioned
5508 // If it's mathml, bail out -- no absolute positioning out from inside
5509 // mathml frames. Note that we don't make this part of the loop
5510 // condition because of the stuff at the end of this method...
5512 }
5514 // Is it positioned?
5515 // If it's table-related then ignore it, because for the time
5516 // being table-related frames are not containers for absolutely
5517 // positioned child frames.
5521 // Find the outermost wrapped block under this frame
5526 #ifdef MOZ_XUL
5528 #endif
5532 // If the positioned frame is a fieldset, use the area frame inside it.
5533 // We don't use GetContentInsertionFrame for fieldsets yet.
5535 }
5536 }
5538 #ifdef DEBUG
5540 NS_WARNING("Positioned frame that does not handle positioned kids; looking further up the parent chain");
5541 #endif
5542 }
5543 }
5545 // If we found an absolutely positioned containing block, then use the
5546 // first-continuation.
5550 // If we didn't find it, then use the document element containing block
5552 }
5554 nsIFrame*
5556 {
5557 // Starting with aFrame, look for a frame that is a float containing block.
5558 // IF we hit a mathml frame, bail out; we don't allow floating out of mathml
5559 // frames, because they don't seem to be able to deal.
5560 // The logic here needs to match the logic in ProcessChildren()
5567 }
5568 }
5570 // If we didn't find a containing block, then there just isn't
5571 // one.... return null
5573 }
5575 /**
5576 * This function will check whether aContainer has :after generated content.
5577 * If so, appending to it should actually insert. The return value is the
5578 * parent to use for newly-appended content. *aAfterFrame points to the :after
5579 * frame before which appended content should go, if there is one.
5580 */
5586 {
5587 // See if the parent has an :after pseudo-element. Check for the presence
5588 // of style first, since nsLayoutUtils::GetAfterFrame is sorta expensive.
5592 aPresContext)) {
5597 }
5598 }
5603 // We might be in a situation where the last part of the {ib} split was
5604 // empty. Since we have no ::after pseudo-element, we do in fact want to be
5605 // appending to that last part, so advance to it if needed. Note that here
5606 // aParentFrame is the result of a GetLastSpecialSibling call, so must be
5607 // either the last or next to last special sibling.
5611 }
5613 // Always make sure to look at the last continuation of the frame
5614 // for the {ib} case, even if that continuation is empty. We
5615 // don't do this for the non-special-frame case, since in the
5616 // other cases appending to the last nonempty continuation is fine
5617 // and in fact not doing that can confuse code that doesn't know
5618 // to pull kids from continuations other than its next one.
5620 }
5623 }
5625 /**
5626 * This function will get the previous sibling to use for an append operation.
5627 * it takes a parent frame (must not be null) and its :after frame (may be
5628 * null).
5629 */
5632 {
5636 }
5639 }
5641 /**
5642 * This function will get the next sibling for a frame insert operation given
5643 * the parent and previous sibling. aPrevSibling may be null.
5644 */
5647 {
5650 }
5653 }
5655 /**
5656 * This function is called by ContentAppended() and ContentInserted() when
5657 * appending flowed frames to a parent's principal child list. It handles the
5658 * case where the parent is the trailing inline of an {ib} split.
5659 */
5660 nsresult
5665 PRBool aIsRecursiveCall)
5666 {
5679 aIsRecursiveCall,
5686 aIsRecursiveCall,
5689 // If we're inserting a list of frames at the end of the trailing inline
5690 // of an {ib} split, we may need to create additional {ib} siblings to parent
5691 // them.
5693 // When we get here, our frame list might start with a block. If it does
5694 // so, and aParentFrame is an inline, and it and all its previous
5695 // continuations have no siblings, then put the initial blocks from the
5696 // frame list into the previous block of the {ib} split. Note that we
5697 // didn't want to stop at the block part of the split when figuring out
5698 // initial parent, because that could screw up float parenting; it's easier
5699 // to do this little fixup here instead.
5701 // See whether our trailing inline is empty
5704 // Our trailing inline is empty. Collect our starting blocks from
5705 // aFrameList, get the right parent frame for them, and put them in.
5716 }
5717 }
5719 // We want to put some of the frames into this inline frame.
5726 }
5730 PRBool positioned =
5733 nsFrameItems ibSiblings;
5735 ibSiblings);
5737 // Make sure to trigger reflow of the inline that used to be our
5738 // last one and now isn't anymore, since its GetSkipSides() has
5739 // changed.
5742 NS_FRAME_HAS_DIRTY_CHILDREN);
5744 // Recurse so we create new ib siblings as needed for aParentFrame's parent
5747 }
5750 }
5752 // Insert the frames after our aPrevSibling
5754 aFrameList);
5755 }
5757 #define UNSET_DISPLAY 255
5759 // This gets called to see if the frames corresponding to aSibling and aContent
5760 // should be siblings in the frame tree. Although (1) rows and cols, (2) row
5761 // groups and col groups, (3) row groups and captions, (4) legends and content
5762 // inside fieldsets, (5) popups and other kids of the menu are siblings from a
5763 // content perspective, they are not considered siblings in the frame tree.
5764 PRBool
5768 {
5777 }
5778 }
5788 // if we haven't already, construct a style context to find the display type of aContent
5792 PRBool providerIsChild;
5800 }
5805 }
5807 return
5810 }
5811 // To have decent performance we want to return false in cases in which
5812 // reordering the two siblings has no effect on display. To ensure
5813 // correctness, we MUST return false in cases where the two siblings have
5814 // the same desired parent type and live on different display lists.
5815 // Specificaly, columns and column groups should only consider columns and
5816 // column groups as valid siblings. Captions should only consider other
5817 // captions. All other things should consider each other as valid
5818 // siblings. The restriction in the |if| above on siblingDisplay is ok,
5819 // because for correctness the only part that really needs to happen is to
5820 // not consider captions, column groups, and row/header/footer groups
5821 // siblings of each other. Treating a column or colgroup as a valid
5822 // sibling of a non-table-related frame will just mean we end up reframing.
5825 // One's a caption and the other is not. Not valid siblings.
5827 }
5833 // One's a column or column group and the other is not. Not valid
5834 // siblings.
5836 }
5839 }
5843 // Legends can be sibling of legends but not of other content in the fieldset
5850 }
5853 }
5855 nsIFrame*
5859 PRBool aPrevSibling)
5860 {
5863 // XXX the GetContent() != aContent check is needed due to bug 135040.
5864 // Remove it once that's fixed.
5866 }
5868 // If the frame is out-of-flow, GetPrimaryFrame() will have returned the
5869 // out-of-flow frame; we want the placeholder.
5874 }
5876 // The frame we have now should never be a continuation
5880 // The frame may be a special frame (a split inline frame that
5881 // contains a block). Get the last part of that split.
5884 }
5886 // The frame may have a continuation. If so, we want the last
5887 // non-overflow-container continuation as our previous sibling.
5889 }
5894 }
5897 }
5899 nsIFrame*
5901 ChildIterator aIter,
5903 {
5906 // Note: not all content objects are associated with a frame (e.g., if it's
5907 // `display: none') so keep looking until we find a previous frame
5914 // Found a previous sibling, we're done!
5916 }
5917 }
5920 }
5922 nsIFrame*
5926 {
5928 // XXXbz Can happen when XBL lies to us about insertion points. This check
5929 // might be able to go away once bug 474324 is fixed.
5931 }
5940 // We found a next sibling, we're done!
5942 }
5943 }
5946 }
5948 // For fieldsets, returns the area frame, if the child is not a legend.
5953 {
5960 // If the parent is a fieldSet, use the fieldSet's area frame as the
5961 // parent unless the new content is a legend.
5965 }
5966 }
5968 }
5970 nsIFrame*
5978 {
5981 // Find the frame that precedes the insertion point. Walk backwards
5982 // from the parent frame to get the parent content, because if an
5983 // XBL insertion point is involved, we'll need to use _that_ to find
5984 // the preceding frame.
5994 // The check for IsRootOfAnonymousSubtree() is because editor is
5995 // severely broken and calls us directly for native anonymous
5996 // nodes that it creates.
6001 }
6002 }
6003 #ifdef DEBUG
6007 }
6008 #endif
6013 // Now, find the geometric parent so that we can handle
6014 // continuations properly. Use the prev sibling if we have it;
6015 // otherwise use the next sibling.
6018 }
6020 // If there is no previous sibling, then find the frame that follows
6023 iter--;
6024 }
6029 }
6031 // No previous or next sibling, so treat this like an appended frame.
6034 // Since we're appending, we'll walk to the last anonymous frame
6035 // that was created for the broken inline frame. But don't walk
6036 // to the trailing inline if it's empty; stop at the block.
6038 }
6039 // Get continuation that parents the last child. This MUST be done
6040 // before the AdjustAppendParentForAfterContent call.
6042 // Deal with fieldsets
6045 aChild);
6047 aParentFrame =
6052 }
6053 }
6057 }
6059 static PRBool
6061 {
6062 // IMPORTANT: This must match the conditions in nsHTMLFramesetFrame::Init.
6066 }
6068 static void
6071 #ifdef MOZ_XUL
6073 static
6074 PRBool
6076 {
6078 }
6080 static
6081 nsListBoxBodyFrame*
6083 {
6095 }
6096 }
6099 }
6100 #endif
6102 void
6107 {
6111 // Not text, or not suppressed due to being all-whitespace (if it
6112 // were being suppressed, it would have the
6113 // NS_CREATE_FRAME_IF_NON_WHITESPACE flag)
6115 }
6120 }
6122 void
6125 {
6128 // Not text, or not suppressed due to being all-whitespace (if it
6129 // were being suppressed, it would have the
6130 // NS_CREATE_FRAME_IF_NON_WHITESPACE flag)
6132 }
6136 }
6138 // We want to disable lazy frame construction for nodes that are under an
6139 // editor. We use nsINode::IsEditable, but that includes inputs with type text
6140 // and password and textareas, which are common and aren't really editable (the
6141 // native anonymous content under them is what is actually editable) so we want
6142 // to construct frames for those lazily.
6143 // The logic for this check is based on
6144 // nsGenericHTMLFormElement::UpdateEditableFormControlState and so must be kept
6145 // in sync with that. The presence of the NODE_MAY_HAVE_CONTENT_EDITABLE_ATTR
6146 // flag only indicates a contenteditable attribute, it doesn't indicate if it
6147 // is true or false, so we force eager construction in some cases when the node
6148 // is not editable, but that should be rare.
6151 {
6155 }
6157 // For inserts aChild should be valid, for appends it should be null.
6158 // Returns true if this operation can be lazy, false if not.
6159 PRBool
6163 {
6167 }
6173 }
6182 }
6183 }
6184 }
6186 // We can construct lazily; just need to set suitable bits in the content
6187 // tree.
6189 // Walk up the tree setting the NODE_DESCENDANTS_NEED_FRAMES bit as we go.
6191 #ifdef DEBUG
6192 // If we hit a node with no primary frame, or the NODE_NEEDS_FRAME bit set
6193 // we want to assert, but leaf frames that process their own children and may
6194 // ignore anonymous children (eg framesets) make this complicated. So we set
6195 // these two booleans if we encounter these situations and unset them if we
6196 // hit a node with a leaf frame.
6199 #endif
6202 #ifdef DEBUG
6205 }
6208 }
6211 }
6212 #endif
6215 }
6216 #ifdef DEBUG
6220 }
6225 #endif
6227 // Set NODE_NEEDS_FRAME on the new nodes.
6231 //XXX the aChild->GetPrimaryFrame()->GetContent() != aChild
6232 // check is needed due to bug 135040. Remove it once that's
6233 // fixed.
6240 //XXX the child->GetPrimaryFrame()->GetContent() != child
6241 // check is needed due to bug 135040. Remove it once that's
6242 // fixed.
6245 }
6246 }
6250 }
6252 void
6254 {
6262 // We could either descend first (on nodes that don't have NODE_NEEDS_FRAME
6263 // set) or issue content notifications for our kids first. In absence of
6264 // anything definitive either way we'll go with the latter.
6266 // It might be better to use GetChildArray and scan it completely first and
6267 // then issue all notifications. (We have to scan it completely first because
6268 // constructing frames can set attributes, which can change the storage of
6269 // child lists).
6271 // Scan the children of aContent to see what operations (if any) we need to
6272 // perform.
6281 //XXX the child->GetPrimaryFrame()->GetContent() != child
6282 // check is needed due to bug 135040. Remove it once that's
6283 // fixed.
6288 }
6292 // generate a ContentRangeInserted for [startOfRun,i)
6294 PR_FALSE);
6295 }
6296 }
6297 }
6300 }
6302 // Now descend.
6310 }
6311 }
6312 }
6315 {
6326 }
6327 }
6329 void
6333 PRBool aAllowLazyConstruction)
6334 {
6340 #ifdef MOZ_XUL
6341 // Except listboxes suck, so do NOT skip anything here if
6342 // we plan to notify a listbox.
6344 #endif
6345 ) {
6346 // Already have a frame or undisplayed entry for this content; a
6347 // previous ContentInserted in this loop must have reconstructed
6348 // its insertion parent. Skip it.
6350 }
6351 // Call ContentInserted with this node.
6353 aAllowLazyConstruction);
6354 }
6355 }
6357 nsIFrame*
6362 PRBool aAllowLazyConstruction)
6363 {
6364 // See if we have an XBL insertion point. If so, then that's our
6365 // real parent frame; if not, then the frame hasn't been built yet
6366 // and we just bail.
6375 // XXXbz XBL2/sXBL issue
6377 // XXXbz how would |document| be null here?
6381 }
6382 }
6385 // We have an insertion point. There are some additional tests we need to do
6386 // in order to ensure that an append is a safe operation.
6390 // We may need to make multiple ContentInserted calls instead. A
6391 // reasonable heuristic to employ (in order to maintain good performance)
6392 // is to find out if the insertion point's content node contains any
6393 // explicit children. If it does not, then it is highly likely that
6394 // an append is occurring. (Note it is not definite, and there are insane
6395 // cases we will not deal with by employing this heuristic, but it beats
6396 // always falling back to multiple ContentInserted calls).
6397 //
6398 // In the multiple insertion point case, we know we're going to need to do
6399 // multiple ContentInserted calls anyway.
6401 }
6403 // If we have multiple insertion points or if we have an insertion point
6404 // and the operation is not a true append or if the insertion point already
6405 // has explicit children, then we must fall back.
6407 // Now comes the fun part. For each inserted child, make a
6408 // ContentInserted call as if it had just gotten inserted and
6409 // let ContentInserted handle the mess.
6411 aAllowLazyConstruction);
6413 }
6414 }
6417 }
6419 PRBool
6423 {
6425 // Check whether we have any kids we care about.
6430 // Just reframe the parent, since framesets are weird like that.
6433 }
6434 }
6435 }
6437 }
6439 nsresult
6442 PRBool aAllowLazyConstruction)
6443 {
6448 #ifdef DEBUG
6453 aAllowLazyConstruction);
6456 }
6457 }
6458 #endif
6460 #ifdef MOZ_XUL
6462 PRInt32 namespaceID;
6466 // Just ignore tree tags, anyway we don't create any frames for them.
6472 }
6475 // Get the frame associated with the content
6483 }
6488 aAllowLazyConstruction);
6492 }
6498 }
6502 // Nothing to do here; we shouldn't be constructing kids of leaves
6503 // Clear lazy bits so we don't try to construct again.
6506 }
6508 #ifdef MOZ_MATHML
6514 }
6515 #endif
6517 // If the frame we are manipulating is a ``special'' frame (that is, one
6518 // that's been created as a result of a block-in-inline situation) then we
6519 // need to append to the last special sibling, not to the frame itself.
6522 #ifdef DEBUG
6527 }
6528 #endif
6530 // Since we're appending, we'll walk to the last anonymous frame
6531 // that was created for the broken inline frame. But don't walk
6532 // to the trailing inline if it's empty; stop at the block.
6534 }
6536 // Get continuation that parents the last child. This MUST be done
6537 // before the AdjustAppendParentForAfterContent call.
6540 // We should never get here with fieldsets, since they have multiple
6541 // insertion points.
6545 // Deal with possible :after generated content on the parent
6547 parentFrame =
6552 // Create some new frames
6557 // See if the containing block has :first-letter style applied.
6562 haveFirstLineStyle =
6565 }
6568 // Before we get going, remove the current letter frames
6571 }
6574 PRBool haveNoXBLChildren =
6576 FrameConstructionItemList items;
6579 haveNoXBLChildren) {
6580 // If there's a text node in the normal content list just before the new
6581 // items, and it has no frame, make a frame construction item for it. If it
6582 // doesn't need a frame, ConstructFramesFromItemList below won't give it
6583 // one. No need to do all this if our parent type is not block, though,
6584 // since WipeContainingBlock already handles that situation.
6585 //
6586 // Because we're appending, we don't need to worry about any text
6587 // after the appended content; there can only be XBL anonymous content
6588 // (text in an XBL binding is not suppressed) or generated content
6589 // (and bare text nodes are not generated). Native anonymous content
6590 // generated by frames never participates in inline layout.
6593 }
6595 child;
6598 }
6602 // Perform special check for diddling around with the frames in
6603 // a special inline frame.
6604 // If we're appending before :after content, then we're not really
6605 // appending, so let WipeContainingBlock know that.
6611 }
6614 // If the parent is a block frame, and we're not in a special case
6615 // where frames can be moved around, determine if the list is for the
6616 // start or end of the block.
6622 // :after content can't be <br> so no need to check it
6625 }
6626 // To suppress whitespace-only text frames, we have to verify that
6627 // our container's DOM child list matches its flattened tree child list.
6628 // This is guaranteed to be true if GetXBLChildNodesFor() returns null.
6631 nsFrameItems frameItems;
6635 child;
6637 // Invalidate now instead of before the WipeContainingBlock call, just in
6638 // case we do wipe; in that case we don't need to do this walk at all.
6639 // XXXbz does that matter? Would it make more sense to save some virtual
6640 // GetChildAt calls instead and do this during construction of our
6641 // FrameConstructionItemList?
6643 }
6645 // if the container is a table and a caption was appended, it needs to be put
6646 // in the outer table frame's additional child list.
6647 nsFrameItems captionItems;
6649 // Pull out the captions. Note that we don't want to do that as we go,
6650 // because processing a single caption can add a whole bunch of things to
6651 // the frame items due to pseudoframe processing. So we'd have to pull
6652 // captions from a list anyway; might as well do that here.
6653 // XXXbz this is no longer true; we could pull captions directly out of the
6654 // FrameConstructionItemList now.
6656 }
6659 // It's possible that some of the new frames go into a
6660 // first-line frame. Look at them and see...
6663 }
6665 // Notify the parent frame passing it the list of new frames
6666 // Append the flowed frames to the principal child list; captions
6667 // need special treatment
6673 captionItems);
6674 }
6675 }
6679 }
6681 // Recover first-letter frames
6684 }
6686 #ifdef DEBUG
6690 }
6691 #endif
6694 }
6696 #ifdef MOZ_XUL
6698 enum content_operation
6699 {
6700 CONTENT_INSERTED,
6701 CONTENT_REMOVED
6702 };
6704 // Helper function to lookup the listbox body frame and send a notification
6705 // for insertion or removal of content
6706 static
6710 // Only used for the removed notification
6714 content_operation aOperation)
6715 {
6720 // Except if we have an aChildFrame and its parent is not the right
6721 // thing, then we don't do this. Pseudo frames are so much fun....
6726 }
6730 }
6731 }
6734 }
6737 nsresult
6741 PRBool aAllowLazyConstruction)
6742 {
6744 aChild,
6746 aFrameState,
6747 aAllowLazyConstruction);
6748 }
6750 // ContentRangeInserted handles creating frames for a range of nodes that
6751 // aren't at the end of their childlist. ContentRangeInserted isn't a real
6752 // content notification, but rather it handles regular ContentInserted calls
6753 // for a single node as well as the lazy construction of frames for a range of
6754 // nodes when called from CreateNeededFrames. For a range of nodes to be
6755 // suitable to have its frames constructed all at once they must meet the same
6756 // conditions that ContentAppended imposes (GetRangeInsertionPoint checks
6757 // these), plus more. Namely when finding the insertion prevsibling we must not
6758 // need to consult something specific to any one node in the range, so that the
6759 // insertion prevsibling would be the same for each node in the range. So we
6760 // pass the first node in the range to GetInsertionPrevSibling, and if
6761 // IsValidSibling (the only place GetInsertionPrevSibling might look at the
6762 // passed in node itself) needs to resolve style on the node we record this and
6763 // return that this range needs to be split up and inserted separately. Table
6764 // captions need extra attention as we need to determine where to insert them
6765 // in the caption list, while skipping any nodes in the range being inserted
6766 // (because when we treat the caption frames the other nodes have had their
6767 // frames constructed but not yet inserted into the frame tree).
6768 nsresult
6773 PRBool aAllowLazyConstruction)
6774 {
6781 // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and
6782 // the :empty pseudo-class?
6783 #ifdef DEBUG
6789 aAllowLazyConstruction);
6795 }
6796 }
6797 }
6798 #endif
6808 #ifdef MOZ_XUL
6812 // The insert case in NotifyListBoxBody
6813 // doesn't use "old next sibling".
6817 }
6819 // We don't handle a range insert to a listbox parent, issue single
6820 // ContertInserted calls for each node inserted.
6823 aAllowLazyConstruction);
6826 }
6827 }
6830 // If we have a null parent, then this must be the document element being
6831 // inserted, or some other child of the document in the DOM (might be a PI,
6832 // say).
6839 // Not the root element; just bail out
6841 }
6846 // Create frames for the document element and its child elements
6852 #ifdef DEBUG
6857 }
6858 #endif
6859 }
6862 }
6864 // Otherwise, we've got parent content. Find its frame.
6872 }
6875 // See if we have an XBL insertion point. If so, then that's our
6876 // real parent frame; if not, then the frame hasn't been built yet
6877 // and we just bail.
6885 // Get our insertion point. If we need to issue single ContentInserted's
6886 // GetRangeInsertionPoint will take care of that for us.
6890 aAllowLazyConstruction);
6894 }
6895 }
6902 // check if range insert is safe
6904 // must fall back to a single ContertInserted for each child in the range
6907 aAllowLazyConstruction);
6910 }
6919 }
6922 // We should only get here with fieldsets when doing a single insert, because
6923 // fieldsets have multiple insertion points.
6928 // Just reframe the parent, since figuring out whether this
6929 // should be the new legend and then handling it is too complex.
6930 // We could do a little better here --- check if the fieldset already
6931 // has a legend which occurs earlier in its child list than this node,
6932 // and if so, proceed. But we'd have to extend nsFieldSetFrame
6933 // to locate this legend in the inserted frames and extract it.
6938 }
6940 // Don't construct kids of leaves
6942 // Clear lazy bits so we don't try to construct again.
6945 }
6947 #ifdef MOZ_MATHML
6953 }
6954 #endif
6959 aFrameState);
6962 // Recover state for the containing block - we need to know if
6963 // it has :first-letter or :first-line style applied to it. The
6964 // reason we care is that the internal structure in these cases
6965 // is not the normal structure and requires custom updating
6966 // logic.
6971 // In order to shave off some cycles, we only dig up the
6972 // containing block haveFirst* flags if the parent frame where
6973 // the insertion/append is occurring is an inline or block
6974 // container. For other types of containers this isn't relevant.
6977 // Examine the parentFrame where the insertion is taking
6978 // place. If it's a certain kind of container then some special
6979 // processing is done.
6984 // Recover the special style flags for the containing block
6987 haveFirstLineStyle =
6990 }
6993 // If our current parentFrame is a Letter frame, use its parent as our
6994 // new parent hint
6996 // If parentFrame is out of flow, then we actually want the parent of
6997 // the placeholder frame.
7005 }
7006 }
7008 // Remove the old letter frames before doing the insertion
7013 // Removing the letterframes messes around with the frame tree, removing
7014 // and creating frames. We need to reget our prevsibling, parent frame,
7015 // etc.
7020 // Need check whether a range insert is still safe.
7022 // Need to recover the letter frames first.
7025 // must fall back to a single ContertInserted for each child in the range
7028 aAllowLazyConstruction);
7031 }
7035 }
7036 }
7039 // We're inserting the new frames as the first child. See if the
7040 // parent has a :before pseudo-element
7046 // Insert the new frames after the last continuation of the :before
7049 // Don't change isAppend here; we'll can call AppendFrames as needed, and
7050 // the change to our prevSibling doesn't affect that.
7051 }
7052 }
7054 FrameConstructionItemList items;
7056 PRBool haveNoXBLChildren =
7060 // If there's a text node in the normal content list just before the
7061 // new nodes, and it has no frame, make a frame construction item for
7062 // it, because it might need a frame now. No need to do this if our
7063 // parent type is not block, though, since WipeContainingBlock
7064 // already handles that sitation.
7066 items);
7067 }
7078 }
7079 }
7082 // If there's a text node in the normal content list just after the
7083 // new nodes, and it has no frame, make a frame construction item for
7084 // it, because it might need a frame now. No need to do this if our
7085 // parent type is not block, though, since WipeContainingBlock
7086 // already handles that sitation.
7088 }
7090 // Perform special check for diddling around with the frames in
7091 // a special inline frame.
7092 // If we're appending before :after content, then we're not really
7093 // appending, so let WipeContainingBlock know that.
7099 }
7102 // If the container is a table and a caption will be appended, it needs to be
7103 // put in the outer table frame's additional child list.
7104 // We make no attempt here to set flags to indicate whether the list
7105 // will be at the start or end of a block. It doesn't seem worthwhile.
7114 }
7119 }
7120 }
7122 // If the parent of our current prevSibling is different from the frame we'll
7123 // actually use as the parent, then the calculated insertion point is now
7124 // invalid and as it is unknown where to insert correctly we append instead
7125 // (bug 341858).
7126 // This can affect our prevSibling and isAppend, but should not have any
7127 // effect on the WipeContainingBlock above, since this should only happen
7128 // when neither parent is a special frame and should not affect whitespace
7129 // handling inside table-related frames (and in fact, can only happen when
7130 // one of the parents is an outer table and one is an inner table or when the
7131 // parent is a fieldset or fieldset content frame). So it won't affect the
7132 // {ib} or XUL box cases in WipeContainingBlock(), and the table pseudo
7133 // handling will only be affected by us maybe thinking we're not inserting
7134 // at the beginning, whereas we really are. That would have made us reframe
7135 // unnecessarily, but that's ok.
7136 // XXXbz we should push our frame construction item code up higher, so we
7137 // know what our items are by the time we start figuring out previous
7138 // siblings
7141 #ifdef DEBUG
7154 #endif
7157 parentFrame =
7159 container,
7163 }
7166 // It's possible that the new frame goes into a first-line
7167 // frame. Look at it and see...
7169 // Use append logic when appending
7172 }
7174 // Use more complicated insert logic when inserting
7175 // XXXbz this method is a no-op, so it's easy for the args being passed
7176 // here to make no sense without anyone noticing... If it ever stops
7177 // being a no-op, vet them carefully!
7180 }
7181 }
7183 // We might have captions; put them into the caption list of the
7184 // outer table frame.
7189 // We need to determine where to put the caption items; start with the
7190 // the parent frame that has already been determined and get the insertion
7191 // prevsibling of the first caption item.
7193 PRBool captionIsAppend;
7196 // aIsRangeInsertSafe is ignored on purpose because it is irrelevant here.
7197 PRBool ignored;
7199 captionPrevSibling =
7204 // It is very important here that we skip the children in
7205 // [aStartChild,aEndChild) when looking for a
7206 // prevsibling.
7207 captionPrevSibling =
7211 }
7216 // If the parent is not an outer table frame we will try to add frames
7217 // to a named child list that the parent does not honour and the frames
7218 // will get lost
7220 "Pseudo frame construction failure; "
7223 // If the parent of our current prevSibling is different from the frame
7224 // we'll actually use as the parent, then the calculated insertion
7225 // point is now invalid (bug 341382).
7229 }
7232 captionItems);
7236 }
7237 }
7238 }
7241 // Notify the parent frame
7246 frameItems);
7247 }
7248 }
7251 // Recover the letter frames for the containing block when
7252 // it has first-letter style.
7254 }
7256 #ifdef DEBUG
7260 }
7261 #endif
7264 }
7266 nsresult
7270 RemoveFlags aFlags,
7272 {
7279 // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and
7280 // the :empty pseudo-class?
7282 #ifdef DEBUG
7291 }
7292 }
7293 #endif
7299 // Find the child frame that maps the content
7303 // XXXbz the GetContent() != aChild check is needed due to bug 135040.
7304 // Remove it once that's fixed.
7306 }
7308 #ifdef MOZ_XUL
7315 // If we're removing the root, then make sure to remove things starting at
7316 // the viewport's child instead of the primary frame (which might even be
7317 // null if the root had an XBL binding or display:none, even though the
7318 // frames above it got created). We do the adjustment after the childFrame
7319 // check above, because we do want to clear any undisplayed content we might
7320 // have for the root. Detecting removal of a root is a little exciting; in
7321 // particular, having a null aContainer is necessary but NOT sufficient. Due
7322 // to how we process reframes, the content node might not even be in our
7323 // document by now. So explicitly check whether the viewport's first kid's
7324 // content node is aChild.
7334 }
7335 }
7336 }
7341 // See whether we need to remove more than just childFrame
7347 }
7350 // Get the childFrame's parent frame
7356 // Just reframe the parent, since framesets are weird like that.
7362 }
7364 #ifdef MOZ_MATHML
7365 // If we're a child of MathML, then we should reframe the MathML content.
7366 // If we're non-MathML, then we would be wrapped in a block so we need to
7367 // check our grandparent in that case.
7376 }
7377 #endif
7379 // Undo XUL wrapping if it's no longer needed.
7380 // (If we're in the XUL block-wrapping situation, parentFrame is the
7381 // wrapper frame.)
7385 // check if this frame is the only one needing wrapping
7393 }
7395 // Examine the containing-block for the removed content and see if
7396 // :first-letter style applies.
7401 }
7406 // Trap out to special routine that handles adjusting a blocks
7407 // frame tree when first-letter style is present.
7408 #ifdef NOISY_FIRST_LETTER
7416 #endif
7418 // First update the containing blocks structure by removing the
7419 // existing letter frames. This makes the subsequent logic
7420 // simpler.
7422 containingBlock);
7424 // Recover childFrame and parentFrame
7427 // XXXbz the GetContent() != aChild check is needed due to bug 135040.
7428 // Remove it once that's fixed.
7431 }
7435 #ifdef NOISY_FIRST_LETTER
7441 #endif
7442 }
7444 #ifdef DEBUG
7450 }
7451 #endif
7454 // Notify the parent frame that it should delete the frame
7459 }
7461 childFrame);
7462 //XXXfr NS_ENSURE_SUCCESS(rv, rv) ?
7472 }
7476 }
7478 // If we're just reconstructing frames for the element, then the
7479 // following ContentInserted notification on the element will
7480 // take care of fixing up any adjacent text nodes. We don't need
7481 // to do this if the table parent type of our parent type is not
7482 // eTypeBlock, though, because in that case the whitespace isn't
7483 // being suppressed due to us anyway.
7487 // Adjacent whitespace-only text nodes might have been suppressed if
7488 // this node does not have inline ends. Create frames for them now
7489 // if necessary.
7490 // Reframe any text node just before the node being removed, if there is
7491 // one, and if it's not the last child or the first child. If a whitespace
7492 // textframe was being suppressed and it's now the last child or first
7493 // child then it can stay suppressed since the parent must be a block
7494 // and hence it's adjacent to a block end.
7495 // If aOldNextSibling is null, then the text node before the node being
7496 // removed is the last node, and we don't need to worry about it.
7503 }
7504 }
7505 // Reframe any text node just after the node being removed, if there is
7506 // one, and if it's not the last child or the first child.
7512 }
7513 }
7515 #ifdef DEBUG
7519 }
7520 #endif
7521 }
7524 }
7526 #ifdef DEBUG
7527 // To ensure that the functions below are only called within
7528 // |ApplyRenderingChangeToTree|.
7530 #endif
7532 static void
7536 nsChangeHint aChange);
7538 /**
7539 * @param aBoundsRect returns the bounds enclosing the areas covered by aFrame and its childre
7540 * This rect is relative to aFrame's parent
7541 */
7542 static void
7545 nsChangeHint aChange)
7546 {
7555 }
7556 }
7558 // now do children of frame
7567 // only do frames that don't have placeholders
7569 // do the out-of-flow frame and its continuations
7584 }
7586 }
7587 }
7589 }
7592 }
7594 static void
7598 nsChangeHint aChange)
7599 {
7604 // Get view if this frame has one and trigger an update. If the
7605 // frame doesn't have a view, find the nearest containing view
7606 // (adjusting r's coordinate system to reflect the nesting) and
7607 // update there.
7610 // if frame has view, will already be invalidated
7613 #ifdef MOZ_SVG
7617 // We need this to invalidate frames when their 'filter' or 'marker'
7618 // property changes. XXX in theory changes to 'marker' should be
7619 // handled in nsSVGPathGeometryFrame::DidSetStyleContext, but for
7620 // some reason that's broken.
7621 //
7622 // This call is also currently the only mechanism for invalidating
7623 // the area covered by a <foreignObject> when 'opacity' changes on
7624 // it or one of its ancestors. (For 'opacity' changes on <image> or
7625 // a graphical element such as <path>, or on one of their
7626 // ancestors, this is redundant since
7627 // nsSVGPathGeometryFrame::DidSetStyleContext also invalidates.)
7629 }
7630 }
7631 #endif
7634 }
7635 }
7640 }
7646 }
7647 }
7648 }
7650 static void
7653 nsChangeHint aChange)
7654 {
7657 // Don't allow synchronous rendering changes when painting is turned off.
7661 }
7662 }
7664 // If the frame's background is propagated to an ancestor, walk up to
7665 // that ancestor.
7670 }
7674 // Trigger rendering updates by damaging this frame and any
7675 // continuations of this frame.
7677 // XXX this needs to detect the need for a view due to an opacity change and deal with it...
7681 #ifdef DEBUG
7683 #endif
7685 aChange);
7686 #ifdef DEBUG
7688 #endif
7691 }
7693 /**
7694 * This method invalidates the canvas when frames are removed or added for a
7695 * node that might have its background propagated to the canvas, i.e., a
7696 * document root node or an HTML BODY which is a child of the root node.
7697 *
7698 * @param aFrame a frame for a content node about to be removed or a frame that
7699 * was just created for a content node that was inserted.
7700 */
7701 static void
7703 {
7707 // Note that both in ContentRemoved and ContentInserted the content node
7708 // will still have the right parent pointer, so looking at that is ok.
7712 // Has a parent; might not be what we want
7715 // Has a grandparent, so not what we want
7717 }
7719 // Check whether it's an HTML body
7723 }
7724 }
7726 // At this point the node has no parent or it's an HTML <body> child of the
7727 // root. We might not need to invalidate in this case (eg we might be in
7728 // XHTML or something), but chances are we want to. Play it safe.
7729 // Invalidate the viewport.
7731 // Wrap this in a DEFERRED view update batch so we don't try to
7732 // flush out layout here
7738 }
7740 nsresult
7742 nsChangeHint aHint)
7743 {
7744 // If the frame hasn't even received an initial reflow, then don't
7745 // send it a style-change reflow!
7749 #ifdef DEBUG
7754 }
7755 #endif
7766 }
7768 nsFrameState dirtyBits;
7773 }
7781 }
7783 nsresult
7786 {
7794 #ifdef DEBUG
7798 #endif
7803 }
7805 // Find the child frame
7808 // Notify the first frame that maps the content. It will generate a reflow
7809 // command
7811 // It's possible the frame whose content changed isn't inserted into the
7812 // frame hierarchy yet, or that there is no frame that maps the content
7814 #if 0
7819 #endif
7821 // Special check for text content that is a child of a letter frame. If
7822 // this happens, we should remove the letter frame, do whatever we're
7823 // planning to do with this notification, then put the letter frame back.
7824 // Note that this is basically what RecreateFramesForContent ends up doing;
7825 // the reason we dont' want to call that here is that our text content
7826 // could be native anonymous, in which case RecreateFramesForContent would
7827 // completely barf on it. And recreating the non-anonymous ancestor would
7828 // just lead us to come back into this notification (e.g. if quotes or
7829 // counters are involved), leading to a loop.
7833 // See if the block has first-letter style applied to it.
7838 // Reget |frame|, since we might have killed it.
7839 // Do we really need to call CharacterDataChanged in this case, though?
7842 }
7843 }
7849 }
7850 }
7853 }
7857 nsresult
7859 {
7866 // Make sure to not rebuild quote or counter lists while we're
7867 // processing restyles
7873 // Mark frames so that we skip frames that die along the way, bug 123049.
7874 // A frame can be in the list multiple times with different hints. Further
7875 // optmization is possible if nsStyleChangeList::AppendChange could coalesce
7884 }
7885 }
7894 nsChangeHint hint;
7902 // XXXbz this is due to image maps messing with the primary frame of
7903 // <area>s. See bug 135040. Remove this block once that's fixed.
7907 }
7908 }
7910 // skip any frame that has been destroyed due to a ripple effect
7914 }
7920 #ifdef MOZ_SVG
7923 }
7924 #endif
7928 }
7933 }
7936 }
7937 }
7938 }
7943 // RepaintFrame changes can indicate changes in opacity etc which
7944 // can require plugin clipping to change. If we requested a reflow,
7945 // we don't need to do this since the reflow will do it for us.
7950 }
7951 }
7953 // cleanup references and verify the style tree. Note that the latter needs
7954 // to happen once we've processed the whole list, since until then the tree
7955 // is not in fact in a consistent state.
7962 }
7964 #ifdef DEBUG
7965 // reget frame from content since it may have been regenerated...
7970 }
7973 }
7974 #endif
7975 }
7979 }
7981 void
7984 nsChangeHint aMinHint,
7986 PRBool aRestyleDescendants)
7987 {
7991 // XXXbz this is due to image maps messing with the primary frame pointer
7992 // of <area>s. See bug 135040. We can remove this block once that's fixed.
7994 }
8001 nsStyleChangeList changeList;
8007 // no frames, reconstruct for content
8009 }
8010 }
8012 nsresult
8015 PRInt32 aStateMask)
8016 {
8017 // XXXbz it would be good if this function only took Elements, but
8018 // we'd have to make ESM guarantee that usefully.
8021 }
8024 }
8026 }
8028 void
8030 PRInt32 aStateMask)
8031 {
8037 // Any change to a content state that affects which frames we construct
8038 // must lead to a frame reconstruct here if we already have a frame.
8039 // Note that we never decide through non-CSS means to not create frames
8040 // based on content states, so if we already don't have a frame we don't
8041 // need to force a reframe -- if it's needed, the HasStateDependentStyle
8042 // call will handle things.
8045 // If it's generated content, ignore LOADING/etc state changes on it.
8060 }
8061 }
8062 }
8063 }
8064 }
8066 nsRestyleHint rshint =
8071 }
8074 // Exposing information to the page about whether the link is
8075 // visited or not isn't really something we can worry about here.
8076 // FIXME: We could probably do this a bit better.
8078 }
8081 }
8083 void
8085 PRInt32 aNameSpaceID,
8087 PRInt32 aModType)
8088 {
8089 nsRestyleHint rshint =
8091 aElement,
8092 aAttribute,
8093 aModType,
8094 PR_FALSE);
8096 }
8098 void
8100 PRInt32 aNameSpaceID,
8102 PRInt32 aModType)
8103 {
8104 // Hold onto the PresShell to prevent ourselves from being destroyed.
8105 // XXXbz how, exactly, would this attribute change cause us to be
8106 // destroyed from inside this function?
8109 // Get the frame associated with the content which is the highest in the frame tree
8112 #if 0
8116 #endif
8118 // the style tag has its own interpretation based on aHint
8123 #ifdef MOZ_XUL
8124 // The following listbox widget trap prevents offscreen listbox widget
8125 // content from being removed and re-inserted (which is what would
8126 // happen otherwise).
8128 PRInt32 namespaceID;
8136 }
8140 {
8147 }
8148 }
8153 // See if we have appearance information for a theme.
8163 }
8164 }
8166 // let the frame deal with it now, so we don't have to deal later
8168 // XXXwaterson should probably check for special IB siblings
8169 // here, and propagate the AttributeChanged notification to
8170 // them, as well. Currently, inline frames don't do anything on
8171 // this notification, so it's not that big a deal.
8172 }
8174 // See if we can optimize away the style re-resolution -- must be called after
8175 // the frame's AttributeChanged() in case it does something that affects the style
8176 nsRestyleHint rshint =
8178 aElement,
8179 aAttribute,
8180 aModType,
8181 PR_TRUE);
8184 }
8186 void
8192 }
8194 void
8196 {
8198 // This is the end of our last update. Before we decrement
8199 // mUpdateCount, recalc quotes and counters as needed.
8203 }
8205 }
8207 void
8209 {
8213 }
8218 }
8222 }
8224 void
8226 {
8227 #if defined(DEBUG_dbaron_off)
8229 #endif
8233 // Prevent frame tree destruction from being O(N^2)
8237 // Remove our presshell as a style flush observer. But leave
8238 // mObservingRefreshDriver true so we don't readd to it even if someone tries
8239 // to post restyle events on us from this point on for some reason.
8242 }
8244 //STATIC
8246 // XXXbz I'd really like this method to go away. Once we have inline-block and
8247 // I can just use that for sized broken images, that can happen, maybe.
8251 {
8252 // The "alt" attribute specifies alternate text that is rendered
8253 // when the image can not be displayed
8255 // If there's no "alt" attribute, and aContent is an input
8256 // element, then use the value of the "value" attribute
8259 // If there's no "value" attribute either, then use the localized string
8260 // for "Submit" as the alternate text.
8264 }
8265 }
8266 }
8268 nsresult
8276 {
8283 // Create a continuing inner table frame, and if there's a caption then
8284 // replicate the caption
8285 nsFrameItems newChildFrames;
8296 }
8300 }
8302 // Set the outer table's initial child list
8307 }
8311 }
8312 }
8314 nsresult
8322 {
8329 // Replicate any header/footer frames
8330 nsFrameItems childFrames;
8333 // See if it's a header/footer, possibly wrapped in a scroll frame.
8336 // If the row group was continued, then don't replicate it.
8340 }
8342 // Replicate the header/footer frame.
8344 nsFrameItems childItems;
8347 nsnull);
8356 nsnull);
8361 // Table specific initialization
8364 // XXX Deal with absolute and fixed frames...
8366 }
8367 }
8369 // Set the table frame's initial child list
8374 }
8378 }
8379 }
8381 nsresult
8386 PRBool aIsFluid)
8387 {
8395 // Use the frame type to determine what type of frame to create
8408 }
8416 }
8424 }
8426 #ifdef MOZ_XUL
8433 }
8434 #endif
8441 }
8449 }
8469 }
8478 // Create a continuing frame for each table cell frame
8479 nsFrameItems newChildList;
8482 // See if it's a table cell frame
8492 }
8494 }
8496 }
8498 // Set the table cell's initial child list
8500 }
8503 // Warning: If you change this and add a wrapper frame around table cell
8504 // frames, make sure Bug 368554 doesn't regress!
8505 // See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.
8512 // Create a continuing area frame
8521 }
8523 // Set the table cell's initial child list
8525 }
8533 }
8541 }
8548 }
8554 }
8556 // create a continuing out of flow frame
8563 }
8564 // create a continuing placeholder frame
8573 }
8582 // Create a continuing area frame
8583 // XXXbz we really shouldn't have to do this by hand!
8592 }
8593 // Set the fieldset's initial child list
8595 }
8602 }
8607 }
8613 }
8615 // Init() set newFrame to be a fluid continuation of aFrame.
8616 // If we want a non-fluid continuation, we need to call SetPrevContinuation()
8617 // to reset NS_FRAME_IS_FLUID_CONTINUATION.
8620 }
8622 // A continuation of generated content is also generated content
8625 }
8627 // A continuation of an out-of-flow is also an out-of-flow
8630 }
8638 }
8642 }
8644 nsresult
8646 {
8647 // Now deal with fixed-pos things.... They should appear on all pages,
8648 // so we want to move over the placeholders when processing the child
8649 // of the pageContentFrame.
8654 }
8658 // document's root element frame missing
8660 }
8662 nsFrameItems fixedPlaceholders;
8666 }
8668 // Don't allow abs-pos descendants of the fixed content to escape the content.
8669 // This should not normally be possible (because fixed-pos elements should
8670 // be absolute containers) but fixed-pos tables currently aren't abs-pos
8671 // containers.
8673 nsnull,
8674 mRootElementFrame);
8677 // Iterate across fixed frames and replicate each whose placeholder is a
8678 // descendant of aFrame. (We don't want to explicitly copy placeholders that
8679 // are within fixed frames, because that would cause duplicates on the new
8680 // page - bug 389619)
8688 }
8689 }
8691 // Add the placeholders to our primary child list.
8692 // XXXbz this is a little screwed up, since the fixed frames will have
8693 // broken auto-positioning. Oh, well.
8698 }
8700 nsresult
8705 {
8706 // Make the insertion point be the parent frame by default, in case
8707 // we have to bail early.
8718 // We've got an explicit insertion child. Check to see if it's
8719 // anonymous.
8721 // This child content is anonymous. Don't use the insertion
8722 // point, since that's only for the explicit kids.
8724 }
8726 PRUint32 index;
8728 aChildContent,
8730 }
8732 PRBool multiple;
8733 PRUint32 index;
8739 }
8744 // Use the content insertion frame of the insertion point.
8748 }
8750 // There was no frame created yet for the insertion point.
8752 }
8753 }
8755 // fieldsets have multiple insertion points. Note that we might
8756 // have to look at insertionElement here...
8762 }
8763 }
8766 }
8768 // Capture state for the frame tree rooted at the frame associated with the
8769 // content object, aContent
8770 nsresult
8773 {
8777 }
8780 }
8782 }
8784 // Capture state for the frame tree rooted at aFrame.
8785 nsresult
8788 {
8791 }
8793 }
8795 nsresult
8797 {
8803 // The parent has a frame, so try resolving a new context.
8810 }
8811 }
8813 }
8817 {
8822 }
8824 }
8828 {
8835 }
8837 PRBool
8840 {
8848 // The removal functions can't handle removal of an {ib} split directly; we
8849 // need to rebuild the containing block.
8850 #ifdef DEBUG
8856 }
8857 #endif
8861 }
8865 // When we remove the legend for a fieldset, we should reframe
8866 // the fieldset to ensure another legend is used, if there is one
8869 }
8871 // Now check for possibly needing to reconstruct due to a pseudo parent
8880 // If we're a table-column-group, then the GetFirstChild check above is
8881 // not going to catch cases when we're the first child.
8884 // Similar if we're a table-caption.
8887 // We're the first or last frame in the pseudo. Need to reframe.
8888 // Good enough to recreate frames for |parent|'s content
8891 }
8892 }
8894 // Might need to reconstruct things if this frame's nextSibling is a table
8895 // pseudo, since removal of this frame might mean that this pseudo needs to
8896 // get merged with the frame's prevSibling.
8897 // XXXbz it would be really nice if we had the prevSibling here too, to check
8898 // whether this is in fact the case...
8903 #ifdef DEBUG
8909 }
8910 #endif
8911 // Good enough to recreate frames for aFrame's parent's content; even if
8912 // aFrame's parent is a table pseudo, that'll be the right content node.
8915 }
8917 #ifdef MOZ_XUL
8923 }
8924 }
8925 #endif
8927 // We might still need to reconstruct things if the parent of inFlowFrame is
8928 // special, since in that case the removal of aFrame might affect the
8929 // splitting of its parent.
8932 }
8934 // If inFlowFrame is not the only in-flow child of |parent|, then removing
8935 // it will change nothing about the {ib} split.
8939 }
8941 // If the parent is the first or last part of the {ib} split, then
8942 // removing one of its kids will have no effect on the splitting.
8943 // Get the first continuation up front so we don't have to do it twice.
8948 }
8950 #ifdef DEBUG
8956 }
8957 #endif
8961 }
8963 nsresult
8965 PRBool aAsyncInsert)
8966 {
8969 // If there is no document, we don't want to recreate frames for it. (You
8970 // shouldn't generally be giving this method content without a document
8971 // anyway).
8972 // Rebuilding the frame tree can have bad effects, especially if it's the
8973 // frame tree for chrome (see bug 157322).
8976 // Is the frame `special'? If so, we need to reframe the containing
8977 // block *here*, rather than trying to remove and re-insert the
8978 // content (which would otherwise result in *two* nested reframe
8979 // containing block from ContentRemoved() and ContentInserted(),
8980 // below!). We'd really like to optimize away one of those
8981 // containing block reframes, hence the code here.
8985 // Reframe the topmost MathML element to prevent exponential blowup
8986 // (see bug 397518)
8994 }
8995 }
9001 }
9005 // If the parent frame is a leaf then the subsequent insert will fail to
9006 // create a frame, so we need to recreate the parent content. This happens
9007 // with native anonymous content from the editor.
9011 }
9012 }
9018 }
9021 // XXXbz how can containerNode be null here?
9023 // Before removing the frames associated with the content object,
9024 // ask them to save their state onto a temporary state object.
9027 // Need the nsIContent parent, which might be null here, since we need to
9028 // pass it to ContentInserted and ContentRemoved.
9031 // Remove the frames associated with the content object.
9032 PRBool didReconstruct;
9035 nsnull :
9040 // Now, recreate the frames associated with this content object. If
9041 // ContentRemoved triggered reconstruction, then we don't need to do this
9042 // because the frames will already have been built.
9045 nsChangeHint_ReconstructFrame);
9048 }
9049 }
9050 }
9052 #ifdef ACCESSIBILITY
9054 PRUint32 changeType;
9059 }
9062 }
9064 // A significant enough change occurred that this part
9065 // of the accessible tree is no longer valid.
9070 }
9071 }
9072 #endif
9075 }
9077 //////////////////////////////////////////////////////////////////////
9079 // Block frame construction code
9084 {
9089 aStyleContext);
9090 }
9092 }
9097 {
9102 aStyleContext);
9103 }
9105 }
9107 // Predicate to see if a given content (block element) has
9108 // first-letter style applied to it.
9109 PRBool
9112 {
9116 }
9118 PRBool
9120 {
9126 }
9128 PRBool
9131 {
9132 PRBool hasFirstLine =
9137 // But disable for fieldsets
9138 PRInt32 namespaceID;
9141 // This check must match the one in FindHTMLData.
9144 }
9147 }
9149 void
9154 {
9159 }
9161 /* static */
9166 FCDATA_USE_CHILD_ITEMS |
9170 },
9173 FCDATA_USE_CHILD_ITEMS |
9177 },
9181 FCDATA_SKIP_ABSPOS_PUSH |
9183 NS_NewTableRowGroupFrame),
9185 },
9189 FCDATA_SKIP_ABSPOS_PUSH |
9191 NS_NewTableColGroupFrame),
9193 },
9198 }
9199 };
9201 /*
9202 * This function works as follows: we walk through the child list (aItems) and
9203 * find items that cannot have aParentFrame as their parent. We wrap
9204 * continuous runs of such items into a FrameConstructionItem for a frame that
9205 * gets them closer to their desired parents. For example, a run of non-row
9206 * children of a row-group will get wrapped in a row. When we later construct
9207 * the frame for this wrapper (in this case for the row), it'll be the correct
9208 * parent for the cells in the set of items we wrapped or we'll wrap cells
9209 * around everything else. At the end of this method, aItems is guaranteed to
9210 * contain only items for frames that can be direct kids of aParentFrame.
9211 */
9212 nsresult
9216 {
9219 // Nothing to do here
9221 }
9226 // Nothing else to do here; we're finished
9228 }
9230 // Now we're pointing to the first child that wants a different parent
9231 // type.
9233 // Now try to figure out what kids we can group together. We can generally
9234 // group everything that has a different desired parent type from us. Two
9235 // exceptions to this:
9236 // 1) If our parent type is table, we can't group columns with anything
9237 // else other than whitespace.
9238 // 2) Whitespace that lies between two things we can group which both want
9239 // a non-block parent should be dropped, even if we can't group them
9240 // with each other and even if the whitespace wants a parent of
9241 // ourParentType. Ends of the list count as things that don't want a
9242 // block parent (so that for example we'll drop a whitespace-only list).
9248 // Just group them all and be done with it. We need the check for
9249 // eTypeBlock here to catch the "all the items are whitespace" case
9250 // described above.
9253 // Locate the end of the group.
9255 // Keep track of the type the previous item wanted, in case we have to
9256 // deal with whitespace. Start it off with ourParentType, since that's
9257 // the last thing |iter| would have skipped over.
9260 /* Walk an iterator past any whitespace that we might be able to drop from the list */
9267 // See whether we can drop the whitespace
9276 }
9280 }
9283 // Update groupingParentType, since it might have been eTypeBlock
9284 // just because of the whitespace.
9286 }
9287 }
9288 }
9290 // Now endIter points to a non-whitespace item or a non-droppable
9291 // whitespace item. In the latter case, if this is the end of the group
9292 // we'll traverse this whitespace again. But it'll all just be quick
9293 // DesiredParentType() checks which will match ourParentType (that's
9294 // what it means that this is the group end), so it's OK.
9297 // End the group at endIter.
9299 }
9304 // Either we started with columns and now found something else, or vice
9305 // versa. In any case, end the grouping.
9307 }
9309 // Include the whitespace we didn't drop (if any) in the group, since
9310 // this is not the end of the group. Note that this doesn't change
9311 // prevParentType, since if we didn't drop the whitespace then we ended
9312 // at something that wants a block parent.
9317 }
9320 // Nothing to wrap here; just skipped some whitespace
9322 }
9324 // Now group together all the items between iter and endIter. The right
9325 // parent type to use depends on ourParentType.
9326 ParentType wrapperType;
9332 // The parent type for a cell is eTypeBlock, since that's what a cell
9333 // looks like to its kids.
9340 // Either colgroup or rowgroup, depending on what we're grouping.
9347 }
9357 }
9363 // Use the content of our parent frame
9364 parentContent,
9365 // Lie about the tag; it doesn't matter anyway
9366 pseudoType,
9367 // The namespace does matter, however; it needs
9368 // to match that of our first child item to
9369 // match the old behavior
9371 // no pending binding
9372 nsnull,
9374 PR_TRUE);
9378 }
9380 // Here we're cheating a tad... technically, table-internal items should be
9381 // inline if aParentFrame is inline, but they'll get wrapped in an
9382 // inline-table in the end, so it'll all work out. In any case, arguably
9383 // we don't need to maintain this state at this point... but it's better
9384 // to, I guess.
9388 // Table pseudo frames always induce line boundaries around their
9389 // contents.
9392 // The parent of the items in aItems is also the parent of the items
9393 // in mChildItems
9397 // Eat up all items between |iter| and |endIter| and put them in our wrapper
9398 // Advances |iter| to point to |endIter|.
9403 // Now |iter| points to the item that was the first one we didn't wrap;
9404 // loop and see whether we need to skip it or wrap it in something
9405 // different.
9409 }
9411 inline nsresult
9416 {
9420 #ifdef DEBUG
9424 }
9425 #endif
9430 }
9436 }
9438 nsresult
9447 {
9450 "Parent frame in ProcessChildren should be its own "
9453 // XXXbz ideally, this would do all the pushing of various
9454 // containing blocks as needed, so callers don't have to do it...
9460 }
9462 // The logic here needs to match the logic in GetFloatContainingBlock()
9463 nsFrameConstructorSaveState floatSaveState;
9469 }
9472 aPendingBinding);
9474 FrameConstructionItemList itemsToConstruct;
9477 // If we have first-letter or first-line style then frames can get
9478 // moved around so don't set these flags.
9482 }
9484 // Create any anonymous frames we need here. This must happen before the
9485 // non-anonymous children are processed to ensure that popups are never
9486 // constructed before the popupset.
9490 #ifdef DEBUG
9493 "If you need to use CreateFrameFor, you need to call "
9494 "CreateAnonymousFrames manually and not follow the standard "
9496 #endif
9498 itemsToConstruct);
9499 }
9502 // :before/:after content should have the same style context parent
9503 // as normal kids.
9504 // Note that we don't use this style context for looking up things like
9505 // special block styles because in some cases involving table pseudo-frames
9506 // it has nothing to do with the parent frame's desired behavior.
9510 styleContext =
9512 // Probe for generated content before
9515 itemsToConstruct);
9516 }
9523 // Frame construction item construction should not post
9524 // restyles, so removing restyle flags here is safe.
9527 }
9529 itemsToConstruct);
9530 }
9534 // Probe for generated content after
9537 itemsToConstruct);
9538 }
9541 }
9544 aFrameItems);
9552 }
9555 aFrameItems);
9556 }
9558 // We might end up with first-line frames that change
9559 // AnyKidsNeedBlockParent() without changing itemsToConstruct, but that
9560 // should never happen for cases whan aFrame->IsBoxFrame().
9569 // XXXbz we could do this on the FrameConstructionItemList level,
9570 // no? And if we cared we could look through the item list
9571 // instead of groveling through the framelist here..
9581 message,
9590 frameStyleContext);
9592 // We might, in theory, want to set NS_BLOCK_FLOAT_MGR and
9593 // NS_BLOCK_MARGIN_ROOT, but I think it's a bad idea given that
9594 // a real block placed here wouldn't get those set on it.
9608 }
9611 }
9613 //----------------------------------------------------------------------
9615 // Support for :first-line style
9617 // Special routine to handle placing a list of frames into a block
9618 // frame that has first-line style. The routine ensures that the first
9619 // collection of inline frames end up in a first-line frame.
9620 // NOTE: aState may have containing block information related to a
9621 // different part of the frame tree than where the first line occurs.
9622 // In particular aState may be set up for where ContentInserted or
9623 // ContentAppended is inserting content, which may be some
9624 // non-first-in-flow continuation of the block to which the first-line
9625 // belongs. So this function needs to be careful about how it uses
9626 // aState.
9627 nsresult
9634 {
9637 // Find the part of aFrameItems that we want to put in the first-line
9641 }
9646 // Nothing is supposed to go into the first-line; nothing to do
9648 }
9651 // Create line frame
9657 parentStyle);
9662 // Initialize the line frame
9664 aLineFrame);
9666 // The lineFrame will be the block's first child; the rest of the
9667 // frame list (after lastInlineFrame) will be the second and
9668 // subsequent children; insert lineFrame into aFrameItems.
9673 }
9674 }
9677 // Give the inline frames to the lineFrame <b>after</b> reparenting them
9684 }
9685 }
9688 }
9691 }
9693 // Special routine to handle appending a new frame to a block frame's
9694 // child list. Takes care of placing the new frame into the right
9695 // place when first-line style is present.
9696 nsresult
9702 {
9703 // It's possible that aBlockFrame needs to have a first-line frame
9704 // created because it doesn't currently have any children.
9709 }
9711 // Examine the last block child - if it's a first-line frame then
9712 // appended frames need special treatment.
9715 // No first-line frame at the end of the list, therefore there is
9716 // an intervening block between any first-line frame the frames
9717 // we are appending. Therefore, we don't need any special
9718 // treatment of the appended frames.
9720 }
9724 }
9726 // Special routine to handle inserting a new frame into a block
9727 // frame's child list. Takes care of placing the new frame into the
9728 // right place when first-line style is present.
9729 nsresult
9737 {
9739 // XXXbz If you make this method actually do something, check to
9740 // make sure that the caller is passing what you expect. In
9741 // particular, which content is aContent? And audit the rest of
9742 // this code too; it makes bogus assumptions and may not build.
9743 #if 0
9749 // Insertion will become the first frame. Two cases: we either
9750 // already have a first-line frame or we don't.
9753 // We already have a first-line frame
9757 // Easy case: the new inline frame will go into the lineFrame.
9760 newFrame);
9762 // Since the frame is going into the lineFrame, don't let it
9763 // go into the block too.
9766 }
9768 // Harder case: We are about to insert a block level element
9769 // before the first-line frame.
9770 // XXX need a method to steal away frames from the line-frame
9771 }
9772 }
9774 // We do not have a first-line frame
9776 // We now need a first-line frame to contain the inline frame.
9780 }
9783 // Lookup first-line style context
9791 // Initialize the line frame
9795 // Make sure the caller inserts the lineFrame into the
9796 // blocks list of children.
9800 // Give the inline frames to the lineFrame <b>after</b>
9801 // reparenting them
9806 }
9807 }
9809 // Easy case: the regular insertion logic can insert the new
9810 // frame because it's a block frame.
9811 }
9812 }
9813 }
9815 // Insertion will not be the first frame.
9818 // Easy case: The prev-siblings parent is the block
9819 // frame. Therefore the prev-sibling is not currently in a
9820 // line-frame. Therefore the new frame which is going after it,
9821 // regardless of type, is not going into a line-frame.
9822 }
9824 // If the prevSiblingParent is not the block-frame then it must
9825 // be a line-frame (if it were a letter-frame, that logic would
9826 // already have adjusted the prev-sibling to be the
9827 // letter-frame).
9829 // Easy case: the insertion can go where the caller thinks it
9830 // should go (which is into prevSiblingParent).
9831 }
9833 // Block elements don't end up in line-frames, therefore
9834 // change the insertion point to aBlockFrame. However, there
9835 // might be more inline elements following aPrevSibling that
9836 // need to be pulled out of the line-frame and become children
9837 // of the block.
9841 // Oy. We have work to do. Create a list of the new frames
9842 // that are going into the block by stripping them away from
9843 // the line-frame(s).
9847 // XXX do something with 'tail'
9848 }
9855 }
9857 }
9858 }
9860 // We got lucky: aPrevSibling was the last inline frame in
9861 // the line-frame.
9867 }
9868 }
9869 }
9870 }
9872 #endif
9874 }
9876 //----------------------------------------------------------------------
9878 // First-letter support
9880 // Determine how many characters in the text fragment apply to the
9881 // first letter
9882 static PRInt32
9884 {
9896 }
9897 count++;
9899 }
9900 // XXX I18n
9905 }
9906 // keep looping
9908 }
9910 count++;
9913 }
9914 }
9917 }
9919 static PRBool
9921 {
9932 }
9933 }
9934 }
9936 }
9939 {
9942 }
9944 /**
9945 * Create a letter frame, only make it a floating frame.
9946 */
9947 void
9957 {
9958 // Create the first-letter-frame
9959 nsresult rv;
9964 // We don't want to use a text content for a non-text frame (because we want
9965 // its primary frame to be a text frame). So use its parent for the
9966 // first-letter.
9971 letterFrame);
9973 // Init the text frame to refer to the letter frame. Make sure we
9974 // get a proper style context for it (the one passed in is for the
9975 // letter frame and will have the float property set on it; the text
9976 // frame shouldn't have that set).
9982 // And then give the text frame to the letter frame
9985 // See if we will need to continue the text frame (does it contain
9986 // more than just the first-letter text or not?) If it does, then we
9987 // create (in advance) a continuation frame for it.
9990 // Create continuation
9996 }
9997 // Repair the continuations style context
10004 }
10005 }
10006 }
10009 // Put the new float before any of the floats in the block we're doing
10010 // first-letter for, that is, before any floats whose parent is
10011 // containingBlock.
10015 }
10026 }
10027 }
10028 }
10030 /**
10031 * Create a new letter frame for aTextFrame. The letter frame will be
10032 * a child of aParentFrame.
10033 */
10034 nsresult
10040 {
10046 // Get style context for the first-letter-frame
10052 // Use content from containing block so that we can actually
10053 // find a matching style rule.
10056 // Create first-letter style rule
10058 parentStyleContext);
10063 // Create a new text frame (the original one will be discarded)
10064 // pass a temporary stylecontext, the correct one will be set
10065 // later. Start off by unsetting the primary frame for
10066 // aTextContent, so it's no longer pointing to the to-be-destroyed
10067 // frame.
10068 // XXXbz it would be really nice to destroy the old frame _first_,
10069 // then create the new one, so we could avoid this hack.
10077 aBlockContinuation);
10079 // Create the right type of first-letter frame
10082 // Make a floating first-letter frame
10085 }
10087 // Make an inflow first-letter frame
10091 // Initialize the first-letter-frame. We don't want to use a text
10092 // content for a non-text frame (because we want its primary frame to
10093 // be a text frame). So use its parent for the first-letter.
10098 textFrame);
10106 }
10107 }
10109 }
10112 }
10114 nsresult
10119 {
10127 nsFrameItems letterFrames;
10135 }
10138 // Take textFrame out of the block's frame list and substitute the
10139 // letter frame(s) instead.
10142 }
10144 // Take the old textFrame out of the inline parent's child list
10147 // Insert in the letter frame(s)
10149 }
10150 }
10153 }
10155 nsresult
10166 {
10177 // Wrap up first-letter content in a letter frame
10180 // Create letter frame to wrap up the text
10185 }
10187 // Provide adjustment information for parent
10193 }
10194 }
10202 }
10203 }
10205 // This will stop us looking to create more letter frames. For
10206 // example, maybe the frame-type is "letterFrame" or
10207 // "placeholderFrame". This keeps us from creating extra letter
10208 // frames, and also prevents us from creating letter frames when
10209 // the first real content child of a block is not text (e.g. an
10210 // image, hr, etc.)
10213 }
10217 }
10220 }
10222 nsresult
10229 {
10230 // First look for the float frame that is a letter frame
10233 // See if we found a floating letter frame
10236 }
10238 }
10240 // No such frame
10242 }
10244 // Take the text frame away from the letter frame (so it isn't
10245 // destroyed when we destroy the letter frame).
10249 }
10251 // Discover the placeholder frame for the letter frame
10257 // Somethings really wrong
10259 }
10262 // Somethings really wrong
10264 }
10266 // Create a new text frame with the right style context that maps
10267 // all of the content that was previously part of the letter frame
10268 // (and probably continued elsewhere).
10272 }
10276 }
10281 }
10285 }
10288 // Destroy the old text frame's continuations (the old text frame
10289 // will be destroyed when its letter frame is destroyed).
10295 }
10299 // Now that everything is set...
10300 #ifdef NOISY_FIRST_LETTER
10303 #endif
10305 // Remove placeholder frame and the float
10308 // Now that the old frames are gone, we can start pointing to our
10309 // new primary frame.
10312 // Insert text frame in its place
10317 }
10319 nsresult
10326 {
10332 // Bingo. Found it. First steal away the text frame.
10336 }
10338 // Create a new textframe
10342 }
10346 }
10351 }
10355 // Next rip out the kid and replace it with the text frame
10358 // Now that the old frames are gone, we can start pointing to our
10359 // new primary frame.
10362 // Insert text frame in its place
10371 }
10373 // Look inside child inline frame for the letter frame
10378 }
10379 }
10382 }
10385 }
10387 nsresult
10392 {
10397 nsresult rv;
10400 aFrameManager,
10405 }
10408 }
10412 }
10414 // Fixup the letter frame situation for the given block
10415 nsresult
10417 {
10424 nsFrameItems letterFrames;
10426 nsresult rv;
10428 // XXX shouldn't this bit be set already (bug 408493), assert instead?
10436 }
10439 }
10444 // Take the old textFrame out of the parents child list
10447 // Insert in the letter frame(s)
10449 }
10451 }
10453 //----------------------------------------------------------------------
10455 // listbox Widget Routines
10457 nsresult
10463 PRBool aIsAppend,
10464 PRBool aIsScrollbar,
10466 {
10467 #ifdef MOZ_XUL
10470 // Construct a new frame
10472 nsFrameItems frameItems;
10476 mTempFrameTreeState);
10481 // Pre-check for display "none" - only if we find that, do we create
10482 // any frame at all
10488 }
10492 FrameConstructionItemList items;
10503 // Notify the parent frame
10506 else
10508 }
10511 }
10514 #else
10516 #endif
10517 }
10519 //----------------------------------------
10521 nsresult
10530 PRBool aAbsPosContainer,
10532 {
10533 // Create column wrapper if necessary
10545 }
10548 // See if we need to create a view
10556 }
10562 aStyleContext,
10564 aParentFrame);
10567 }
10569 // See if we need to create a view, e.g. the frame is absolutely positioned
10573 // The frame we're constructing will be the root element frame.
10574 // Set mRootElementFrame before processing children.
10576 }
10578 // We should make the outer frame be the absolute containing block,
10579 // if one is required. We have to do this because absolute
10580 // positioning must be computed with respect to the CSS dimensions
10581 // of the element, which are the dimensions of the outer block. But
10582 // we can't really do that because only blocks can have absolute
10583 // children. So use the block and try to compensate with hacks
10584 // in nsBlockFrame::CalculateContainingBlockSizeForAbsolutes.
10585 nsFrameConstructorSaveState absoluteSaveState;
10587 // NS_ASSERTION(aRelPos, "should have made area frame for this");
10589 }
10591 // Process the child content
10592 nsFrameItems childItems;
10596 // Set the frame's initial child list
10600 }
10602 nsresult
10609 {
10610 // If an inline frame has non-inline kids, then we chop up the child list
10611 // into runs of blocks and runs of inlines, create anonymous block frames to
10612 // contain the runs of blocks, inline frames with our style context for the
10613 // runs of inlines, and put all these frames, in order, into aFrameItems. We
10614 // put the first one into *aNewFrame. The whole setup is called an {ib}
10615 // split; in what follows "frames in the split" refers to the anonymous blocks
10616 // and inlines that contain our children.
10617 //
10618 // {ib} splits maintain the following invariants:
10619 // 1) All frames in the split have the NS_FRAME_IS_SPECIAL bit set.
10620 // 2) Each frame in the split has the nsIFrame::IBSplitSpecialSibling
10621 // property pointing to the next frame in the split, except for the last
10622 // one, which does not have it set.
10623 // 3) Each frame in the split has the nsIFrame::IBSplitSpecialPrevSibling
10624 // property pointing to the previous frame in the split, except for the
10625 // first one, which does not have it set.
10626 // 4) The first and last frame in the split are always inlines.
10627 //
10628 // An invariant that is NOT maintained is that the wrappers are actually
10629 // linked via GetNextSibling linkage. A simple example is an inline
10630 // containing an inline that contains a block. The three parts of the inner
10631 // inline end up with three different parents.
10632 //
10633 // For example, this HTML:
10634 // <span>
10635 // <div>a</div>
10636 // <span>
10637 // b
10638 // <div>c</div>
10639 // </span>
10640 // d
10641 // <div>e</div>
10642 // f
10643 // </span>
10644 // Gives the following frame tree:
10645 //
10646 // Inline (outer span)
10647 // Block (anonymous, outer span)
10648 // Block (div)
10649 // Text("a")
10650 // Inline (outer span)
10651 // Inline (inner span)
10652 // Text("b")
10653 // Block (anonymous, outer span)
10654 // Block (anonymous, inner span)
10655 // Block (div)
10656 // Text("c")
10657 // Inline (outer span)
10658 // Inline (inner span)
10659 // Text("d")
10660 // Block (anonymous, outer span)
10661 // Block (div)
10662 // Text("e")
10663 // Inline (outer span)
10664 // Text("f")
10671 PRBool positioned =
10679 }
10681 // Initialize the frame
10685 // because the object's destructor is significant
10686 // this is part of the fix for bug 42372
10688 // Any inline frame might need a view (because of opacity, or fixed background)
10692 // Relatively positioned frames becomes a container for child
10693 // frames that are positioned
10695 }
10697 // Process the child content
10698 nsFrameItems childItems;
10700 childItems);
10702 // Clean up?
10704 }
10709 }
10712 // This part is easy. We either already know we have no non-inline kids,
10713 // or haven't found any when constructing actual frames (the latter can
10714 // happen only if out-of-flows that we thought had no containing block
10715 // acquired one when ancestor inline frames and {ib} splits got
10716 // constructed). Just put all the kids into the single inline frame and
10717 // bail.
10722 }
10724 }
10726 // This inline frame contains several types of children. Therefore this frame
10727 // has to be chopped into several pieces, as described above.
10729 // Grab the first inline's kids
10739 }
10741 void
10744 PRBool aIsPositioned,
10747 {
10752 // Resolve the right style context for our anonymous blocks.
10758 styleContext);
10762 // On entry to this loop aChildItems is not empty and the first frame in it
10763 // is block-level.
10768 // The initial run of blocks belongs to an anonymous block that we create
10769 // right now. The anonymous block will be the parent of these block
10770 // children of the inline.
10775 PR_FALSE);
10777 // Any frame could have a view
10780 // Find the first non-block child which defines the end of our block kids
10781 // and the start of our next inline's kids
10791 // Now grab the initial inlines in aChildItems and put them into an inline
10792 // frame
10796 }
10799 }
10802 PR_FALSE);
10804 // Any frame might need a view
10813 inlineKids);
10814 }
10822 }
10824 void
10827 {
10828 // XXXbz should we preallocate aParentItem.mChildItems to some sane
10829 // length? Maybe even to parentContent->GetChildCount()?
10833 // Probe for generated content before
10844 // Manually check for comments/PIs, since we do't have a frame to pass to
10845 // AddFrameConstructionItems. We know our parent is a non-replaced inline,
10846 // so there is no need to do the NeedFrameFor check.
10852 }
10854 // See comment explaining why we need to remove the "is possible
10855 // restyle root" flags in AddFrameConstructionItems. But note
10856 // that we can remove all restyle flags, just like in
10857 // ProcessChildren and for the same reason.
10859 }
10869 }
10871 // Probe for generated content after
10877 }
10879 // return whether it's ok to append (in the AppendFrames sense) to
10880 // aParentFrame if our nextSibling is aNextSibling. aParentFrame must
10881 // be an {ib} special inline.
10882 static PRBool
10884 {
10892 }
10899 }
10901 PRBool
10906 PRBool aIsAppend,
10908 {
10911 }
10913 // Before we go and append the frames, we must check for several
10914 // special situations.
10916 // Situation #1 is a XUL frame that contains frames that are required
10917 // to be wrapped in blocks.
10923 }
10927 // Situation #2 is a case when table pseudo-frames don't work out right
10929 // If all the kids want a parent of the type that aFrame is, then we're all
10930 // set to go. Indeed, there won't be any table pseudo-frames created between
10931 // aFrame and the kids, so those won't need to be merged with any table
10932 // pseudo-frames that might already be kids of aFrame. If aFrame itself is a
10933 // table pseudo-frame, then all the kids in this list would have wanted a
10934 // frame of that type wrapping them anyway, so putting them inside it is ok.
10936 // Don't give up yet. If parentType is not eTypeBlock and the parent is
10937 // not a generated content frame, then try filtering whitespace out of the
10938 // list.
10940 // For leading whitespace followed by a kid that wants our parent type,
10941 // there are four cases:
10942 // 1) We have a previous sibling which is not a table pseudo. That means
10943 // that previous sibling wanted a (non-block) parent of the type we're
10944 // looking at. Then the whitespace comes between two table-internal
10945 // elements, so should be collapsed out.
10946 // 2) We have a previous sibling which is a table pseudo. It might have
10947 // kids who want this whitespace, so we need to reframe.
10948 // 3) We have no previous sibling and our parent frame is not a table
10949 // pseudo. That means that we'll be at the beginning of our actual
10950 // non-block-type parent, and the whitespace is OK to collapse out.
10951 // If something is ever inserted before us, it'll find our own parent
10952 // as its parent and if it's something that would care about the
10953 // whitespace it'll want a block parent, so it'll trigger a reframe at
10954 // that point.
10955 // 4) We have no previous sibling and our parent frame is a table pseudo.
10956 // Need to reframe.
10957 // All that is predicated on finding the correct previous sibling. We
10958 // might have to walk backwards along continuations from aFrame to do so.
10959 //
10960 // It's always OK to drop whitespace between any two items that want a
10961 // parent of type parentType.
10962 //
10963 // For trailing whitespace preceded by a kid that wants our parent type,
10964 // there are four cases:
10965 // 1) We have a next sibling which is not a table pseudo. That means
10966 // that next sibling wanted a (non-block) parent of the type we're
10967 // looking at. Then the whitespace comes between two table-internal
10968 // elements, so should be collapsed out.
10969 // 2) We have a next sibling which is a table pseudo. It might have
10970 // kids who want this whitespace, so we need to reframe.
10971 // 3) We have no next sibling and our parent frame is not a table
10972 // pseudo. That means that we'll be at the end of our actual
10973 // non-block-type parent, and the whitespace is OK to collapse out.
10974 // If something is ever inserted after us, it'll find our own parent
10975 // as its parent and if it's something that would care about the
10976 // whitespace it'll want a block parent, so it'll trigger a reframe at
10977 // that point.
10978 // 4) We have no next sibling and our parent frame is a table pseudo.
10979 // Need to reframe.
10980 // All that is predicated on finding the correct next sibling. We might
10981 // have to walk forward along continuations from aFrame to do so. That
10982 // said, in the case when nextSibling is null at this point and aIsAppend
10983 // is true, we know we're in case 3. Furthermore, in that case we don't
10984 // even have to worry about the table pseudo situation; we know our
10985 // parent is not a table pseudo there.
10991 }
10993 // iter points to an item that wants a different parent. If it's not
10994 // whitespace, we're done; no more point scanning the list.
10997 }
11000 // Leading whitespace. How to handle this depends on our
11001 // previous sibling and aFrame. See the long comment above.
11004 // Try to find one after all
11010 }
11012 }
11013 };
11016 // need to reframe
11018 }
11020 // need to reframe
11022 }
11023 }
11026 // Advance spaceEndIter past any whitespace
11029 PRBool okToDrop;
11031 // Trailing whitespace. How to handle this depeds on aIsAppend, our
11032 // next sibling and aFrame. See the long comment above.
11036 // Try to find one after all
11042 }
11044 }
11045 }
11049 }
11050 #ifdef DEBUG
11053 }
11054 #endif
11057 }
11062 // We're done: we don't want to drop the whitespace, and it has the
11063 // wrong parent type.
11065 }
11067 // Now loop, since |iter| points to item right after the whitespace we
11068 // removed.
11070 }
11072 // We might be able to figure out some sort of optimizations here, but they
11073 // would have to depend on having a correct aPrevSibling and a correct next
11074 // sibling. For example, we can probably avoid reframing if none of
11075 // aFrame, aPrevSibling, and next sibling are table pseudo-frames. But it
11076 // doesn't seem worth it to worry about that for now, especially since we
11077 // in fact do not have a reliable aPrevSibling, nor any next sibling, in
11078 // this method.
11080 // aItems might have changed, so recheck the parent type thing. In fact,
11081 // it might be empty, so recheck that too.
11084 }
11087 // Reframing aFrame->GetContent() is good enough, since the content of
11088 // table pseudo-frames is the ancestor content.
11091 }
11092 }
11094 // Now we have several cases involving {ib} splits. Put them all in a
11095 // do/while with breaks to take us to the "go and reconstruct" code.
11099 // We can just put the kids in.
11101 }
11104 // Need to go ahead and reconstruct.
11106 }
11108 // Now we're adding kids including some blocks to an inline part of an
11109 // {ib} split. If we plan to call AppendFrames, and don't have a next
11110 // sibling for the new frames, and our parent is the last continuation of
11111 // the last part of the {ib} split, and the same is true of all our
11112 // ancestor inlines (they have no following continuations and they're the
11113 // last part of their {ib} splits and we'd be adding to the end for all
11114 // of them), then AppendFrames will handle things for us. Bail out in
11115 // that case.
11118 }
11120 // Need to reconstruct.
11122 }
11124 // Now we know we have a block parent. If it's not special, we're all set.
11127 }
11129 // We're adding some kids to a block part of an {ib} split. If all the
11130 // kids are blocks, we don't need to reconstruct.
11133 }
11135 // We might have some inline kids for this block. Just reconstruct.
11139 // If we don't have a containing block, start with aFrame and look for one.
11142 }
11144 // To find the right block to reframe, just walk up the tree until we find a
11145 // frame that is:
11146 // 1) Not part of an IB split (not special)
11147 // 2) Not a pseudo-frame
11148 // 3) Not an inline frame
11149 // We're guaranteed to find one, since nsStyleContext::ApplyStyleFixups
11150 // enforces that the root is display:none, display:table, or display:block.
11151 // Note that walking up "too far" is OK in terms of correctness, even if it
11152 // might be a little inefficient. This is why we walk out of all
11153 // pseudo-frames -- telling which ones are or are not OK to walk out of is
11154 // too hard (and I suspect that we do in fact need to walk out of all of
11155 // them).
11160 "Must have non-inline, non-special, non-pseudo frame as root "
11162 }
11164 // Tell parent of the containing block to reformulate the
11165 // entire block. This is painful and definitely not optimal
11166 // but it will *always* get the right answer.
11169 #ifdef DEBUG
11173 }
11174 #endif
11177 }
11179 nsresult
11181 {
11183 #ifdef DEBUG
11184 // ReframeContainingBlock is a NASTY routine, it causes terrible performance problems
11185 // so I want to see when it is happening! Unfortunately, it is happening way to often because
11186 // so much content on the web causes 'special' block-in-inline frame situations and we handle them
11187 // very poorly
11191 }
11192 #endif
11194 // XXXbz how exactly would we get here while isReflowing anyway? Should this
11195 // whole test be ifdef DEBUG?
11197 // don't ReframeContainingBlock, this will result in a crash
11198 // if we remove a tree that's in reflow - see bug 121368 for testcase
11201 }
11203 // Get the first "normal" ancestor of the target frame.
11206 // From here we look for the containing block in case the target
11207 // frame is already a block (which can happen when an inline frame
11208 // wraps some of its content in an anonymous block; see
11209 // ConstructInline)
11211 // NOTE: We used to get the FloatContainingBlock here, but it was often wrong.
11212 // GetIBContainingBlock works much better and provides the correct container in all cases
11213 // so GetFloatContainingBlock(aFrame) has been removed
11215 // And get the containingBlock's content
11218 #ifdef DEBUG
11221 }
11222 #endif
11224 }
11225 }
11227 // If we get here, we're screwed!
11229 PR_TRUE);
11230 }
11232 void
11234 {
11235 // In some cases (:empty + E, :empty ~ E), a change if the content of
11236 // an element requires restyling its parent's siblings.
11242 }
11244 }
11246 void
11249 {
11251 #ifdef DEBUG
11252 {
11256 }
11257 }
11258 #endif
11259 PRUint32 selectorFlags =
11266 // see whether we need to restyle the container
11271 // We don't know whether we're testing :empty or :-moz-only-whitespace,
11272 // so be conservative and assume :-moz-only-whitespace (i.e., make
11273 // IsSignificantChild less likely to be true, and thus make us more
11274 // likely to restyle).
11278 }
11279 }
11283 }
11284 }
11288 // Restyling the container is the most we can do here, so we're done.
11290 }
11293 // restyle the last element child before this node
11295 cur;
11300 }
11301 }
11302 }
11303 }
11305 // Needed since we can't use PostRestyleEvent on non-elements (with
11306 // eRestyle_LaterSiblings or nsRestyleHint(eRestyle_Subtree |
11307 // eRestyle_LaterSiblings) as appropriate).
11308 static void
11311 {
11315 aFrameConstructor->
11318 NS_STYLE_HINT_NONE);
11320 }
11321 }
11322 }
11324 // Restyling for a ContentInserted or CharacterDataChanged notification.
11325 // This could be used for ContentRemoved as well if we got the
11326 // notification before the removal happened (and sometimes
11327 // CharacterDataChanged is more like a removal than an addition).
11328 // The comments are written and variables are named in terms of it being
11329 // a ContentInserted notification.
11330 void
11333 {
11336 PRUint32 selectorFlags =
11342 // see whether we need to restyle the container
11345 child;
11349 // We don't know whether we're testing :empty or :-moz-only-whitespace,
11350 // so be conservative and assume :-moz-only-whitespace (i.e., make
11351 // IsSignificantChild less likely to be true, and thus make us more
11352 // likely to restyle).
11356 }
11357 }
11361 }
11362 }
11366 // Restyling the container is the most we can do here, so we're done.
11368 }
11371 // Restyle all later siblings.
11373 }
11376 // restyle the previously-first element child if it is after this node
11379 content;
11384 }
11388 NS_STYLE_HINT_NONE);
11389 }
11391 }
11392 }
11393 // restyle the previously-last element child if it is before this node
11396 content;
11401 }
11405 NS_STYLE_HINT_NONE);
11406 }
11408 }
11409 }
11410 }
11411 }
11413 void
11417 {
11420 PRUint32 selectorFlags =
11426 // see whether we need to restyle the container
11429 child;
11431 // We don't know whether we're testing :empty or :-moz-only-whitespace,
11432 // so be conservative and assume :-moz-only-whitespace (i.e., make
11433 // IsSignificantChild less likely to be true, and thus make us more
11434 // likely to restyle).
11438 }
11439 }
11443 }
11444 }
11448 // Restyling the container is the most we can do here, so we're done.
11450 }
11453 // Restyle all later siblings.
11455 }
11458 // restyle the now-first element child if it was after aOldChild
11461 content;
11465 // do NOT continue here; we might want to restyle this node
11466 }
11470 NS_STYLE_HINT_NONE);
11471 }
11473 }
11474 }
11475 // restyle the now-last element child if it was before aOldChild
11478 content;
11483 }
11485 }
11488 }
11489 }
11490 }
11491 }
11494 void
11496 {
11498 "Should not reconstruct the root of the frame tree. "
11508 // Make sure that the viewmanager will outlive the presshell
11511 // Processing the style changes could cause a flush that propagates to
11512 // the parent frame and thus destroys the pres shell.
11515 // We may reconstruct frames below and hence process anything that is in the
11516 // tree. We don't want to get notified to process those items again after.
11519 nsAutoScriptBlocker scriptBlocker;
11521 // Tell the style set to get the old rule tree out of the way
11522 // so we can recalculate while maintaining rule tree immutability
11527 }
11529 // Recalculate all of the style contexts for the document
11530 // Note that we can ignore the return value of ComputeStyleChangeFor
11531 // because we never need to reframe the root frame
11532 // XXX This could be made faster by not rerunning rule matching
11533 // (but note that nsPresShell::SetPreferenceStyleRules currently depends
11534 // on us re-running rule matching here
11535 nsStyleChangeList changeList;
11536 // XXX Does it matter that we're passing aExtraHint to the real root
11537 // frame and not the root node's primary frame?
11538 // Note: The restyle tracker we pass in here doesn't matter.
11542 // Process the required changes
11544 // Tell the style set it's safe to destroy the old rule tree. We
11545 // must do this after the ProcessRestyledFrames call in case the
11546 // change list has frame reconstructs in it (since frames to be
11547 // reconstructed will still have their old style context pointers
11548 // until they are destroyed).
11551 }
11553 void
11555 {
11560 // Process non-animation restyles...
11568 #ifdef DEBUG
11570 #endif
11572 // ...and then process animation restyles. This needs to happen
11573 // second because we need to start animations that resulted from the
11574 // first set of restyles (e.g., CSS transitions with negative
11575 // transition-delay), and because we need to immediately
11576 // restyle-with-animation any just-restyled elements that are
11577 // mid-transition (since processing the non-animation restyle ignores
11578 // the running transition so it can check for a new change on the same
11579 // property, and then posts an immediate animation style change).
11586 "We should not have posted new non-animation restyles while "
11590 // We probably wasted a lot of work up above, but this seems safest
11591 // and it should be rarely used.
11592 // This might add us as a refresh observer again; that's ok.
11594 }
11595 }
11597 void
11599 nsRestyleHint aRestyleHint,
11600 nsChangeHint aMinChangeHint,
11601 PRBool aForAnimation)
11602 {
11605 }
11608 // Nothing to do here
11610 }
11617 }
11619 void
11621 {
11622 // Make sure we're not in a style refresh; if we are, we still have
11623 // a call to ProcessPendingRestyles coming and there's no need to
11624 // add ourselves as a refresh observer until then.
11629 }
11630 }
11632 void
11634 {
11636 "Should not reconstruct the root of the frame tree. "
11641 // Get a restyle event posted if necessary
11643 }
11645 nsresult
11647 {
11648 {
11649 nsAutoScriptBlocker scriptBlocker;
11652 nsFrameItems childItems;
11654 // We don't have a parent frame with a pending binding constructor here,
11655 // so no need to worry about ordering of the kids' constructors with it.
11656 // Pass null for the PendingBinding.
11659 nsnull);
11663 }
11668 }
11670 // call XBL constructors after the frames are created
11674 }
11676 //////////////////////////////////////////////////////////
11677 // nsCSSFrameConstructor::FrameConstructionItem methods //
11678 //////////////////////////////////////////////////////////
11679 PRBool
11682 {
11687 }
11689 NS_REFRAME_IF_WHITESPACE);
11691 }
11693 //////////////////////////////////////////////////////////////
11694 // nsCSSFrameConstructor::FrameConstructionItemList methods //
11695 //////////////////////////////////////////////////////////////
11696 void
11699 {
11704 }
11707 }
11710 }
11712 }
11714 ////////////////////////////////////////////////////////////////////////
11715 // nsCSSFrameConstructor::FrameConstructionItemList::Iterator methods //
11716 ////////////////////////////////////////////////////////////////////////
11717 inline PRBool
11720 {
11726 }
11727 }
11729 }
11731 inline PRBool
11734 {
11741 }
11745 }
11747 void
11750 {
11761 }
11763 void
11767 {
11776 }
11778 // move over the list of items
11782 // Copy over the various counters
11790 // reset mList
11793 // Point ourselves to aEnd, as advertised
11796 }
11798 void
11801 {
11802 // Just insert the item before us. There's no magic here.
11807 }
11809 void
11812 {
11824 }