| blob | f6ed4e4f3ee18e6f8b10ce051932dfd03a9d0d33 |
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
133 #endif
142 #undef NOISY_FIRST_LETTER
144 #ifdef MOZ_MATHML
146 #endif
147 #ifdef MOZ_SVG
152 #endif
159 nsIFrame*
162 #if defined(MOZ_MEDIA)
163 nsIFrame*
165 #endif
167 #ifdef MOZ_SVG
170 PRBool
172 nsIFrame*
174 nsIFrame*
176 nsIFrame*
178 nsIFrame*
180 nsIFrame*
182 nsIFrame*
184 nsIFrame*
186 nsIFrame*
188 nsIFrame*
190 nsIFrame*
192 nsIFrame*
194 nsIFrame*
196 nsIFrame*
204 nsIFrame*
208 nsIFrame*
210 nsIFrame*
212 nsIFrame*
214 nsIFrame*
216 nsIFrame*
218 nsIFrame*
220 #endif
235 // Global object maintenance
238 #ifdef DEBUG
239 // Set the environment variable GECKO_FRAMECTOR_DEBUG_FLAGS to one or
240 // more of the following flags (comma separated) for handy debug
241 // output.
249 };
255 };
257 #define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
258 #endif
261 #ifdef MOZ_XUL
272 //------------------------------------------------------------------
274 nsIFrame*
277 nsIFrame*
280 nsIFrame*
283 nsIFrame*
286 nsIFrame*
289 nsIFrame*
292 nsIFrame*
295 nsIFrame*
298 nsIFrame*
301 nsIFrame*
304 nsIFrame*
307 nsIFrame*
310 nsIFrame*
313 nsIFrame*
316 nsIFrame*
319 nsIFrame*
322 nsIFrame*
325 nsIFrame*
328 // grid
329 nsresult
331 nsIFrame*
333 nsIFrame*
336 // end grid
338 nsIFrame*
341 nsIFrame*
345 #endif
347 nsIFrame*
350 nsIFrame*
353 nsIFrame*
356 nsIFrame*
359 nsIFrame*
363 #ifdef NOISY_FINDFRAME
369 #endif
373 {
374 // Depends on the fieldset child frame order - see ConstructFieldSetFrame() below.
377 }
379 #define FCDATA_DECL(_flags, _func) \
380 { _flags, { (FrameCreationFunc)_func } }
382 //----------------------------------------------------------------------
384 static PRBool
386 {
388 }
390 /**
391 * True if aFrame is an actual inline frame in the sense of non-replaced
392 * display:inline CSS boxes. In other words, it can be affected by {ib}
393 * splitting and can contain first-letter frames. Basically, this is either an
394 * inline frame (positioned or otherwise) or an line frame (this last because
395 * it can contain first-letter and because inserting blocks in the middle of it
396 * needs to terminate it).
397 */
398 static PRBool
400 {
402 }
404 /**
405 * If any children require a block parent, return the first such child.
406 * Otherwise return null.
407 */
410 {
412 // Line participants, such as text and inline frames, can't be
413 // directly inside a XUL box; they must be wrapped in an
414 // intermediate block.
417 }
418 }
420 }
422 // Reparent a frame into a wrapper frame that is a child of its old parent.
423 static void
427 {
430 }
432 static void
436 {
439 }
440 }
442 //----------------------------------------------------------------------
443 //
444 // When inline frames get weird and have block frames in them, we
445 // annotate them to help us respond to incremental content changes
446 // more easily.
450 {
452 }
455 {
458 // We only store the "special sibling" annotation with the first
459 // frame in the continuation chain. Walk back to find that frame now.
463 }
466 {
469 // We only store the "special sibling" annotation with the first
470 // frame in the continuation chain. Walk back to find that frame now.
474 }
478 {
487 }
488 }
491 }
493 static void
495 {
498 // We should be the only continuation
505 // Mark the frame as "special".
510 "assigning something other than the first continuation as the "
513 // Store the "special sibling" (if we were given one) with the
514 // first frame in the flow.
518 }
519 }
523 {
527 // Get the first "normal" ancestor of the target frame.
535 }
537 // Note that we ignore non-special frames which have a pseudo on their
538 // style context -- they're not the frames we're looking for! In
539 // particular, they may be hiding a real parent that _is_ special.
547 // post-conditions
548 NS_ASSERTION(parentFrame, "no normal ancestor found for special frame in GetIBContainingBlockFor");
552 }
554 //----------------------------------------------------------------------
556 // Block/inline frame construction logic. We maintain a few invariants here:
557 //
558 // 1. Block frames contain block and inline frames.
559 //
560 // 2. Inline frames only contain inline frames. If an inline parent has a block
561 // child then the block child is migrated upward until it lands in a block
562 // parent (the inline frames containing block is where it will end up).
564 // After this function returns, aLink is pointing to the first link at or
565 // after its starting position for which the next frame is a block. If there
566 // is no such link, it points to the end of the list.
567 static void
569 {
573 }
574 }
575 }
577 // This function returns a frame link enumerator pointing to the first link in
578 // the list for which the next frame is not block. If there is no such link,
579 // it points to the end of the list.
582 {
587 }
588 }
590 }
594 {
598 }
600 // -----------------------------------------------------------
602 // Structure used when constructing formatting object trees.
604 {
605 // Appends the frame to the end of the list
607 };
609 void
611 {
614 // It'd be really nice if we could just AppendFrames(nsnull, aChild) here,
615 // but some of our callers put frames that have different
616 // parents (caption, I'm looking at you) on the same framelist, and
617 // nsFrameList asserts if you try to do that.
620 }
626 }
627 }
629 // -----------------------------------------------------------
631 // Structure used when constructing formatting object trees. Contains
632 // state information needed for absolutely positioned elements
634 // containing block for absolutely positioned elements
638 #ifdef DEBUG
639 // XXXbz Does this need a debug-only assignment operator that nulls out the
640 // childList in the nsAbsoluteItems we're copying? Introducing a difference
641 // between debug and non-debug behavior seems bad, so I guess not...
645 }
646 #endif
648 // Appends the frame to the end of the list
650 };
654 {
655 }
657 // Additional behavior is that it sets the frame's NS_FRAME_OUT_OF_FLOW flag
658 void
660 {
666 }
668 // -----------------------------------------------------------
670 // Structure for saving the existing state when pushing/poping containing
671 // blocks. The destructor restores the state to its previous state
682 PRPackedBool mSavedFixedPosIsAbsPos;
684 // The name of the child list in which our frames would belong
689 };
691 // Structure used to keep track of a list of bindings we need to call
692 // AddToAttachedQueue on. These should be in post-order depth-first
693 // flattened tree traversal order.
695 {
696 #ifdef NS_BUILD_REFCNT_LOGGING
699 }
702 }
703 #endif
706 };
708 // Structure used for maintaining state information during the
709 // frame construction process
716 #ifdef MOZ_XUL
717 // Frames destined for the nsGkAtoms::popupList.
718 nsAbsoluteItems mPopupItems;
719 #endif
721 // Containing block information for out-of-flow frames.
722 nsAbsoluteItems mFixedItems;
723 nsAbsoluteItems mAbsoluteItems;
724 nsAbsoluteItems mFloatedItems;
727 // These bits will be added to the state bits of any frame we construct
728 // using this state.
729 nsFrameState mAdditionalStateBits;
731 // When working with the -moz-transform property, we want to hook
732 // the abs-pos and fixed-pos lists together, since transformed
733 // elements are fixed-pos containing blocks. This flag determines
734 // whether or not we want to wire the fixed-pos and abs-pos lists
735 // together.
736 PRPackedBool mFixedPosIsAbsPos;
738 // A boolean to indicate whether we have a "pending" popupgroup. That is, we
739 // have already created the FrameConstructionItem for the root popupgroup but
740 // we have not yet created the relevant frame.
741 PRPackedBool mHavePendingPopupgroup;
743 // If false (which is the default) then call SetPrimaryFrame() as needed
744 // during frame construction. If true, don't make any SetPrimaryFrame()
745 // calls. The mCreatingExtraFrames == PR_TRUE mode is meant to be used for
746 // construction of random "extra" frames for elements via normal frame
747 // construction APIs (e.g. replication of things across pages in paginated
748 // mode).
749 PRPackedBool mCreatingExtraFrames;
753 // Constructor
754 // Use the passed-in history state.
760 // Get the history state from the pres context's pres shell.
768 // Function to push the existing absolute containing block state and
769 // create a new scope. Code that uses this function should get matching
770 // logic in GetAbsoluteContainingBlock.
774 // Function to push the existing float containing block state and
775 // create a new scope. Code that uses this function should get matching
776 // logic in GetFloatContainingBlock.
777 // Pushing a null float containing block forbids any frames from being
778 // floated until a new float containing block is pushed.
779 // XXX we should get rid of null float containing blocks and teach the
780 // various frame classes to deal with floats instead.
784 // Function to return the proper geometric parent for a frame with display
785 // struct given by aStyleDisplay and parent's frame given by
786 // aContentParentFrame.
790 /**
791 * Function to add a new frame to the right frame list. This MUST be called
792 * on frames before their children have been processed if the frames might
793 * conceivably be out-of-flow; otherwise cleanup in error cases won't work
794 * right. Also, this MUST be called on frames after they have been
795 * initialized.
796 * @param aNewFrame the frame to add
797 * @param aFrameItems the list to add in-flow frames to
798 * @param aContent the content pointer for aNewFrame
799 * @param aStyleContext the style context resolved for aContent
800 * @param aParentFrame the parent frame for the content if it were in-flow
801 * @param aCanBePositioned pass false if the frame isn't allowed to be
802 * positioned
803 * @param aCanBeFloated pass false if the frame isn't allowed to be
804 * floated
805 * @param aIsOutOfFlowPopup pass true if the frame is an out-of-flow popup
806 * (XUL-only)
807 * @throws NS_ERROR_OUT_OF_MEMORY if it happens.
808 * @note If this method throws, that means that aNewFrame was not inserted
809 * into any frame lists. Furthermore, this method will handle cleanup
810 * of aNewFrame (via calling Destroy() on it).
811 */
823 /**
824 * Function to return the fixed-pos element list. Normally this will just hand back the
825 * fixed-pos element list, but in case we're dealing with a transformed element that's
826 * acting as an abs-pos and fixed-pos container, we'll hand back the abs-pos list. Callers should
827 * use this function if they want to get the list acting as the fixed-pos item parent.
828 */
830 {
832 }
834 {
836 }
839 /**
840 * class to automatically push and pop a pending binding in the frame
841 * constructor state. See nsCSSFrameConstructor::FrameConstructionItem
842 * mPendingBinding documentation.
843 */
852 {
856 }
857 }
860 {
862 }
867 };
869 /**
870 * Add a new pending binding to the list
871 */
874 }
879 /**
880 * ProcessFrameInsertions takes the frames in aFrameItems and adds them as
881 * kids to the aChildListName child list of |aFrameItems.containingBlock|.
882 */
886 // Our list of all pending bindings. When we're done, we need to call
887 // AddToAttachedQueue on all of them, in order.
888 PRCList mPendingBindings;
891 };
901 #ifdef MOZ_XUL
903 #endif
907 // See PushAbsoluteContaningBlock below
916 {
917 #ifdef MOZ_XUL
921 }
922 #endif
925 }
934 #ifdef MOZ_XUL
936 #endif
940 // See PushAbsoluteContaningBlock below
948 {
949 #ifdef MOZ_XUL
953 }
954 #endif
958 }
961 {
962 // Frame order comparison functions only work properly when the placeholders
963 // have been inserted into the frame tree. So for example if we have a new float
964 // containing the placeholder for a new abs-pos frame, and we process the abs-pos
965 // insertion first, then we won't be able to find the right place to insert in
966 // in the abs-pos list. So put floats in first, because they can contain placeholders
967 // for abs-pos and fixed-pos items whose containing blocks are outside the floats.
968 // Then put abs-pos frames in, because they can contain placeholders for fixed-pos
969 // items whose containing block is outside the abs-pos frames.
974 #ifdef MOZ_XUL
976 #endif
980 }
990 }
991 }
995 {
998 }
1000 // Always use the container's first continuation. (Inline frames can have
1001 // non-fluid bidi continuations...)
1003 }
1005 void
1008 {
1014 /* Store whether we're wiring the abs-pos and fixed-pos lists together. */
1018 mAbsoluteItems =
1021 /* See if we're wiring the fixed-pos and abs-pos lists together. This happens iff
1022 * we're a transformed element.
1023 */
1026 }
1028 void
1031 {
1040 }
1042 nsIFrame*
1045 {
1048 // If there is no container for a fixed, absolute, or floating root
1049 // frame, we will ignore the positioning. This hack is originally
1050 // brought to you by the letter T: tables, since other roots don't
1051 // even call into this code. See bug 178855.
1052 //
1053 // XXX Disabling positioning in this case is a hack. If one was so inclined,
1054 // one could support this either by (1) inserting a dummy block between the
1055 // table and the canvas or (2) teaching the canvas how to reflow positioned
1056 // elements. (1) has the usual problems when multiple frames share the same
1057 // content (notice all the special cases in this file dealing with inner
1058 // tables and outer tables which share the same content). (2) requires some
1059 // work and possible factoring.
1060 //
1061 // XXXbz couldn't we just force position to "static" on roots and
1062 // float to "none"? That's OK per CSS 2.1, as far as I can tell.
1068 }
1073 }
1078 }
1081 }
1083 nsresult
1089 PRBool aCanBePositioned,
1090 PRBool aCanBeFloated,
1091 PRBool aIsOutOfFlowPopup,
1092 PRBool aInsertAfter,
1094 {
1099 // The comments in GetGeometricParent regarding root table frames
1100 // all apply here, unfortunately.
1103 nsFrameState placeholderType;
1105 #ifdef MOZ_XUL
1113 }
1114 else
1123 }
1132 }
1140 }
1141 }
1147 nsresult rv =
1149 aContent,
1150 aNewFrame,
1151 aStyleContext,
1152 aParentFrame,
1153 nsnull,
1154 placeholderType,
1157 // Note that aNewFrame could be the top frame for a scrollframe setup,
1158 // hence already set as the primary frame. So we have to clean up here.
1159 // But it shouldn't have any out-of-flow kids.
1160 // XXXbz Maybe add a utility function to assert that?
1163 }
1166 // Add the placeholder frame to the flow
1168 }
1169 #ifdef DEBUG
1173 }
1174 #endif
1180 }
1183 }
1185 void
1188 {
1189 #define NS_NONXUL_LIST_TEST (&aFrameItems == &mFloatedItems && \
1190 aChildListName == nsGkAtoms::floatList) || \
1191 (&aFrameItems == &mAbsoluteItems && \
1192 aChildListName == nsGkAtoms::absoluteList) || \
1193 (&aFrameItems == &mFixedItems && \
1194 aChildListName == nsGkAtoms::fixedList)
1195 #ifdef MOZ_XUL
1200 #else
1203 #endif
1207 }
1214 // Insert the frames hanging out in aItems. We can use SetInitialChildList()
1215 // if the containing block hasn't been reflowed yet (so NS_FRAME_FIRST_REFLOW
1216 // is set) and doesn't have any frames in the aChildListName child list yet.
1223 // Note that whether the frame construction context is doing an append or
1224 // not is not helpful here, since it could be appending to some frame in
1225 // the middle of the document, which means we're not necessarily
1226 // appending to the children of the containing block.
1227 //
1228 // We need to make sure the 'append to the end of document' case is fast.
1229 // So first test the last child of the containing block
1232 // CompareTreePosition uses placeholder hierarchy for out of flow frames,
1233 // so this will make out-of-flows respect the ordering of placeholders,
1234 // which is great because it takes care of anonymous content.
1238 // no lastChild, or lastChild comes before the new children, so just append
1241 // try the other children
1245 PRInt32 compare =
1248 // f comes after the new children, so stop here and insert after
1249 // the previous frame
1251 }
1253 }
1255 aFrameItems);
1256 }
1257 }
1261 // XXXbz And if NS_FAILED(rv), what? I guess we need to clean up the list
1262 // and deal with all the placeholders... but what if the placeholders aren't
1263 // in the document yet? Could that happen?
1265 }
1275 {
1276 }
1279 {
1280 // Restore the state
1285 #ifdef DEBUG
1286 // We've transferred the child list, so drop the pointer we held to it.
1287 // Note that this only matters for the assert in ~nsAbsoluteItems.
1289 #endif
1290 }
1293 }
1294 }
1296 static
1298 {
1302 }
1303 }
1306 }
1308 /**
1309 * Moves aFrameList from aOldParent to aNewParent. This updates the parent
1310 * pointer of the frames in the list, and reparents their views as needed.
1311 * nsFrame::SetParent sets the NS_FRAME_HAS_VIEW bit on aNewParent and its
1312 * ancestors as needed. Then it sets the list as the initial child list
1313 * on aNewParent, unless aNewParent either already has kids or has been
1314 * reflowed; in that case it appends the new frames. Note that this
1315 * method differs from ReparentFrames in that it doesn't change the kids'
1316 * style contexts.
1317 */
1318 // XXXbz Since this is only used for {ib} splits, could we just copy the view
1319 // bits from aOldParent to aNewParent and then use the
1320 // nsFrameList::ApplySetParent? That would still leave us doing two passes
1321 // over the list, of course; if we really wanted to we could factor out the
1322 // relevant part of ReparentFrameViewList, I suppose... Or just get rid of
1323 // views, which would make most of this function go away.
1324 static void
1329 {
1333 // Move the frames into the new view
1336 }
1340 }
1347 }
1348 }
1350 //----------------------------------------------------------------------
1376 {
1377 // XXXbz this should be in Init() or something!
1379 // now what?
1380 }
1382 #ifdef DEBUG
1403 }
1405 }
1415 }
1424 }
1427 }
1428 }
1429 }
1430 #endif
1431 }
1434 {
1439 }
1442 }
1444 void
1446 {
1453 }
1456 // Technically we don't need to update anything if we destroyed only
1457 // USE nodes. However, this is unlikely to happen in the real world
1458 // since USE nodes generally go along with INCREMENT nodes.
1460 }
1461 }
1471 };
1473 static void
1478 {
1480 }
1487 {
1491 // XXX The quotes/counters code doesn't like the text pointer
1492 // being null in case of dynamic changes!
1495 }
1499 }
1502 DestroyGenConInitializer);
1504 }
1506 }
1512 PRUint32 aContentIndex)
1513 {
1514 // Get the content value
1521 // CSS had something specified that couldn't be converted to an
1522 // image object
1524 }
1526 // Create an image content object and pass it the image request.
1527 // XXX Check if it's an image type we can handle...
1530 nodeInfo = mDocument->NodeInfoManager()->GetNodeInfo(nsGkAtoms::mozgeneratedcontentimage, nsnull,
1531 kNameSpaceID_XHTML);
1537 }
1546 {
1553 nsAutoString nameSpaceVal;
1555 PRInt32 error;
1561 }
1563 }
1564 }
1568 }
1570 }
1574 }
1580 }
1584 {
1601 initializer);
1602 }
1612 {
1622 initializer);
1623 }
1626 {
1627 // Use the "alt" attribute; if that fails and the node is an HTML
1628 // <input>, try the value attribute and then fall back to some default
1629 // localized text we have.
1630 // XXX what if the 'alt' attribute is added later, how will we
1631 // detect that and do the right thing here?
1637 }
1646 }
1648 nsXPIDLString temp;
1652 }
1655 }
1659 }
1661 /*
1662 * aParentFrame - the frame that should be the parent of the generated
1663 * content. This is the frame for the corresponding content node,
1664 * which must not be a leaf frame.
1665 *
1666 * Any items created are added to aItems.
1667 *
1668 * We create an XML element (tag _moz_generated_content_before or
1669 * _moz_generated_content_after) representing the pseudoelement. We
1670 * create a DOM node for each 'content' item and make those nodes the
1671 * children of the XML element. Then we create a frame subtree for
1672 * the XML element as if it were a regular child of
1673 * aParentFrame/aParentContent, giving the XML element the ::before or
1674 * ::after style.
1675 */
1676 void
1683 {
1684 // XXXbz is this ever true?
1688 }
1692 // Probe for the existence of the pseudo-element
1694 pseudoStyleContext =
1696 aPseudoElement,
1697 aStyleContext);
1700 // |ProbePseudoStyleFor| checked the 'display' property and the
1701 // |ContentCount()| of the 'content' property for us.
1706 kNameSpaceID_None);
1717 }
1723 contentIndex);
1726 }
1727 }
1731 pseudoStyleContext,
1733 }
1735 /****************************************************
1736 ** BEGIN TABLE SECTION
1737 ****************************************************/
1739 // The term pseudo frame is being used instead of anonymous frame, since anonymous
1740 // frame has been used elsewhere to refer to frames that have generated content
1742 static PRBool
1744 {
1745 return
1754 }
1756 // Return whether the given frame is a table pseudo-frame. Note that
1757 // cell-content and table-outer frames have pseudo-types, but are always
1758 // created, even for non-anonymous cells and tables respectively. So for those
1759 // we have to examine the cell or table frame to see whether it's a pseudo
1760 // frame. In particular, a lone table caption will have an outer table as its
1761 // parent, but will also trigger construction of an empty inner table, which
1762 // will be the one we can examine to see whether the outer was a pseudo-frame.
1763 static PRBool
1765 {
1782 }
1784 /* static */
1787 {
1790 }
1793 }
1796 }
1799 }
1802 }
1806 {
1809 }
1811 }
1813 /**
1814 * If the parent frame is a |tableFrame| and the child is a
1815 * |captionFrame|, then we want to insert the frames beneath the
1816 * |tableFrame|'s parent frame. Returns |PR_TRUE| if the parent frame
1817 * needed to be fixed up.
1818 */
1819 static PRBool
1823 {
1830 }
1832 }
1834 void
1838 {
1845 NS_STYLE_DISPLAY_TABLE_CAPTION) {
1847 }
1848 }
1850 // Pull all the captions present in aItems out into aCaptions
1851 static void
1853 {
1860 }
1862 }
1863 }
1866 // Construct the outer, inner table frames and the children frames for the table.
1867 // XXX Page break frames for pseudo table frames are not constructed to avoid the risk
1868 // associated with revising the pseudo frame mechanism. The long term solution
1869 // of having frames handle page-break-before/after will solve the problem.
1870 nsresult
1877 {
1888 // create the pseudo SC for the outer table as a child of the inner SC
1893 // Create the outer table frame which holds the caption and inner table frame
1895 #ifdef MOZ_MATHML
1898 else
1899 #endif
1904 aParentFrame);
1906 // Init the table outer frame and see if we need to create a view, e.g.
1907 // the frame is absolutely positioned
1911 // Create the inner table frame
1913 #ifdef MOZ_MATHML
1916 else
1917 #endif
1922 // Put the newly created frames into the right child list
1926 aParentFrame);
1929 }
1932 // The frame we're constructing will be the root element frame.
1933 // Set mRootElementFrame before processing children.
1935 }
1937 nsFrameItems childItems;
1944 }
1945 // XXXbz what about cleaning up?
1948 nsFrameItems captionItems;
1951 // Set the inner table frame's initial primary list
1954 // Set the outer table frame's secondary childlist lists
1957 }
1961 }
1963 nsresult
1970 {
1978 #ifdef MOZ_MATHML
1981 else
1982 #endif
1987 }
1991 nsFrameItems childItems;
1992 nsresult rv;
1995 childItems);
1999 }
2007 }
2009 nsresult
2016 {
2023 }
2032 // construct additional col frames if the col frame has a span > 1
2038 }
2040 PR_FALSE);
2045 }
2048 }
2050 nsresult
2057 {
2067 #ifdef MOZ_MATHML
2068 // <mtable> is border separate in mathml.css and the MathML code doesn't implement
2069 // border collapse. For those users who style <mtable> with border collapse,
2070 // give them the default non-MathML table frames that understand border collapse.
2071 // This won't break us because MathML table frames are all subclasses of the default
2072 // table code, and so we can freely mix <mtable> with <mtr> or <tr>, <mtd> or <td>.
2073 // What will happen is just that non-MathML frames won't understand MathML attributes
2074 // and will therefore miss the special handling that the MathML code does.
2077 else
2078 #endif
2079 // Warning: If you change this and add a wrapper frame around table cell
2080 // frames, make sure Bug 368554 doesn't regress!
2081 // See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.
2086 }
2088 // Initialize the table cell frame
2092 // Resolve pseudo style and initialize the body cell frame
2097 // Create a block frame that will format the cell's content
2098 PRBool isBlock;
2100 #ifdef MOZ_MATHML
2104 }
2105 else
2106 #endif
2107 {
2110 }
2115 }
2119 nsFrameItems childItems;
2120 nsresult rv;
2122 // Need to push ourselves as a float containing block.
2123 // XXXbz it might be nice to work on getting the parent
2124 // FrameConstructionItem down into ProcessChildren and just making use of
2125 // the push there, but that's a bit of work.
2126 nsFrameConstructorSaveState floatSaveState;
2131 }
2134 childItems);
2136 // Process the child content
2139 }
2142 // Clean up
2143 // XXXbz kids of this stuff need to be cleaned up too!
2147 }
2155 }
2161 {
2162 // XXX the GetContent() != aChildContent check is needed due to bug 135040.
2163 // Remove it once that's fixed.
2169 // don't create a whitespace frame if aParentFrame doesn't want it.
2170 // always create frames for children in generated content. counter(),
2171 // quotes, and attr() content can easily change dynamically and we don't
2172 // want to be reconstructing frames. It's not even clear that these
2173 // should be considered ignorable just because they evaluate to
2174 // whitespace.
2176 // We could handle all this in CreateNeededTablePseudos or some other place
2177 // after we build our frame construction items, but that would involve
2178 // creating frame construction items for whitespace kids of
2179 // eExcludesIgnorableWhitespace frames, where we know we'll be dropping them
2180 // all anyway, and involve an extra walk down the frame construction item
2181 // list.
2186 }
2189 NS_REFRAME_IF_WHITESPACE);
2191 }
2193 /***********************************************
2194 * END TABLE SECTION
2195 ***********************************************/
2199 {
2205 NS_STYLE_OVERFLOW_HIDDEN);
2206 else
2210 }
2212 /**
2213 * This checks the root element and the HTML BODY, if any, for an "overflow" property
2214 * that should be applied to the viewport. If one is found then we return the
2215 * element that we took the overflow from (which should then be treated as
2216 * "overflow:visible"), and we store the overflow style in the prescontext.
2217 * @return if scroll was propagated from some content node, the content node it
2218 * was propagated from.
2219 */
2220 nsIContent*
2222 {
2223 // Set default
2226 NS_STYLE_OVERFLOW_AUTO);
2228 // We never mess with the viewport scroll state
2229 // when printing or in print preview
2232 }
2236 // Check the style on the document root element
2242 }
2244 // tell caller we stole the overflow style from the root element
2246 }
2248 // Don't look in the BODY for non-HTML documents or HTML documents
2249 // with non-HTML roots
2250 // XXX this should be earlier; we shouldn't even look at the document root
2251 // for non-HTML documents. Fix this once we support explicit CSS styling
2252 // of the viewport
2253 // XXX what about XHTML?
2257 }
2265 // The body is not a <body> tag, it's a <frameset>.
2267 }
2273 }
2276 // tell caller we stole the overflow style from the body element
2278 }
2281 }
2283 nsresult
2287 {
2297 // Make sure to call PropagateScrollToViewport before
2298 // SetUpDocElementContainingBlock, since it sets up our scrollbar state
2299 // properly.
2309 // XXXbz why, exactly?
2313 // Make sure that we'll handle restyles for this document element in
2314 // the future. We need this, because the document element might
2315 // have stale restyle bits from a previous frame constructor for
2316 // this document. Unlike in AddFrameConstructionItems, it's safe to
2317 // unset all element restyle flags, since we don't have any
2318 // siblings.
2321 // --------- CREATE AREA OR BOX FRAME -------
2324 nsnull);
2328 // Ensure that our XBL bindings are installed.
2330 // Get the XBL loader.
2331 nsresult rv;
2332 PRBool resolveStyle;
2347 // For backwards compat, keep firing the root's constructor
2348 // after all of its kids' constructors. So tell the binding
2349 // manager about it right now.
2351 }
2355 nsnull);
2357 }
2358 }
2360 // --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------
2362 #ifdef DEBUG
2367 #endif
2372 }
2374 nsFrameConstructorSaveState absoluteSaveState;
2376 // Push the absolute containing block now so we can absolutely position
2377 // the root element
2379 absoluteSaveState);
2380 }
2382 nsresult rv;
2384 // The rules from CSS 2.1, section 9.2.4, have already been applied
2385 // by the style system, so we can assume that display->mDisplay is
2386 // either NONE, BLOCK, or TABLE.
2388 // contentFrame is the primary frame for the root element. *aNewFrame
2389 // is the frame that will be the child of the initial containing block.
2390 // These are usually the same frame but they can be different, in
2391 // particular if the root frame is positioned, in which case
2392 // contentFrame is the out-of-flow frame and *aNewFrame is the
2393 // placeholder.
2397 // Check whether we need to build a XUL box or SVG root frame
2398 #ifdef MOZ_XUL
2403 }
2405 contentFrame);
2408 }
2409 else
2410 #endif
2411 #ifdef MOZ_SVG
2417 }
2420 mDocElementContainingBlock),
2423 // AddChild takes care of transforming the frame tree for fixed-pos
2424 // or abs-pos situations
2425 nsFrameItems frameItems;
2430 }
2434 // See if we need to create a view
2438 }
2439 }
2440 else
2441 #endif
2442 {
2445 // We're going to call the right function ourselves, so no need to give a
2446 // function to this FrameConstructionData.
2448 // XXXbz on the other hand, if we converted this whole function to
2449 // FrameConstructionData/Item, then we'd need the right function
2450 // here... but would probably be able to get away with less code in this
2451 // function in general.
2452 // Use a null PendingBinding, since our binding is not in fact pending.
2459 nsFrameItems frameItems;
2460 // if the document is a table then just populate it.
2475 nsFrameItems frameItems;
2476 // Use a null PendingBinding, since our binding is not in fact pending.
2479 mDocElementContainingBlock),
2482 nsnull);
2487 }
2488 }
2490 // set the primary frame
2498 // Figure out which frame has the main style for the document element,
2499 // assigning it to mRootElementStyleFrame.
2500 // Backgrounds should be propagated from that frame to the viewport.
2501 PRBool isChild;
2506 }
2509 // Still need to process the child content
2510 nsFrameItems childItems;
2514 // Use a null PendingBinding, since our binding is not in fact pending.
2518 // Set the initial child lists
2520 }
2525 }
2528 nsresult
2530 {
2536 // Set up our style rule observer.
2537 // XXXbz wouldn't this make more sense as part of presshell init?
2538 {
2540 }
2542 // --------- BUILD VIEWPORT -----------
2546 viewportPseudoStyle =
2551 // XXXbz do we _have_ to pass a null content pointer to that frame?
2552 // Would it really kill us to pass in the root element or something?
2553 // What would that break?
2556 // Bind the viewport frame to the root view
2564 rootView);
2566 // The viewport is the containing block for 'fixed' elements
2571 }
2573 nsresult
2575 {
2582 /*
2583 how the root frame hierarchy should look
2585 Galley presentation, non-XUL, with scrolling (i.e. not a frameset):
2587 ViewportFrame [fixed-cb]
2588 nsHTMLScrollFrame
2589 nsCanvasFrame [abs-cb]
2590 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
2591 nsTableOuterFrame, nsPlaceholderFrame)
2593 Galley presentation, non-XUL, without scrolling (i.e. a frameset):
2595 ViewportFrame [fixed-cb]
2596 nsCanvasFrame [abs-cb]
2597 root element frame (nsBlockFrame)
2599 Galley presentation, XUL
2601 ViewportFrame [fixed-cb]
2602 nsRootBoxFrame
2603 root element frame (nsDocElementBoxFrame)
2605 Print presentation, non-XUL
2607 ViewportFrame
2608 nsSimplePageSequenceFrame
2609 nsPageFrame [fixed-cb]
2610 nsPageContentFrame
2611 nsCanvasFrame [abs-cb]
2612 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
2613 nsTableOuterFrame, nsPlaceholderFrame)
2615 Print-preview presentation, non-XUL
2617 ViewportFrame
2618 nsHTMLScrollFrame
2619 nsSimplePageSequenceFrame
2620 nsPageFrame [fixed-cb]
2621 nsPageContentFrame
2622 nsCanvasFrame [abs-cb]
2623 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,
2624 nsTableOuterFrame, nsPlaceholderFrame)
2626 Print/print preview of XUL is not supported.
2627 [fixed-cb]: the default containing block for fixed-pos content
2628 [abs-cb]: the default containing block for abs-pos content
2630 Meaning of nsCSSFrameConstructor fields:
2631 mRootElementFrame is "root element frame". This is the primary frame for
2632 the root element.
2633 mDocElementContainingBlock is the parent of mRootElementFrame
2634 (i.e. nsCanvasFrame or nsRootBoxFrame)
2635 mFixedContainingBlock is the [fixed-cb]
2636 mGfxScrollFrame is the nsHTMLScrollFrame mentioned above, or null if there isn't one
2637 mPageSequenceFrame is the nsSimplePageSequenceFrame, or null if there isn't one
2638 */
2640 // --------- CREATE ROOT FRAME -------
2643 // Create the root frame. The document element's frame is a child of the
2644 // root frame.
2645 //
2646 // The root frame serves two purposes:
2647 // - reserves space for any margins needed for the document element's frame
2648 // - renders the document element's background. This ensures the background covers
2649 // the entire canvas as specified by the CSS2 spec
2660 #ifdef MOZ_XUL
2662 {
2663 // pass a temporary stylecontext, the correct one will be set later
2666 #endif
2667 {
2668 // pass a temporary stylecontext, the correct one will be set later
2671 }
2676 // Create a page sequence frame
2680 }
2683 // --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------
2685 // If the device supports scrolling (e.g., in galley mode on the screen and
2686 // for print-preview, but not when printing), then create a scroll frame that
2687 // will act as the scrolling mechanism for the viewport.
2688 // XXX Do we even need a viewport when printing to a printer?
2690 // As long as the docshell doesn't prohibit it, and the device supports
2691 // it, create a scroll frame that will act as the scolling mechanism for
2692 // the viewport.
2693 //
2694 // Threre are three possible values stored in the docshell:
2695 // 1) nsIScrollable::Scrollbar_Never = no scrollbars
2696 // 2) nsIScrollable::Scrollbar_Auto = scrollbars appear if needed
2697 // 3) nsIScrollable::Scrollbar_Always = scrollbars always
2698 // Only need to create a scroll frame/view for cases 2 and 3.
2705 }
2707 // Never create scrollbars for XUL documents
2710 // Never create scrollbars for frameset documents.
2715 }
2719 }
2721 // We no longer need to do overflow propagation here. It's taken care of
2722 // when we construct frames for the element whose overflow might be
2723 // propagated
2729 // we must create a state because if the scrollbars are GFX it needs the
2730 // state to build the scrollbar frames.
2733 // Start off with the viewport as parent; we'll adjust it as needed.
2737 // If paginated, make sure we don't put scrollbars in
2740 viewportPseudoStyle);
2748 }
2750 // Build the frame. We give it the content we are wrapping which is the
2751 // document element, the root frame, the parent view port frame, and we
2752 // should get back the new frame and the scrollable view if one was
2753 // created.
2755 // resolve a context for the scrollframe
2758 viewportPseudoStyle);
2760 // Note that the viewport scrollframe is always built with
2761 // overflow:auto style. This forces the scroll frame to create
2762 // anonymous content for both scrollbars. This is necessary even
2763 // if the HTML or BODY elements are overriding the viewport
2764 // scroll style to 'hidden' --- dynamic style changes might put
2765 // scrollbars back on the viewport and we don't want to have to
2766 // reframe the viewport to create the scrollbar content.
2769 aDocElement,
2770 styleContext,
2771 viewportFrame,
2772 rootPseudo,
2773 PR_TRUE,
2774 newFrame);
2777 }
2784 }
2787 // Create the first page
2788 // Set the initial child lists
2794 // The eventual parent of the document element frame.
2795 // XXX should this be set for every new page (in ConstructPageFrame)?
2798 }
2805 }
2808 }
2810 nsresult
2817 {
2823 parentStyleContext);
2829 // Initialize the page frame and force it to have a view. This makes printing of
2830 // the pages easier and faster.
2834 pageContentPseudoStyle =
2836 pagePseudoStyle);
2842 // Initialize the page content frame and force it to have a view. Also make it the
2843 // containing block for fixed elements which are repeated on every page.
2848 }
2855 pageContentPseudoStyle);
2865 }
2870 }
2872 /* static */
2873 nsresult
2880 nsFrameState aTypeBit,
2882 {
2886 // The placeholder frame gets a pseudo style context
2889 aTypeBit);
2894 // The placeholder frame has a pointer back to the out-of-flow frame
2899 // Add mapping from absolutely positioned frame to its placeholder frame
2905 }
2908 }
2909 }
2911 // Clears any lazy bits set in the range [aStartContent, aEndContent). If
2912 // aEndContent is null, that means to clear bits in all siblings starting with
2913 // aStartContent. aStartContent must not be null unless aEndContent is also
2914 // null. We do this so that when new children are inserted under elements whose
2915 // frame is a leaf the new children don't cause us to try to construct frames
2916 // for the existing children again.
2919 {
2925 }
2926 }
2928 nsresult
2935 {
2943 }
2946 }
2949 }
2950 // Initialize the button frame
2957 }
2958 // See if we need to create a view
2962 innerBlockContext =
2964 styleContext);
2967 NS_BLOCK_FLOAT_MGR);
2972 }
2978 }
2981 aParentFrame);
2986 }
2989 #ifdef DEBUG
2990 // Make sure that we're an anonymous content creator exactly when we're a
2991 // leaf
2995 #endif
2998 // Process children
2999 nsFrameConstructorSaveState absoluteSaveState;
3000 nsFrameItems childItems;
3003 // The area frame becomes a container for child frames that are
3004 // absolutely positioned
3006 }
3008 #ifdef DEBUG
3009 // Make sure that anonymous child creation will have no effect in this case
3012 #endif
3019 // Set the areas frame's initial child lists
3021 }
3028 nsFrameItems anonymousChildItems;
3029 // if there are any anonymous children create frames for them. Note that
3030 // we're doing this using a different parent frame from the one we pass to
3031 // ProcessChildren!
3033 anonymousChildItems);
3035 // the anonymous content is already parented to the area frame
3037 anonymousChildItems);
3038 }
3039 }
3041 // our new button frame returned is the top frame.
3045 }
3047 nsresult
3054 {
3061 // Construct a frame-based listbox or combobox
3068 // Construct a combobox if size=1 or no size is specified and its multiple select
3069 if (((1 == size || 0 == size) || (kNoSizeSpecified == size)) && (PR_FALSE == multipleSelect)) {
3070 // Construct a frame-based combo box.
3071 // The frame-based combo box is built out of three parts. A display area, a button and
3072 // a dropdown list. The display area and button are created through anonymous content.
3073 // The drop-down list's frame is created explicitly. The combobox frame shares its content
3074 // with the drop-down list.
3078 // Save the history state so we don't restore during construction
3079 // since the complete tree is required before we restore.
3082 // Initialize the combobox frame
3090 aParentFrame);
3093 }
3095 ///////////////////////////////////////////////////////////////////
3096 // Combobox - Old Native Implementation
3097 ///////////////////////////////////////////////////////////////////
3102 // Resolve pseudo element style for the dropdown list
3107 // Create a listbox
3110 // Notify the listbox that it is being used as a dropdown list.
3114 }
3115 // Notify combobox that it should use the listbox as it's popup
3123 // Initialize the scroll frame positioned. Note that it is NOT
3124 // initialized as absolutely positioned.
3131 // Set flag so the events go to the listFrame not child frames.
3132 // XXX: We should replace this with a real widget manager similar
3133 // to how the nsFormControlFrame works. Re-directing events is a temporary Kludge.
3135 //listFrame->GetView()->SetViewFlags(NS_VIEW_PUBLIC_FLAG_DONT_CHECK_CHILDREN);
3137 // Create display and button frames from the combobox's anonymous content.
3138 // The anonymous content is appended to existing anonymous content for this
3139 // element (the scrollbars).
3141 nsFrameItems childItems;
3147 // Initialize the additional popup child list which contains the
3148 // dropdown list frame.
3149 nsFrameItems popupItems;
3152 popupItems);
3157 // Restore frame state for the entire subtree of |comboboxFrame|.
3160 }
3162 ///////////////////////////////////////////////////////////////////
3163 // ListBox - Old Native Implementation
3164 ///////////////////////////////////////////////////////////////////
3168 }
3171 }
3176 // ******* this code stolen from Initialze ScrollFrame ********
3177 // please adjust this code to use BuildScrollFrame.
3184 }
3185 }
3188 }
3190 /**
3191 * Used to be InitializeScrollFrame but now it's only used for the select tag
3192 * But the select tag should really be fixed to use GFX scrollbars that can
3193 * be create with BuildScrollFrame.
3194 */
3195 nsresult
3202 PRBool aBuildCombobox,
3205 {
3208 // Initialize it
3211 // We don't call InitAndRestoreFrame for scrollFrame because we can only
3212 // restore the frame state after its parts have been created (in particular,
3213 // the scrollable view). So we have to split Init and Restore.
3215 // Initialize the frame
3223 }
3224 }
3228 // Give the drop-down list a popup widget
3234 nsWidgetInitData widgetData;
3238 }
3239 }
3245 // Restore frame state for the scroll frame
3247 }
3249 // Process children
3250 nsFrameConstructorSaveState absoluteSaveState;
3251 nsFrameItems childItems;
3254 // The area frame becomes a container for child frames that are
3255 // absolutely positioned
3257 }
3262 // Set the scrolled frame's initial child lists
3265 }
3267 nsresult
3274 {
3281 }
3283 // Initialize it
3288 // See if we need to create a view, e.g. the frame is absolutely
3289 // positioned
3292 // Resolve style and initialize the frame
3298 NS_BLOCK_FLOAT_MGR |
3299 NS_BLOCK_MARGIN_ROOT);
3303 aParentFrame);
3306 }
3308 // Process children
3309 nsFrameConstructorSaveState absoluteSaveState;
3310 nsFrameItems childItems;
3313 // The area frame becomes a container for child frames that are
3314 // absolutely positioned
3315 // XXXbz this is probably wrong, and once arbitrary frames can be absolute
3316 // containing blocks we should fix this..
3318 }
3323 nsFrameItems fieldsetKids;
3329 // We want the legend to be the first frame in the fieldset child list.
3330 // That way the EventStateManager will do the right thing when tabbing
3331 // from a selection point within the legend (bug 236071), which is
3332 // used for implementing legend access keys (bug 81481).
3333 // GetAdjustedParentFrame() below depends on this frame order.
3335 // Make sure to reparent the legend so it has the fieldset as the parent.
3338 }
3339 }
3341 // Set the inner frame's initial child lists
3344 // Set the outer frame's initial child list
3347 // our new frame returned is the top frame which is the list frame.
3351 }
3355 {
3363 }
3365 }
3367 #define SIMPLE_FCDATA(_func) FCDATA_DECL(0, _func)
3368 #define FULL_CTOR_FCDATA(_flags, _func) \
3369 { _flags | FCDATA_FUNC_IS_FULL_CTOR, { nsnull }, _func }
3371 /* static */
3374 {
3375 #ifdef MOZ_SVG
3385 }
3386 }
3388 }
3389 #endif
3394 }
3396 nsresult
3403 {
3417 }
3419 // We never need to create a view for a text frame.
3423 initializer =
3430 }
3432 }
3433 }
3435 // Add the newly constructed frame to the flow
3442 }
3444 /* static */
3450 PRUint32 aDataLength)
3451 {
3460 }
3463 }
3464 }
3467 }
3469 /* static */
3475 PRUint32 aDataLength)
3476 {
3485 }
3488 }
3489 }
3492 }
3494 #define SUPPRESS_FCDATA() FCDATA_DECL(FCDATA_SUPPRESS_FRAME, nsnull)
3495 #define SIMPLE_INT_CREATE(_int, _func) { _int, SIMPLE_FCDATA(_func) }
3496 #define SIMPLE_INT_CHAIN(_int, _func) \
3497 { _int, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) }
3498 #define COMPLEX_INT_CREATE(_int, _func) \
3499 { _int, FULL_CTOR_FCDATA(0, _func) }
3501 #define SIMPLE_TAG_CREATE(_tag, _func) \
3502 { &nsGkAtoms::_tag, SIMPLE_FCDATA(_func) }
3503 #define SIMPLE_TAG_CHAIN(_tag, _func) \
3504 { &nsGkAtoms::_tag, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) }
3505 #define COMPLEX_TAG_CREATE(_tag, _func) \
3506 { &nsGkAtoms::_tag, FULL_CTOR_FCDATA(0, _func) }
3508 /* static */
3512 PRInt32 aNameSpaceID,
3515 {
3516 // Ignore the tag if it's not HTML content and if it doesn't extend (via XBL)
3517 // a valid HTML namespace. This check must match the one in
3518 // ShouldHaveFirstLineStyle.
3521 }
3538 // <legend> is only special inside fieldset, check both the frame tree
3539 // parent and content tree parent due to XBL issues. For floated or
3540 // absolutely positioned legends we want to construct by display type and
3541 // not do special legend stuff.
3542 // XXXbz it would be nice if we could just decide this based on the parent
3543 // tag, and hence just use a SIMPLE_TAG_CHAIN for legend below, but the
3544 // fact that with XBL we could end up with this legend element in some
3545 // totally weird insertion point makes that chancy, I think.
3547 }
3555 NS_NewBRFrame) },
3571 #if defined(MOZ_MEDIA)
3574 #endif
3576 };
3580 }
3582 /* static */
3586 {
3589 }
3593 }
3595 /* static */
3599 {
3602 }
3607 }
3609 /* static */
3613 {
3632 // Keeping hidden inputs out of here on purpose for so they get frames by
3633 // display (in practice, none).
3634 };
3641 }
3643 /* static */
3647 {
3648 // GetDisplayedType isn't necessarily nsIObjectLoadingContent::TYPE_NULL for
3649 // cases when the object is broken/suppressed/etc (e.g. a broken image), but
3650 // we want to treat those cases as TYPE_NULL
3651 PRUint32 type;
3653 NS_EVENT_STATE_USERDISABLED |
3654 NS_EVENT_STATE_SUPPRESSED)) {
3659 "applet, embed and object must implement "
3663 }
3667 NS_NewEmptyFrame),
3669 NS_NewObjectFrame),
3671 NS_NewImageFrame),
3673 NS_NewSubDocumentFrame)
3674 // Nothing for TYPE_NULL so we'll construct frames by display there
3675 };
3679 }
3681 nsresult
3686 {
3695 // Some sets of bits are not compatible with each other
3696 #define CHECK_ONLY_ONE_BIT(_bit1, _bit2) \
3697 NS_ASSERTION(!(bits & _bit1) || !(bits & _bit2), \
3700 #ifdef MOZ_MATHML
3702 #endif
3708 FCDATA_DISALLOW_GENERATED_CONTENT);
3711 #undef CHECK_ONLY_ONE_BIT
3713 // Don't create a subdocument frame for iframes if we're creating extra frames
3716 {
3718 }
3726 nsresult rv =
3731 }
3737 newFrame =
3741 }
3758 // Must init frameToAddToList to null, since it's inout
3766 newFrame);
3768 // See whether we need to create a view
3772 }
3774 // Use frameToAddToList as the primary frame. In the non-scrollframe case
3775 // they're equal, but in the scrollframe case newFrame is the scrolled
3776 // frame, while frameToAddToList is the scrollframe (and should be the
3777 // primary frame).
3784 }
3786 #ifdef MOZ_XUL
3787 // Icky XUL stuff, sadly
3792 newFrame,
3796 }
3799 // Process the child content if requested
3800 nsFrameItems childItems;
3801 nsFrameConstructorSaveState absoluteSaveState;
3807 }
3811 childItems);
3813 // Process the child frames.
3816 childItems,
3819 }
3821 #ifdef MOZ_XUL
3822 // More icky XUL stuff
3830 }
3831 }
3832 #endif
3834 #ifdef MOZ_MATHML
3836 nsFrameItems newItems;
3837 nsFrameItems currentBlock;
3845 }
3852 }
3853 }
3857 // an error must have occurred, delete unprocessed frames
3859 }
3862 }
3863 #endif
3865 // Set the frame's initial child list
3866 // Note that MathML depends on this being called even if
3867 // childItems is empty!
3869 }
3877 }
3880 }
3882 // after the node has been constructed and initialized create any
3883 // anonymous content a node needs.
3884 nsresult
3890 {
3898 }
3901 aPendingBinding);
3916 }
3918 // create the frame and attach it to our frame
3920 }
3921 }
3924 }
3926 nsresult
3930 {
3940 // get our child's content and set its parent to our content
3944 #ifdef MOZ_SVG
3945 // least-surprise CSS binding until we do the SVG specified
3946 // cascading rules for <svg:use> - bug 265894
3951 #endif
3952 {
3954 }
3960 }
3961 }
3964 }
3966 static
3968 {
3970 #ifdef MOZ_XUL
3973 #endif
3975 #ifdef MOZ_XUL
3983 #endif
3984 );
3985 }
3988 // XUL frames are not allowed to be out of flow.
3989 #define SIMPLE_XUL_FCDATA(_func) \
3990 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH, \
3991 _func)
3992 #define SCROLLABLE_XUL_FCDATA(_func) \
3993 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH | \
3994 FCDATA_MAY_NEED_SCROLLFRAME, _func)
3995 #define SIMPLE_XUL_CREATE(_tag, _func) \
3996 { &nsGkAtoms::_tag, SIMPLE_XUL_FCDATA(_func) }
3997 #define SCROLLABLE_XUL_CREATE(_tag, _func) \
3998 { &nsGkAtoms::_tag, SCROLLABLE_XUL_FCDATA(_func) }
3999 #define SIMPLE_XUL_INT_CREATE(_int, _func) \
4000 { _int, SIMPLE_XUL_FCDATA(_func) }
4001 #define SCROLLABLE_XUL_INT_CREATE(_int, _func) \
4002 { _int, SCROLLABLE_XUL_FCDATA(_func) }
4004 static
4007 {
4012 }
4015 }
4017 /* static */
4021 PRInt32 aNameSpaceID,
4023 {
4026 }
4029 #ifdef MOZ_XUL
4047 #ifdef XP_MACOSX
4049 #else
4065 };
4069 }
4071 #ifdef MOZ_XUL
4072 /* static */
4076 {
4079 }
4084 }
4086 /* static */
4090 /* static */
4094 {
4097 }
4102 }
4106 {
4107 // XXXbz do we really need to set those flags? If the parent is not
4108 // a block we'll get them anyway, and if it is, do we want them?
4111 }
4113 /* static */
4117 {
4120 }
4125 }
4127 #ifdef XP_MACOSX
4128 /* static */
4132 {
4138 PRInt32 type;
4144 // This is the root. Suppress the menubar, since on Mac
4145 // window menus are not attached to the window.
4148 }
4149 }
4150 }
4151 }
4156 }
4159 /* static */
4163 {
4165 NS_STYLE_DISPLAY_GRID_GROUP) {
4167 }
4172 }
4174 /* static */
4178 {
4180 NS_STYLE_DISPLAY_GRID_LINE) {
4182 }
4187 }
4191 /* static */
4196 {
4200 #ifdef MOZ_XUL
4204 NS_NewGridRowGroupFrame),
4206 NS_NewGridRowLeafFrame),
4215 };
4217 // Processing by display here:
4220 }
4228 PRBool aIsRoot,
4230 {
4233 nsFrameItems anonymousItems;
4238 // Build a XULScrollFrame when the child is a box, otherwise an
4239 // HTMLScrollFrame
4240 // XXXbz this is the lone remaining consumer of IsXULDisplayType.
4241 // I wonder whether we can eliminate that somehow.
4246 }
4250 // Create a view
4252 }
4254 // if there are any anonymous children for the scroll frame, create
4255 // frames for them.
4256 // Pass a null pending binding: we don't care how constructors for any of
4257 // this anonymous content order with anything else. It's never been
4258 // consistent anyway.
4260 anonymousItems);
4264 // we used the style that was passed in. So resolve another one.
4271 }
4274 }
4276 void
4279 {
4282 }
4285 /**
4286 * Called to wrap a gfx scrollframe around a frame. The hierarchy will look like this
4287 *
4288 * ------- for gfx scrollbars ------
4289 *
4290 *
4291 * ScrollFrame
4292 * ^
4293 * |
4294 * Frame (scrolled frame you passed in)
4295 *
4296 *
4297 *-----------------------------------
4298 * LEGEND:
4299 *
4300 * ScrollFrame: This is a frame that manages gfx cross platform frame based scrollbars.
4301 *
4302 * @param aContent the content node of the child to wrap.
4303 * @param aScrolledFrame The frame of the content to wrap. This should not be
4304 * Initialized. This method will initialize it with a scrolled pseudo
4305 * and no nsIContent. The content will be attached to the scrollframe
4306 * returned.
4307 * @param aContentStyle the style context that has already been resolved for the content being passed in.
4308 *
4309 * @param aParentFrame The parent to attach the scroll frame to
4310 *
4311 * @param aNewFrame The new scrollframe or gfx scrollframe that we create. It will contain the
4312 * scrolled frame you passed in. (returned)
4313 * If this is not null, we'll just use it
4314 * @param aScrolledContentStyle the style that was resolved for the scrolled frame. (returned)
4315 */
4316 nsresult
4323 {
4334 }
4340 {
4343 // The style system ensures that floated and positioned frames are
4344 // block-level.
4350 // If this is "body", try propagating its scroll style to the viewport
4351 // Note that we need to do this even if the body is NOT scrollable;
4352 // it might have dynamically changed from scrollable to not scrollable,
4353 // and that might need to be propagated.
4354 // XXXbz is this the right place to do this? If this code moves,
4355 // make this function static.
4359 propagatedScrollToViewport =
4361 }
4367 // If the frame is a block-level frame and is scrollable, then wrap it in a
4368 // scroll frame. Except we don't want to do that for paginated contexts for
4369 // frames that are block-outside and aren't frames for native anonymous stuff.
4370 // The condition on skipping scrollframe construction in the
4371 // paginated case needs to match code in ConstructNonScrollableBlock
4372 // and in nsFrame::ApplyPaginatedOverflowClipping.
4373 // XXX Ignore tables for the time being
4374 // XXXbz it would be nice to combine this with the other block
4375 // case... Think about how do do this?
4385 }
4387 // Handle various non-scrollable blocks
4394 }
4397 // To keep the hash table small don't add inline frames (they're
4398 // typically things like FONT and B), because we can quickly
4399 // find them if we need to.
4400 // XXXbz the "quickly" part is a bald-faced lie!
4415 NS_NewTableCaptionFrame) },
4418 FCDATA_SKIP_ABSPOS_PUSH |
4420 NS_NewTableRowGroupFrame) },
4423 FCDATA_SKIP_ABSPOS_PUSH |
4425 NS_NewTableRowGroupFrame) },
4428 FCDATA_SKIP_ABSPOS_PUSH |
4430 NS_NewTableRowGroupFrame) },
4433 FCDATA_SKIP_ABSPOS_PUSH |
4435 NS_NewTableColGroupFrame) },
4448 };
4452 }
4454 nsresult
4461 {
4472 // Create our block frame
4473 // pass a temporary stylecontext, the correct one will be set later
4477 nsFrameItems blockItem;
4484 // XXXbz any cleanup needed here?
4486 }
4493 aParentFrame);
4495 }
4497 nsresult
4504 {
4510 // This check just needs to be the same as the check for using scrollable
4511 // blocks in FindDisplayData and the check for clipping in
4512 // nsFrame::ApplyPaginatedOverflowClipping; we want a block formatting
4513 // context root in paginated contexts for every block that would be
4514 // scrollable in a non-paginated context. Note that IsPaginated()
4515 // implies that no propagation to viewport has taken place, so we don't
4516 // need to check for propagation here.
4525 }
4532 }
4535 nsresult
4541 PRBool aAllowCounters)
4542 {
4552 // Initialize the frame
4557 // Restore frame state for just the newly created frame.
4559 }
4564 }
4567 }
4572 {
4579 // Resolve the style context based on the content object and the parent
4580 // style context
4583 // Perhaps aParentFrame is a canvasFrame and we're replicating
4584 // fixed-pos frames.
4585 // XXX should we create a way to tell ConstructFrame which style
4586 // context to use, and pass it the style context for the
4587 // previous page's fixed-pos frame?
4588 }
4591 }
4596 {
4601 }
4604 "shouldn't waste time creating style contexts for "
4608 }
4610 // MathML Mod - RBS
4611 #ifdef MOZ_MATHML
4612 nsresult
4618 {
4620 // Nothing to do
4622 }
4631 parentContext);
4633 // then, create a block frame that will wrap the child frames. Make it a
4634 // MathML frame so that Get(Absolute/Float)ContainingBlockFor know that this
4635 // is not a suitable block.
4643 // abs-pos and floats are disabled in MathML children so we don't have to
4644 // worry about messing up those.
4650 }
4652 // Only <math> elements can be floated or positioned. All other MathML
4653 // should be in-flow.
4654 #define SIMPLE_MATHML_CREATE(_tag, _func) \
4655 { &nsGkAtoms::_tag, \
4656 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \
4657 FCDATA_FORCE_NULL_ABSPOS_CONTAINER | \
4658 FCDATA_WRAP_KIDS_IN_BLOCKS, _func) }
4660 /* static */
4664 PRInt32 aNameSpaceID,
4666 {
4667 // Make sure that we remain confined in the MathML world
4671 // Handle <math> specially, because it sometimes produces inlines
4673 // This needs to match the test in EnsureBlockDisplay in
4674 // nsRuleNode.cpp. Though the behavior here for the display:table
4675 // case is pretty weird...
4679 FCDATA_WRAP_KIDS_IN_BLOCKS,
4680 NS_CreateNewMathMLmathBlockFrame);
4682 }
4686 FCDATA_IS_LINE_PARTICIPANT |
4687 FCDATA_WRAP_KIDS_IN_BLOCKS,
4688 NS_NewMathMLmathInlineFrame);
4690 }
4721 };
4725 }
4728 #ifdef MOZ_SVG
4729 // Only outer <svg> elements can be floated or positioned. All other SVG
4730 // should be in-flow.
4731 #define SIMPLE_SVG_FCDATA(_func) \
4732 FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \
4733 FCDATA_SKIP_ABSPOS_PUSH | \
4734 FCDATA_DISALLOW_GENERATED_CONTENT, _func)
4735 #define SIMPLE_SVG_CREATE(_tag, _func) \
4736 { &nsGkAtoms::_tag, SIMPLE_SVG_FCDATA(_func) }
4738 /* static */
4742 PRInt32 aNameSpaceID,
4745 {
4748 }
4757 // XXXbz should this really be based on the XBL-resolved tag of the parent
4758 // frame's content? Should it not be based on the type of the parent frame
4759 // (e.g. whether it's an SVG frame)?
4761 PRInt32 parentNSID;
4766 // It's not clear whether the SVG spec intends to allow any SVG
4767 // content within svg:foreignObject at all (SVG 1.1, section
4768 // 23.2), but if it does, it better be svg:svg. So given that
4769 // we're allowing it, treat it as a non-SVG parent.
4772 }
4776 // Sections 5.1 and G.4 of SVG 1.1 say that SVG elements other than
4777 // svg:svg not contained within svg:svg are incorrect, although they
4778 // don't seem to specify error handling. Ignore them, since many of
4779 // our frame classes can't deal. It *may* be that the document
4780 // should at that point be considered in error according to F.2, but
4781 // it's hard to tell.
4782 //
4783 // Style mutation can't change this situation, so don't bother
4784 // adding to the undisplayed content map.
4785 //
4786 // We don't currently handle any UI for desc/title
4788 }
4790 // We don't need frames for animation elements
4793 }
4795 // Reduce the number of frames we create unnecessarily. Note that this is not
4796 // where we select which frame in a <switch> to render! That happens in
4797 // nsSVGSwitchFrame::PaintSVG.
4799 // Note that just returning is probably not right. According
4800 // to the spec, <use> is allowed to use an element that fails its
4801 // conditional, but because we never actually create the frame when
4802 // a conditional fails and when we use GetReferencedFrame to find the
4803 // references, things don't work right.
4804 // XXX FIXME XXX
4806 }
4808 // Special case for aTag == nsGkAtoms::svg because we don't want to
4809 // have to recompute parentIsSVG for it.
4815 }
4819 FCDATA_DISALLOW_GENERATED_CONTENT,
4820 NS_NewSVGOuterSVGFrame);
4822 }
4824 // Special cases for text/tspan/textPath, because the kind of frame
4825 // they get depends on the parent frame. We ignore 'a' elements when
4826 // determining the parent, however.
4831 // tspan and altGlyph must be children of another text content element.
4835 }
4837 // textPath must be a child of text.
4841 }
4843 // Every other element except 'a' must not be a child of a text content
4844 // element.
4848 }
4849 }
4850 }
4904 };
4912 }
4915 }
4917 nsresult
4924 {
4931 }
4933 // We don't allow this frame to be out of flow
4941 }
4948 NS_BLOCK_FLOAT_MGR |
4949 NS_BLOCK_MARGIN_ROOT);
4953 }
4955 nsFrameItems childItems;
4956 // Claim to be relatively positioned so that we end up being the
4957 // absolute containing block.
4963 // Give the blockFrame a view so that GetOffsetTo works for descendants
4964 // of blockFrame with views...
4972 }
4976 void
4980 {
4982 // Use the same parent style context that |aMainStyleContext| has, since
4983 // that's easier to re-resolve and it doesn't matter in practice.
4984 // (Getting different parents can result in framechange hints, e.g.,
4985 // for user-modify.)
4986 pseudoStyle =
4997 // Lie about the tag and namespace so we don't trigger anything
4998 // interesting during frame construction.
5001 }
5003 nsresult
5009 {
5011 FrameConstructionItemList items;
5017 nsresult rv =
5020 }
5023 }
5025 void
5028 PRBool aSuppressWhiteSpaceOptimizations,
5031 {
5034 // We can't just remove our pending restyle flags, since we may
5035 // have restyle-later-siblings set on us. But we _can_ remove the
5036 // "is possible restyle root" flags, and need to. Otherwise we can
5037 // end up with stale such flags (e.g. if we used to have a
5038 // display:none parent when our last restyle was posted and
5039 // processed and now no longer do).
5042 }
5044 // don't create a whitespace frame if aParent doesn't want it
5047 }
5049 // never create frames for comments or PIs
5059 aSuppressWhiteSpaceOptimizations,
5060 styleContext,
5062 aItems);
5063 }
5065 /**
5066 * Set aContent as undisplayed content with style context aStyleContext. This
5067 * method enforces the invariant that all style contexts in the undisplayed
5068 * content map must be non-pseudo contexts and also handles unbinding
5069 * undisplayed generated content as needed.
5070 */
5071 static void
5074 PRBool aIsGeneratedContent)
5075 {
5079 }
5081 }
5085 }
5087 void
5092 PRInt32 aNameSpaceID,
5093 PRBool aSuppressWhiteSpaceOptimizations,
5095 PRUint32 aFlags,
5097 {
5098 // The following code allows the user to specify the base tag
5099 // of an element using XBL. XUL and HTML objects (like boxes, menus, etc.)
5100 // can then be extended arbitrarily.
5105 {
5106 // Ensure that our XBL bindings are installed.
5112 PRBool resolveStyle;
5117 }
5120 PR_FALSE,
5128 // aState takes over owning newPendingBinding
5130 }
5136 }
5139 }
5143 // Pre-check for display "none" - if we find that, don't create
5144 // any frame at all
5147 isGeneratedContent);
5149 }
5153 // Try to find frame construction data for this content
5157 #ifdef MOZ_SVG
5159 // Nothing to do here; suppressed text inside SVG
5161 }
5164 #ifdef MOZ_SVG
5165 // Don't create frames for non-SVG element children of SVG elements.
5167 aParentFrame &&
5170 ) {
5172 isGeneratedContent);
5174 }
5178 styleContext);
5181 }
5182 #ifdef MOZ_MATHML
5185 }
5186 #endif
5187 #ifdef MOZ_SVG
5190 styleContext);
5191 }
5194 // Now check for XUL display types
5197 }
5199 // And general display types
5202 }
5208 isGeneratedContent);
5210 }
5212 #ifdef MOZ_XUL
5219 isGeneratedContent);
5221 }
5224 }
5226 }
5230 // Inside colgroups, suppress everything except columns.
5236 isGeneratedContent);
5238 }
5240 PRBool canHavePageBreak =
5248 }
5253 aSuppressWhiteSpaceOptimizations);
5257 }
5259 }
5265 }
5271 }
5276 }
5279 // To correctly set item->mIsAllInline we need to build up our child items
5280 // right now.
5285 // Compute a boolean isInline which is guaranteed to be false for blocks
5286 // (but may also be false for some inlines).
5287 PRBool isInline =
5288 // Table-internal things are inline-outside if and only if they're kids of
5289 // inlines, since they'll trigger construction of inline-table
5290 // pseudos.
5294 // Things that are inline-outside but aren't inline frames are inline
5296 // Popups that are certainly out of flow.
5297 isPopup;
5299 // Set mIsAllInline conservatively. It just might be that even an inline
5300 // that has mIsAllInline false doesn't need an {ib} split. So this is just
5301 // an optimization to keep from doing too much work in cases when we can
5302 // show that mIsAllInline is true..
5304 // Figure out whether we're guaranteed this item will be out of flow.
5305 // This is not a precise test, since one of our ancestor inlines might add
5306 // an absolute containing block (if it's relatively positioned) when there
5307 // wasn't such a containing block before. But it's conservative in the
5308 // sense that anything that will really end up as an in-flow non-inline
5309 // will test false here. In other words, if this test is true we're
5310 // guaranteed to be inline; if it's false we don't know what we'll end up
5311 // as.
5312 //
5313 // If we make this test precise, we can remove some of the code dealing
5314 // with the imprecision in ConstructInline and adjust the comments on
5315 // mIsAllInline and mIsBlock in the header. And probably remove mIsBlock
5316 // altogether, since then it will always be equal to !mHasInlineEnds.
5320 // Set mIsBlock conservatively. It's OK to set it false for some real
5321 // blocks, but not OK to set it true for things that aren't blocks. Since
5322 // isOutOfFlow might be false even in cases when the frame will end up
5323 // out-of-flow, we can't use it here. But we _can_ say that the frame will
5324 // for sure end up in-flow if it's not floated or absolutely positioned.
5327 }
5333 }
5335 // Our item should be treated as a line participant if we have the relevant
5336 // bit and are going to be in-flow. Note that this really only matters if
5337 // our ancestor is a box or some such, so the fact that we might have an
5338 // inline ancestor that might become a containing block is not relevant here.
5344 }
5345 }
5347 static void
5349 {
5353 }
5360 {
5366 }
5368 /**
5369 * Return true if the frame construction item pointed to by aIter will
5370 * create a frame adjacent to a line boundary in the frame tree, and that
5371 * line boundary is induced by a content node adjacent to the frame's
5372 * content node in the content tree. The latter condition is necessary so
5373 * that ContentAppended/ContentInserted/ContentRemoved can easily find any
5374 * text nodes that were suppressed here.
5375 */
5376 PRBool
5378 {
5381 }
5394 }
5407 }
5410 }
5412 nsresult
5417 {
5424 // If this is collapsible whitespace next to a line boundary,
5425 // don't create a frame. item.IsWhitespace() also sets the
5426 // NS_CREATE_FRAME_IF_NON_WHITESPACE flag in the text node. (If we
5427 // end up creating a frame, nsTextFrame::Init will clear the flag.)
5428 // We don't do this for generated content, because some generated
5429 // text content is empty text nodes that are about to be initialized.
5430 // (We check mAdditionalStateBits because only the generated content
5431 // container's frame construction item is marked with
5432 // mIsGeneratedContent, and we might not have an aParentFrame.)
5433 // We don't do it for content that may have XBL anonymous siblings,
5434 // because they make it difficult to correctly create the frame
5435 // due to dynamic changes.
5436 // We don't do it for text that's not a line participant (i.e. SVG text).
5447 aFrameItems);
5448 }
5450 // Start background loads during frame construction. This is just
5451 // a hint; the paint code will do the right thing in any case.
5452 {
5454 }
5458 // Ensure that frames created here are all tagged with
5459 // NS_FRAME_GENERATED_CONTENT.
5462 // Note that we're not necessarily setting this property on the primary
5463 // frame for the content for which this is generated content. We might be
5464 // setting it on a table pseudo-frame inserted under that instead. That's
5465 // OK, though; we just need to do the property set so that the content will
5466 // get cleaned up when the frame is destroyed.
5470 // Now that we've passed ownership of item.mContent to the frame, unset
5471 // our generated content flag so we don't release or unbind it ourselves.
5473 }
5475 // XXXbz maybe just inline ConstructFrameFromItemInternal here or something?
5477 aFrameItems);
5482 }
5485 inline PRBool
5487 {
5489 }
5491 nsresult
5493 {
5495 PR_FALSE);
5496 }
5498 nsIFrame*
5500 {
5501 // Get the primary frame associated with the content
5507 // If the content of the frame is not the desired content then this is not
5508 // really a frame for the desired content.
5509 // XXX This check is needed due to bug 135040. Remove it once that's fixed.
5512 }
5520 }
5522 nsIFrame*
5524 {
5527 // Starting with aFrame, look for a frame that is absolutely positioned or
5528 // relatively positioned
5533 // If it's mathml, bail out -- no absolute positioning out from inside
5534 // mathml frames. Note that we don't make this part of the loop
5535 // condition because of the stuff at the end of this method...
5537 }
5539 // Is it positioned?
5540 // If it's table-related then ignore it, because for the time
5541 // being table-related frames are not containers for absolutely
5542 // positioned child frames.
5546 // Find the outermost wrapped block under this frame
5551 #ifdef MOZ_XUL
5553 #endif
5557 // If the positioned frame is a fieldset, use the area frame inside it.
5558 // We don't use GetContentInsertionFrame for fieldsets yet.
5560 }
5561 }
5563 // We sometimes have a null containing block here because we
5564 // haven't yet fixed bug 455338. Once we fix that we shouldn't
5565 // have to loop here.
5566 }
5567 }
5569 // If we found an absolutely positioned containing block, then use the
5570 // first-continuation.
5574 // If we didn't find it, then use the document element containing block
5576 }
5578 nsIFrame*
5580 {
5581 // Starting with aFrame, look for a frame that is a float containing block.
5582 // IF we hit a mathml frame, bail out; we don't allow floating out of mathml
5583 // frames, because they don't seem to be able to deal.
5584 // The logic here needs to match the logic in ProcessChildren()
5591 }
5592 }
5594 // If we didn't find a containing block, then there just isn't
5595 // one.... return null
5597 }
5599 /**
5600 * This function will check whether aContainer has :after generated content.
5601 * If so, appending to it should actually insert. The return value is the
5602 * parent to use for newly-appended content. *aAfterFrame points to the :after
5603 * frame before which appended content should go, if there is one.
5604 */
5610 {
5611 // See if the parent has an :after pseudo-element. Check for the presence
5612 // of style first, since nsLayoutUtils::GetAfterFrame is sorta expensive.
5616 aPresContext)) {
5621 }
5622 }
5627 // We might be in a situation where the last part of the {ib} split was
5628 // empty. Since we have no ::after pseudo-element, we do in fact want to be
5629 // appending to that last part, so advance to it if needed. Note that here
5630 // aParentFrame is the result of a GetLastSpecialSibling call, so must be
5631 // either the last or next to last special sibling.
5635 }
5637 // Always make sure to look at the last continuation of the frame
5638 // for the {ib} case, even if that continuation is empty. We
5639 // don't do this for the non-special-frame case, since in the
5640 // other cases appending to the last nonempty continuation is fine
5641 // and in fact not doing that can confuse code that doesn't know
5642 // to pull kids from continuations other than its next one.
5644 }
5647 }
5649 /**
5650 * This function will get the previous sibling to use for an append operation.
5651 * it takes a parent frame (must not be null) and its :after frame (may be
5652 * null).
5653 */
5656 {
5660 }
5663 }
5665 /**
5666 * This function will get the next sibling for a frame insert operation given
5667 * the parent and previous sibling. aPrevSibling may be null.
5668 */
5671 {
5674 }
5677 }
5679 /**
5680 * This function is called by ContentAppended() and ContentInserted() when
5681 * appending flowed frames to a parent's principal child list. It handles the
5682 * case where the parent is the trailing inline of an {ib} split.
5683 */
5684 nsresult
5689 PRBool aIsRecursiveCall)
5690 {
5703 aIsRecursiveCall,
5710 aIsRecursiveCall,
5713 // If we're inserting a list of frames at the end of the trailing inline
5714 // of an {ib} split, we may need to create additional {ib} siblings to parent
5715 // them.
5717 // When we get here, our frame list might start with a block. If it does
5718 // so, and aParentFrame is an inline, and it and all its previous
5719 // continuations have no siblings, then put the initial blocks from the
5720 // frame list into the previous block of the {ib} split. Note that we
5721 // didn't want to stop at the block part of the split when figuring out
5722 // initial parent, because that could screw up float parenting; it's easier
5723 // to do this little fixup here instead.
5725 // See whether our trailing inline is empty
5728 // Our trailing inline is empty. Collect our starting blocks from
5729 // aFrameList, get the right parent frame for them, and put them in.
5740 }
5741 }
5743 // We want to put some of the frames into this inline frame.
5750 }
5754 PRBool positioned =
5757 nsFrameItems ibSiblings;
5759 ibSiblings);
5761 // Make sure to trigger reflow of the inline that used to be our
5762 // last one and now isn't anymore, since its GetSkipSides() has
5763 // changed.
5766 NS_FRAME_HAS_DIRTY_CHILDREN);
5768 // Recurse so we create new ib siblings as needed for aParentFrame's parent
5771 }
5774 }
5776 // Insert the frames after our aPrevSibling
5778 aFrameList);
5779 }
5781 #define UNSET_DISPLAY 255
5783 // This gets called to see if the frames corresponding to aSibling and aContent
5784 // should be siblings in the frame tree. Although (1) rows and cols, (2) row
5785 // groups and col groups, (3) row groups and captions, (4) legends and content
5786 // inside fieldsets, (5) popups and other kids of the menu are siblings from a
5787 // content perspective, they are not considered siblings in the frame tree.
5788 PRBool
5792 {
5801 }
5802 }
5812 // if we haven't already, construct a style context to find the display type of aContent
5816 PRBool providerIsChild;
5824 }
5829 }
5831 return
5834 }
5835 // To have decent performance we want to return false in cases in which
5836 // reordering the two siblings has no effect on display. To ensure
5837 // correctness, we MUST return false in cases where the two siblings have
5838 // the same desired parent type and live on different display lists.
5839 // Specificaly, columns and column groups should only consider columns and
5840 // column groups as valid siblings. Captions should only consider other
5841 // captions. All other things should consider each other as valid
5842 // siblings. The restriction in the |if| above on siblingDisplay is ok,
5843 // because for correctness the only part that really needs to happen is to
5844 // not consider captions, column groups, and row/header/footer groups
5845 // siblings of each other. Treating a column or colgroup as a valid
5846 // sibling of a non-table-related frame will just mean we end up reframing.
5849 // One's a caption and the other is not. Not valid siblings.
5851 }
5857 // One's a column or column group and the other is not. Not valid
5858 // siblings.
5860 }
5863 }
5867 // Legends can be sibling of legends but not of other content in the fieldset
5874 }
5877 }
5879 nsIFrame*
5883 PRBool aPrevSibling)
5884 {
5887 // XXX the GetContent() != aContent check is needed due to bug 135040.
5888 // Remove it once that's fixed.
5890 }
5892 // If the frame is out-of-flow, GetPrimaryFrame() will have returned the
5893 // out-of-flow frame; we want the placeholder.
5898 }
5900 // The frame we have now should never be a continuation
5904 // The frame may be a special frame (a split inline frame that
5905 // contains a block). Get the last part of that split.
5908 }
5910 // The frame may have a continuation. If so, we want the last
5911 // non-overflow-container continuation as our previous sibling.
5913 }
5918 }
5921 }
5923 nsIFrame*
5925 ChildIterator aIter,
5927 {
5930 // Note: not all content objects are associated with a frame (e.g., if it's
5931 // `display: none') so keep looking until we find a previous frame
5938 // Found a previous sibling, we're done!
5940 }
5941 }
5944 }
5946 nsIFrame*
5950 {
5952 // XXXbz Can happen when XBL lies to us about insertion points. This check
5953 // might be able to go away once bug 474324 is fixed.
5955 }
5964 // We found a next sibling, we're done!
5966 }
5967 }
5970 }
5972 // For fieldsets, returns the area frame, if the child is not a legend.
5977 {
5984 // If the parent is a fieldSet, use the fieldSet's area frame as the
5985 // parent unless the new content is a legend.
5989 }
5990 }
5992 }
5994 nsIFrame*
6002 {
6005 // Find the frame that precedes the insertion point. Walk backwards
6006 // from the parent frame to get the parent content, because if an
6007 // XBL insertion point is involved, we'll need to use _that_ to find
6008 // the preceding frame.
6018 // The check for IsRootOfAnonymousSubtree() is because editor is
6019 // severely broken and calls us directly for native anonymous
6020 // nodes that it creates.
6025 }
6026 }
6027 #ifdef DEBUG
6031 }
6032 #endif
6037 // Now, find the geometric parent so that we can handle
6038 // continuations properly. Use the prev sibling if we have it;
6039 // otherwise use the next sibling.
6042 }
6044 // If there is no previous sibling, then find the frame that follows
6047 iter--;
6048 }
6053 }
6055 // No previous or next sibling, so treat this like an appended frame.
6058 // Since we're appending, we'll walk to the last anonymous frame
6059 // that was created for the broken inline frame. But don't walk
6060 // to the trailing inline if it's empty; stop at the block.
6062 }
6063 // Get continuation that parents the last child. This MUST be done
6064 // before the AdjustAppendParentForAfterContent call.
6066 // Deal with fieldsets
6069 aChild);
6071 aParentFrame =
6076 }
6077 }
6081 }
6083 static PRBool
6085 {
6086 // IMPORTANT: This must match the conditions in nsHTMLFramesetFrame::Init.
6090 }
6092 static void
6095 #ifdef MOZ_XUL
6097 static
6098 PRBool
6100 {
6102 }
6104 static
6105 nsListBoxBodyFrame*
6107 {
6119 }
6120 }
6123 }
6124 #endif
6126 void
6131 {
6135 // Not text, or not suppressed due to being all-whitespace (if it
6136 // were being suppressed, it would have the
6137 // NS_CREATE_FRAME_IF_NON_WHITESPACE flag)
6139 }
6144 }
6146 void
6149 {
6152 // Not text, or not suppressed due to being all-whitespace (if it
6153 // were being suppressed, it would have the
6154 // NS_CREATE_FRAME_IF_NON_WHITESPACE flag)
6156 }
6160 }
6162 // We want to disable lazy frame construction for nodes that are under an
6163 // editor. We use nsINode::IsEditable, but that includes inputs with type text
6164 // and password and textareas, which are common and aren't really editable (the
6165 // native anonymous content under them is what is actually editable) so we want
6166 // to construct frames for those lazily.
6167 // The logic for this check is based on
6168 // nsGenericHTMLFormElement::UpdateEditableFormControlState and so must be kept
6169 // in sync with that. The presence of the NODE_MAY_HAVE_CONTENT_EDITABLE_ATTR
6170 // flag only indicates a contenteditable attribute, it doesn't indicate if it
6171 // is true or false, so we force eager construction in some cases when the node
6172 // is not editable, but that should be rare.
6175 {
6179 }
6181 // For inserts aChild should be valid, for appends it should be null.
6182 // Returns true if this operation can be lazy, false if not.
6183 PRBool
6187 {
6191 }
6197 }
6206 }
6207 }
6208 }
6210 // We can construct lazily; just need to set suitable bits in the content
6211 // tree.
6213 // Walk up the tree setting the NODE_DESCENDANTS_NEED_FRAMES bit as we go.
6215 #ifdef DEBUG
6216 // If we hit a node with no primary frame, or the NODE_NEEDS_FRAME bit set
6217 // we want to assert, but leaf frames that process their own children and may
6218 // ignore anonymous children (eg framesets) make this complicated. So we set
6219 // these two booleans if we encounter these situations and unset them if we
6220 // hit a node with a leaf frame.
6223 #endif
6226 #ifdef DEBUG
6229 }
6232 }
6235 }
6236 #endif
6239 }
6240 #ifdef DEBUG
6244 }
6249 #endif
6251 // Set NODE_NEEDS_FRAME on the new nodes.
6255 //XXX the aChild->GetPrimaryFrame()->GetContent() != aChild
6256 // check is needed due to bug 135040. Remove it once that's
6257 // fixed.
6264 //XXX the child->GetPrimaryFrame()->GetContent() != child
6265 // check is needed due to bug 135040. Remove it once that's
6266 // fixed.
6269 }
6270 }
6274 }
6276 void
6278 {
6286 // We could either descend first (on nodes that don't have NODE_NEEDS_FRAME
6287 // set) or issue content notifications for our kids first. In absence of
6288 // anything definitive either way we'll go with the latter.
6290 // It might be better to use GetChildArray and scan it completely first and
6291 // then issue all notifications. (We have to scan it completely first because
6292 // constructing frames can set attributes, which can change the storage of
6293 // child lists).
6295 // Scan the children of aContent to see what operations (if any) we need to
6296 // perform.
6305 //XXX the child->GetPrimaryFrame()->GetContent() != child
6306 // check is needed due to bug 135040. Remove it once that's
6307 // fixed.
6312 }
6316 // generate a ContentRangeInserted for [startOfRun,i)
6318 PR_FALSE);
6319 }
6320 }
6321 }
6324 }
6326 // Now descend.
6334 }
6335 }
6336 }
6339 {
6350 }
6351 }
6353 void
6357 PRBool aAllowLazyConstruction)
6358 {
6364 #ifdef MOZ_XUL
6365 // Except listboxes suck, so do NOT skip anything here if
6366 // we plan to notify a listbox.
6368 #endif
6369 ) {
6370 // Already have a frame or undisplayed entry for this content; a
6371 // previous ContentInserted in this loop must have reconstructed
6372 // its insertion parent. Skip it.
6374 }
6375 // Call ContentInserted with this node.
6377 aAllowLazyConstruction);
6378 }
6379 }
6381 nsIFrame*
6386 PRBool aAllowLazyConstruction)
6387 {
6388 // See if we have an XBL insertion point. If so, then that's our
6389 // real parent frame; if not, then the frame hasn't been built yet
6390 // and we just bail.
6399 // XXXbz XBL2/sXBL issue
6401 // XXXbz how would |document| be null here?
6405 }
6406 }
6409 // We have an insertion point. There are some additional tests we need to do
6410 // in order to ensure that an append is a safe operation.
6414 // We may need to make multiple ContentInserted calls instead. A
6415 // reasonable heuristic to employ (in order to maintain good performance)
6416 // is to find out if the insertion point's content node contains any
6417 // explicit children. If it does not, then it is highly likely that
6418 // an append is occurring. (Note it is not definite, and there are insane
6419 // cases we will not deal with by employing this heuristic, but it beats
6420 // always falling back to multiple ContentInserted calls).
6421 //
6422 // In the multiple insertion point case, we know we're going to need to do
6423 // multiple ContentInserted calls anyway.
6425 }
6427 // If we have multiple insertion points or if we have an insertion point
6428 // and the operation is not a true append or if the insertion point already
6429 // has explicit children, then we must fall back.
6431 // Now comes the fun part. For each inserted child, make a
6432 // ContentInserted call as if it had just gotten inserted and
6433 // let ContentInserted handle the mess.
6435 aAllowLazyConstruction);
6437 }
6438 }
6441 }
6443 PRBool
6447 {
6449 // Check whether we have any kids we care about.
6454 // Just reframe the parent, since framesets are weird like that.
6457 }
6458 }
6459 }
6461 }
6463 nsresult
6466 PRBool aAllowLazyConstruction)
6467 {
6472 #ifdef DEBUG
6477 aAllowLazyConstruction);
6480 }
6481 }
6482 #endif
6484 #ifdef MOZ_XUL
6486 PRInt32 namespaceID;
6490 // Just ignore tree tags, anyway we don't create any frames for them.
6496 }
6499 // Get the frame associated with the content
6507 }
6512 aAllowLazyConstruction);
6516 }
6522 }
6526 // Nothing to do here; we shouldn't be constructing kids of leaves
6527 // Clear lazy bits so we don't try to construct again.
6530 }
6532 #ifdef MOZ_MATHML
6538 }
6539 #endif
6541 // If the frame we are manipulating is a ``special'' frame (that is, one
6542 // that's been created as a result of a block-in-inline situation) then we
6543 // need to append to the last special sibling, not to the frame itself.
6546 #ifdef DEBUG
6551 }
6552 #endif
6554 // Since we're appending, we'll walk to the last anonymous frame
6555 // that was created for the broken inline frame. But don't walk
6556 // to the trailing inline if it's empty; stop at the block.
6558 }
6560 // Get continuation that parents the last child. This MUST be done
6561 // before the AdjustAppendParentForAfterContent call.
6564 // We should never get here with fieldsets, since they have multiple
6565 // insertion points.
6569 // Deal with possible :after generated content on the parent
6571 parentFrame =
6576 // Create some new frames
6581 // See if the containing block has :first-letter style applied.
6586 haveFirstLineStyle =
6589 }
6592 // Before we get going, remove the current letter frames
6595 }
6598 PRBool haveNoXBLChildren =
6600 FrameConstructionItemList items;
6603 haveNoXBLChildren) {
6604 // If there's a text node in the normal content list just before the new
6605 // items, and it has no frame, make a frame construction item for it. If it
6606 // doesn't need a frame, ConstructFramesFromItemList below won't give it
6607 // one. No need to do all this if our parent type is not block, though,
6608 // since WipeContainingBlock already handles that situation.
6609 //
6610 // Because we're appending, we don't need to worry about any text
6611 // after the appended content; there can only be XBL anonymous content
6612 // (text in an XBL binding is not suppressed) or generated content
6613 // (and bare text nodes are not generated). Native anonymous content
6614 // generated by frames never participates in inline layout.
6617 }
6619 child;
6622 }
6626 // Perform special check for diddling around with the frames in
6627 // a special inline frame.
6628 // If we're appending before :after content, then we're not really
6629 // appending, so let WipeContainingBlock know that.
6635 }
6638 // If the parent is a block frame, and we're not in a special case
6639 // where frames can be moved around, determine if the list is for the
6640 // start or end of the block.
6646 // :after content can't be <br> so no need to check it
6649 }
6650 // To suppress whitespace-only text frames, we have to verify that
6651 // our container's DOM child list matches its flattened tree child list.
6652 // This is guaranteed to be true if GetXBLChildNodesFor() returns null.
6655 nsFrameItems frameItems;
6659 child;
6661 // Invalidate now instead of before the WipeContainingBlock call, just in
6662 // case we do wipe; in that case we don't need to do this walk at all.
6663 // XXXbz does that matter? Would it make more sense to save some virtual
6664 // GetChildAt calls instead and do this during construction of our
6665 // FrameConstructionItemList?
6667 }
6669 // if the container is a table and a caption was appended, it needs to be put
6670 // in the outer table frame's additional child list.
6671 nsFrameItems captionItems;
6673 // Pull out the captions. Note that we don't want to do that as we go,
6674 // because processing a single caption can add a whole bunch of things to
6675 // the frame items due to pseudoframe processing. So we'd have to pull
6676 // captions from a list anyway; might as well do that here.
6677 // XXXbz this is no longer true; we could pull captions directly out of the
6678 // FrameConstructionItemList now.
6680 }
6683 // It's possible that some of the new frames go into a
6684 // first-line frame. Look at them and see...
6687 }
6689 // Notify the parent frame passing it the list of new frames
6690 // Append the flowed frames to the principal child list; captions
6691 // need special treatment
6697 captionItems);
6698 }
6699 }
6703 }
6705 // Recover first-letter frames
6708 }
6710 #ifdef DEBUG
6714 }
6715 #endif
6717 #ifdef ACCESSIBILITY
6724 }
6725 }
6726 #endif
6729 }
6731 #ifdef MOZ_XUL
6733 enum content_operation
6734 {
6735 CONTENT_INSERTED,
6736 CONTENT_REMOVED
6737 };
6739 // Helper function to lookup the listbox body frame and send a notification
6740 // for insertion or removal of content
6741 static
6745 // Only used for the removed notification
6749 content_operation aOperation)
6750 {
6755 // Except if we have an aChildFrame and its parent is not the right
6756 // thing, then we don't do this. Pseudo frames are so much fun....
6761 }
6765 }
6766 }
6769 }
6772 nsresult
6776 PRBool aAllowLazyConstruction)
6777 {
6779 aChild,
6781 aFrameState,
6782 aAllowLazyConstruction);
6783 }
6785 // ContentRangeInserted handles creating frames for a range of nodes that
6786 // aren't at the end of their childlist. ContentRangeInserted isn't a real
6787 // content notification, but rather it handles regular ContentInserted calls
6788 // for a single node as well as the lazy construction of frames for a range of
6789 // nodes when called from CreateNeededFrames. For a range of nodes to be
6790 // suitable to have its frames constructed all at once they must meet the same
6791 // conditions that ContentAppended imposes (GetRangeInsertionPoint checks
6792 // these), plus more. Namely when finding the insertion prevsibling we must not
6793 // need to consult something specific to any one node in the range, so that the
6794 // insertion prevsibling would be the same for each node in the range. So we
6795 // pass the first node in the range to GetInsertionPrevSibling, and if
6796 // IsValidSibling (the only place GetInsertionPrevSibling might look at the
6797 // passed in node itself) needs to resolve style on the node we record this and
6798 // return that this range needs to be split up and inserted separately. Table
6799 // captions need extra attention as we need to determine where to insert them
6800 // in the caption list, while skipping any nodes in the range being inserted
6801 // (because when we treat the caption frames the other nodes have had their
6802 // frames constructed but not yet inserted into the frame tree).
6803 nsresult
6808 PRBool aAllowLazyConstruction)
6809 {
6816 // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and
6817 // the :empty pseudo-class?
6818 #ifdef DEBUG
6824 aAllowLazyConstruction);
6830 }
6831 }
6832 }
6833 #endif
6843 #ifdef MOZ_XUL
6847 // The insert case in NotifyListBoxBody
6848 // doesn't use "old next sibling".
6852 }
6854 // We don't handle a range insert to a listbox parent, issue single
6855 // ContertInserted calls for each node inserted.
6858 aAllowLazyConstruction);
6861 }
6862 }
6865 // If we have a null parent, then this must be the document element being
6866 // inserted, or some other child of the document in the DOM (might be a PI,
6867 // say).
6874 // Not the root element; just bail out
6876 }
6881 // Create frames for the document element and its child elements
6887 #ifdef DEBUG
6892 }
6893 #endif
6894 }
6896 #ifdef ACCESSIBILITY
6903 }
6904 }
6905 #endif
6908 }
6910 // Otherwise, we've got parent content. Find its frame.
6918 }
6921 // See if we have an XBL insertion point. If so, then that's our
6922 // real parent frame; if not, then the frame hasn't been built yet
6923 // and we just bail.
6931 // Get our insertion point. If we need to issue single ContentInserted's
6932 // GetRangeInsertionPoint will take care of that for us.
6936 aAllowLazyConstruction);
6940 }
6941 }
6948 // check if range insert is safe
6950 // must fall back to a single ContertInserted for each child in the range
6953 aAllowLazyConstruction);
6956 }
6965 }
6968 // We should only get here with fieldsets when doing a single insert, because
6969 // fieldsets have multiple insertion points.
6974 // Just reframe the parent, since figuring out whether this
6975 // should be the new legend and then handling it is too complex.
6976 // We could do a little better here --- check if the fieldset already
6977 // has a legend which occurs earlier in its child list than this node,
6978 // and if so, proceed. But we'd have to extend nsFieldSetFrame
6979 // to locate this legend in the inserted frames and extract it.
6984 }
6986 // Don't construct kids of leaves
6988 // Clear lazy bits so we don't try to construct again.
6991 }
6993 #ifdef MOZ_MATHML
6999 }
7000 #endif
7005 aFrameState);
7008 // Recover state for the containing block - we need to know if
7009 // it has :first-letter or :first-line style applied to it. The
7010 // reason we care is that the internal structure in these cases
7011 // is not the normal structure and requires custom updating
7012 // logic.
7017 // In order to shave off some cycles, we only dig up the
7018 // containing block haveFirst* flags if the parent frame where
7019 // the insertion/append is occurring is an inline or block
7020 // container. For other types of containers this isn't relevant.
7023 // Examine the parentFrame where the insertion is taking
7024 // place. If it's a certain kind of container then some special
7025 // processing is done.
7030 // Recover the special style flags for the containing block
7033 haveFirstLineStyle =
7036 }
7039 // If our current parentFrame is a Letter frame, use its parent as our
7040 // new parent hint
7042 // If parentFrame is out of flow, then we actually want the parent of
7043 // the placeholder frame.
7051 }
7052 }
7054 // Remove the old letter frames before doing the insertion
7059 // Removing the letterframes messes around with the frame tree, removing
7060 // and creating frames. We need to reget our prevsibling, parent frame,
7061 // etc.
7066 // Need check whether a range insert is still safe.
7068 // Need to recover the letter frames first.
7071 // must fall back to a single ContertInserted for each child in the range
7074 aAllowLazyConstruction);
7077 }
7081 }
7082 }
7085 // We're inserting the new frames as the first child. See if the
7086 // parent has a :before pseudo-element
7092 // Insert the new frames after the last continuation of the :before
7095 // Don't change isAppend here; we'll can call AppendFrames as needed, and
7096 // the change to our prevSibling doesn't affect that.
7097 }
7098 }
7100 FrameConstructionItemList items;
7102 PRBool haveNoXBLChildren =
7106 // If there's a text node in the normal content list just before the
7107 // new nodes, and it has no frame, make a frame construction item for
7108 // it, because it might need a frame now. No need to do this if our
7109 // parent type is not block, though, since WipeContainingBlock
7110 // already handles that sitation.
7112 items);
7113 }
7124 }
7125 }
7128 // If there's a text node in the normal content list just after the
7129 // new nodes, and it has no frame, make a frame construction item for
7130 // it, because it might need a frame now. No need to do this if our
7131 // parent type is not block, though, since WipeContainingBlock
7132 // already handles that sitation.
7134 }
7136 // Perform special check for diddling around with the frames in
7137 // a special inline frame.
7138 // If we're appending before :after content, then we're not really
7139 // appending, so let WipeContainingBlock know that.
7145 }
7148 // If the container is a table and a caption will be appended, it needs to be
7149 // put in the outer table frame's additional child list.
7150 // We make no attempt here to set flags to indicate whether the list
7151 // will be at the start or end of a block. It doesn't seem worthwhile.
7160 }
7165 }
7166 }
7168 // If the parent of our current prevSibling is different from the frame we'll
7169 // actually use as the parent, then the calculated insertion point is now
7170 // invalid and as it is unknown where to insert correctly we append instead
7171 // (bug 341858).
7172 // This can affect our prevSibling and isAppend, but should not have any
7173 // effect on the WipeContainingBlock above, since this should only happen
7174 // when neither parent is a special frame and should not affect whitespace
7175 // handling inside table-related frames (and in fact, can only happen when
7176 // one of the parents is an outer table and one is an inner table or when the
7177 // parent is a fieldset or fieldset content frame). So it won't affect the
7178 // {ib} or XUL box cases in WipeContainingBlock(), and the table pseudo
7179 // handling will only be affected by us maybe thinking we're not inserting
7180 // at the beginning, whereas we really are. That would have made us reframe
7181 // unnecessarily, but that's ok.
7182 // XXXbz we should push our frame construction item code up higher, so we
7183 // know what our items are by the time we start figuring out previous
7184 // siblings
7187 #ifdef DEBUG
7200 #endif
7203 parentFrame =
7205 container,
7209 }
7212 // It's possible that the new frame goes into a first-line
7213 // frame. Look at it and see...
7215 // Use append logic when appending
7218 }
7220 // Use more complicated insert logic when inserting
7221 // XXXbz this method is a no-op, so it's easy for the args being passed
7222 // here to make no sense without anyone noticing... If it ever stops
7223 // being a no-op, vet them carefully!
7226 }
7227 }
7229 // We might have captions; put them into the caption list of the
7230 // outer table frame.
7235 // We need to determine where to put the caption items; start with the
7236 // the parent frame that has already been determined and get the insertion
7237 // prevsibling of the first caption item.
7239 PRBool captionIsAppend;
7242 // aIsRangeInsertSafe is ignored on purpose because it is irrelevant here.
7243 PRBool ignored;
7245 captionPrevSibling =
7250 // It is very important here that we skip the children in
7251 // [aStartChild,aEndChild) when looking for a
7252 // prevsibling.
7253 captionPrevSibling =
7257 }
7262 // If the parent is not an outer table frame we will try to add frames
7263 // to a named child list that the parent does not honour and the frames
7264 // will get lost
7266 "Pseudo frame construction failure; "
7269 // If the parent of our current prevSibling is different from the frame
7270 // we'll actually use as the parent, then the calculated insertion
7271 // point is now invalid (bug 341382).
7275 }
7278 captionItems);
7282 }
7283 }
7284 }
7287 // Notify the parent frame
7292 frameItems);
7293 }
7294 }
7297 // Recover the letter frames for the containing block when
7298 // it has first-letter style.
7300 }
7302 #ifdef DEBUG
7306 }
7307 #endif
7309 #ifdef ACCESSIBILITY
7316 }
7317 }
7318 #endif
7321 }
7323 nsresult
7327 RemoveFlags aFlags,
7329 {
7336 // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and
7337 // the :empty pseudo-class?
7339 #ifdef DEBUG
7348 }
7349 }
7350 #endif
7356 // Find the child frame that maps the content
7360 // XXXbz the GetContent() != aChild check is needed due to bug 135040.
7361 // Remove it once that's fixed.
7363 }
7365 #ifdef MOZ_XUL
7372 // If we're removing the root, then make sure to remove things starting at
7373 // the viewport's child instead of the primary frame (which might even be
7374 // null if the root had an XBL binding or display:none, even though the
7375 // frames above it got created). We do the adjustment after the childFrame
7376 // check above, because we do want to clear any undisplayed content we might
7377 // have for the root. Detecting removal of a root is a little exciting; in
7378 // particular, having a null aContainer is necessary but NOT sufficient. Due
7379 // to how we process reframes, the content node might not even be in our
7380 // document by now. So explicitly check whether the viewport's first kid's
7381 // content node is aChild.
7391 }
7392 }
7393 }
7398 // See whether we need to remove more than just childFrame
7404 }
7407 // Get the childFrame's parent frame
7413 // Just reframe the parent, since framesets are weird like that.
7419 }
7421 #ifdef MOZ_MATHML
7422 // If we're a child of MathML, then we should reframe the MathML content.
7423 // If we're non-MathML, then we would be wrapped in a block so we need to
7424 // check our grandparent in that case.
7433 }
7434 #endif
7436 // Undo XUL wrapping if it's no longer needed.
7437 // (If we're in the XUL block-wrapping situation, parentFrame is the
7438 // wrapper frame.)
7442 // check if this frame is the only one needing wrapping
7450 }
7452 #ifdef ACCESSIBILITY
7458 }
7459 }
7460 #endif
7462 // Examine the containing-block for the removed content and see if
7463 // :first-letter style applies.
7468 }
7473 // Trap out to special routine that handles adjusting a blocks
7474 // frame tree when first-letter style is present.
7475 #ifdef NOISY_FIRST_LETTER
7483 #endif
7485 // First update the containing blocks structure by removing the
7486 // existing letter frames. This makes the subsequent logic
7487 // simpler.
7489 containingBlock);
7491 // Recover childFrame and parentFrame
7494 // XXXbz the GetContent() != aChild check is needed due to bug 135040.
7495 // Remove it once that's fixed.
7498 }
7502 #ifdef NOISY_FIRST_LETTER
7508 #endif
7509 }
7511 #ifdef DEBUG
7517 }
7518 #endif
7521 // Notify the parent frame that it should delete the frame
7526 }
7528 childFrame);
7529 //XXXfr NS_ENSURE_SUCCESS(rv, rv) ?
7539 }
7543 }
7545 // If we're just reconstructing frames for the element, then the
7546 // following ContentInserted notification on the element will
7547 // take care of fixing up any adjacent text nodes. We don't need
7548 // to do this if the table parent type of our parent type is not
7549 // eTypeBlock, though, because in that case the whitespace isn't
7550 // being suppressed due to us anyway.
7554 // Adjacent whitespace-only text nodes might have been suppressed if
7555 // this node does not have inline ends. Create frames for them now
7556 // if necessary.
7557 // Reframe any text node just before the node being removed, if there is
7558 // one, and if it's not the last child or the first child. If a whitespace
7559 // textframe was being suppressed and it's now the last child or first
7560 // child then it can stay suppressed since the parent must be a block
7561 // and hence it's adjacent to a block end.
7562 // If aOldNextSibling is null, then the text node before the node being
7563 // removed is the last node, and we don't need to worry about it.
7570 }
7571 }
7572 // Reframe any text node just after the node being removed, if there is
7573 // one, and if it's not the last child or the first child.
7579 }
7580 }
7582 #ifdef DEBUG
7586 }
7587 #endif
7588 }
7591 }
7593 #ifdef DEBUG
7594 // To ensure that the functions below are only called within
7595 // |ApplyRenderingChangeToTree|.
7597 #endif
7599 static void
7603 nsChangeHint aChange);
7605 /**
7606 * @param aBoundsRect returns the bounds enclosing the areas covered by aFrame and its childre
7607 * This rect is relative to aFrame's parent
7608 */
7609 static void
7612 nsChangeHint aChange)
7613 {
7622 }
7623 }
7625 // now do children of frame
7634 // only do frames that don't have placeholders
7636 // do the out-of-flow frame and its continuations
7651 }
7653 }
7654 }
7656 }
7659 }
7661 static void
7665 nsChangeHint aChange)
7666 {
7671 // Get view if this frame has one and trigger an update. If the
7672 // frame doesn't have a view, find the nearest containing view
7673 // (adjusting r's coordinate system to reflect the nesting) and
7674 // update there.
7677 // if frame has view, will already be invalidated
7680 #ifdef MOZ_SVG
7684 // We need this to invalidate frames when their 'filter' or 'marker'
7685 // property changes. XXX in theory changes to 'marker' should be
7686 // handled in nsSVGPathGeometryFrame::DidSetStyleContext, but for
7687 // some reason that's broken.
7688 //
7689 // This call is also currently the only mechanism for invalidating
7690 // the area covered by a <foreignObject> when 'opacity' changes on
7691 // it or one of its ancestors. (For 'opacity' changes on <image> or
7692 // a graphical element such as <path>, or on one of their
7693 // ancestors, this is redundant since
7694 // nsSVGPathGeometryFrame::DidSetStyleContext also invalidates.)
7696 }
7697 }
7698 #endif
7701 }
7702 }
7707 }
7713 }
7714 }
7715 }
7717 static void
7720 nsChangeHint aChange)
7721 {
7724 // Don't allow synchronous rendering changes when painting is turned off.
7728 }
7729 }
7731 // If the frame's background is propagated to an ancestor, walk up to
7732 // that ancestor.
7737 }
7741 // Trigger rendering updates by damaging this frame and any
7742 // continuations of this frame.
7744 // XXX this needs to detect the need for a view due to an opacity change and deal with it...
7748 #ifdef DEBUG
7750 #endif
7752 aChange);
7753 #ifdef DEBUG
7755 #endif
7758 }
7760 /**
7761 * This method invalidates the canvas when frames are removed or added for a
7762 * node that might have its background propagated to the canvas, i.e., a
7763 * document root node or an HTML BODY which is a child of the root node.
7764 *
7765 * @param aFrame a frame for a content node about to be removed or a frame that
7766 * was just created for a content node that was inserted.
7767 */
7768 static void
7770 {
7774 // Note that both in ContentRemoved and ContentInserted the content node
7775 // will still have the right parent pointer, so looking at that is ok.
7779 // Has a parent; might not be what we want
7782 // Has a grandparent, so not what we want
7784 }
7786 // Check whether it's an HTML body
7790 }
7791 }
7793 // At this point the node has no parent or it's an HTML <body> child of the
7794 // root. We might not need to invalidate in this case (eg we might be in
7795 // XHTML or something), but chances are we want to. Play it safe.
7796 // Invalidate the viewport.
7798 // Wrap this in a DEFERRED view update batch so we don't try to
7799 // flush out layout here
7805 }
7807 nsresult
7809 nsChangeHint aHint)
7810 {
7811 // If the frame hasn't even received an initial reflow, then don't
7812 // send it a style-change reflow!
7816 #ifdef DEBUG
7821 }
7822 #endif
7833 }
7835 nsFrameState dirtyBits;
7840 }
7848 }
7850 nsresult
7853 {
7861 #ifdef DEBUG
7865 #endif
7870 }
7872 // Find the child frame
7875 // Notify the first frame that maps the content. It will generate a reflow
7876 // command
7878 // It's possible the frame whose content changed isn't inserted into the
7879 // frame hierarchy yet, or that there is no frame that maps the content
7881 #if 0
7886 #endif
7888 // Special check for text content that is a child of a letter frame. If
7889 // this happens, we should remove the letter frame, do whatever we're
7890 // planning to do with this notification, then put the letter frame back.
7891 // Note that this is basically what RecreateFramesForContent ends up doing;
7892 // the reason we dont' want to call that here is that our text content
7893 // could be native anonymous, in which case RecreateFramesForContent would
7894 // completely barf on it. And recreating the non-anonymous ancestor would
7895 // just lead us to come back into this notification (e.g. if quotes or
7896 // counters are involved), leading to a loop.
7900 // See if the block has first-letter style applied to it.
7905 // Reget |frame|, since we might have killed it.
7906 // Do we really need to call CharacterDataChanged in this case, though?
7909 }
7910 }
7916 }
7917 }
7920 }
7924 nsresult
7926 {
7933 // Make sure to not rebuild quote or counter lists while we're
7934 // processing restyles
7940 // Mark frames so that we skip frames that die along the way, bug 123049.
7941 // A frame can be in the list multiple times with different hints. Further
7942 // optmization is possible if nsStyleChangeList::AppendChange could coalesce
7951 }
7952 }
7961 nsChangeHint hint;
7969 // XXXbz this is due to image maps messing with the primary frame of
7970 // <area>s. See bug 135040. Remove this block once that's fixed.
7974 }
7975 }
7977 // skip any frame that has been destroyed due to a ripple effect
7981 }
7987 #ifdef MOZ_SVG
7990 }
7991 #endif
7995 }
8000 }
8003 }
8004 }
8005 }
8010 // RepaintFrame changes can indicate changes in opacity etc which
8011 // can require plugin clipping to change. If we requested a reflow,
8012 // we don't need to do this since the reflow will do it for us.
8017 }
8018 }
8020 // cleanup references and verify the style tree. Note that the latter needs
8021 // to happen once we've processed the whole list, since until then the tree
8022 // is not in fact in a consistent state.
8029 }
8031 #ifdef DEBUG
8032 // reget frame from content since it may have been regenerated...
8037 }
8040 }
8041 #endif
8042 }
8046 }
8048 void
8051 nsChangeHint aMinHint,
8053 PRBool aRestyleDescendants)
8054 {
8058 // XXXbz this is due to image maps messing with the primary frame pointer
8059 // of <area>s. See bug 135040. We can remove this block once that's fixed.
8061 }
8068 nsStyleChangeList changeList;
8074 // no frames, reconstruct for content
8076 }
8077 }
8079 nsresult
8082 nsEventStates aStateMask)
8083 {
8084 // XXXbz it would be good if this function only took Elements, but
8085 // we'd have to make ESM guarantee that usefully.
8088 }
8091 }
8093 }
8095 void
8097 nsEventStates aStateMask)
8098 {
8104 // Any change to a content state that affects which frames we construct
8105 // must lead to a frame reconstruct here if we already have a frame.
8106 // Note that we never decide through non-CSS means to not create frames
8107 // based on content states, so if we already don't have a frame we don't
8108 // need to force a reframe -- if it's needed, the HasStateDependentStyle
8109 // call will handle things.
8112 // If it's generated content, ignore LOADING/etc state changes on it.
8115 NS_EVENT_STATE_USERDISABLED |
8116 NS_EVENT_STATE_SUPPRESSED |
8117 NS_EVENT_STATE_LOADING)) {
8129 }
8130 }
8131 }
8132 }
8133 }
8135 nsRestyleHint rshint =
8140 }
8143 // Exposing information to the page about whether the link is
8144 // visited or not isn't really something we can worry about here.
8145 // FIXME: We could probably do this a bit better.
8147 }
8150 }
8152 void
8154 PRInt32 aNameSpaceID,
8156 PRInt32 aModType)
8157 {
8158 nsRestyleHint rshint =
8160 aElement,
8161 aAttribute,
8162 aModType,
8163 PR_FALSE);
8165 }
8167 void
8169 PRInt32 aNameSpaceID,
8171 PRInt32 aModType)
8172 {
8173 // Hold onto the PresShell to prevent ourselves from being destroyed.
8174 // XXXbz how, exactly, would this attribute change cause us to be
8175 // destroyed from inside this function?
8178 // Get the frame associated with the content which is the highest in the frame tree
8181 #if 0
8185 #endif
8187 // the style tag has its own interpretation based on aHint
8192 #ifdef MOZ_XUL
8193 // The following listbox widget trap prevents offscreen listbox widget
8194 // content from being removed and re-inserted (which is what would
8195 // happen otherwise).
8197 PRInt32 namespaceID;
8205 }
8209 {
8216 }
8217 }
8222 // See if we have appearance information for a theme.
8232 }
8233 }
8235 // let the frame deal with it now, so we don't have to deal later
8237 // XXXwaterson should probably check for special IB siblings
8238 // here, and propagate the AttributeChanged notification to
8239 // them, as well. Currently, inline frames don't do anything on
8240 // this notification, so it's not that big a deal.
8241 }
8243 // See if we can optimize away the style re-resolution -- must be called after
8244 // the frame's AttributeChanged() in case it does something that affects the style
8245 nsRestyleHint rshint =
8247 aElement,
8248 aAttribute,
8249 aModType,
8250 PR_TRUE);
8253 }
8255 void
8264 }
8267 }
8269 void
8271 {
8273 // This is the end of our last update. Before we decrement
8274 // mUpdateCount, recalc quotes and counters as needed.
8278 }
8280 }
8282 void
8284 {
8288 }
8293 }
8297 }
8299 void
8301 {
8302 #if defined(DEBUG_dbaron_off)
8304 #endif
8308 // Prevent frame tree destruction from being O(N^2)
8312 // Remove our presshell as a style flush observer. But leave
8313 // mObservingRefreshDriver true so we don't readd to it even if someone tries
8314 // to post restyle events on us from this point on for some reason.
8317 }
8319 //STATIC
8321 // XXXbz I'd really like this method to go away. Once we have inline-block and
8322 // I can just use that for sized broken images, that can happen, maybe.
8326 {
8327 // The "alt" attribute specifies alternate text that is rendered
8328 // when the image can not be displayed
8330 // If there's no "alt" attribute, and aContent is an input
8331 // element, then use the value of the "value" attribute
8334 // If there's no "value" attribute either, then use the localized string
8335 // for "Submit" as the alternate text.
8339 }
8340 }
8341 }
8343 nsresult
8351 {
8358 // Create a continuing inner table frame, and if there's a caption then
8359 // replicate the caption
8360 nsFrameItems newChildFrames;
8371 }
8375 }
8377 // Set the outer table's initial child list
8382 }
8386 }
8387 }
8389 nsresult
8397 {
8404 // Replicate any header/footer frames
8405 nsFrameItems childFrames;
8408 // See if it's a header/footer, possibly wrapped in a scroll frame.
8411 // If the row group was continued, then don't replicate it.
8415 }
8417 // Replicate the header/footer frame.
8419 nsFrameItems childItems;
8422 nsnull);
8431 nsnull);
8436 // Table specific initialization
8439 // XXX Deal with absolute and fixed frames...
8441 }
8442 }
8444 // Set the table frame's initial child list
8449 }
8453 }
8454 }
8456 nsresult
8461 PRBool aIsFluid)
8462 {
8470 // Use the frame type to determine what type of frame to create
8483 }
8491 }
8499 }
8501 #ifdef MOZ_XUL
8508 }
8509 #endif
8516 }
8524 }
8544 }
8553 // Create a continuing frame for each table cell frame
8554 nsFrameItems newChildList;
8557 // See if it's a table cell frame
8567 }
8569 }
8571 }
8573 // Set the table cell's initial child list
8575 }
8578 // Warning: If you change this and add a wrapper frame around table cell
8579 // frames, make sure Bug 368554 doesn't regress!
8580 // See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.
8587 // Create a continuing area frame
8596 }
8598 // Set the table cell's initial child list
8600 }
8608 }
8616 }
8623 }
8629 }
8631 // create a continuing out of flow frame
8638 }
8639 // create a continuing placeholder frame
8648 }
8657 // Create a continuing area frame
8658 // XXXbz we really shouldn't have to do this by hand!
8667 }
8668 // Set the fieldset's initial child list
8670 }
8677 }
8682 }
8688 }
8690 // Init() set newFrame to be a fluid continuation of aFrame.
8691 // If we want a non-fluid continuation, we need to call SetPrevContinuation()
8692 // to reset NS_FRAME_IS_FLUID_CONTINUATION.
8695 }
8697 // A continuation of generated content is also generated content
8700 }
8702 // A continuation of an out-of-flow is also an out-of-flow
8705 }
8713 }
8717 }
8719 nsresult
8721 {
8722 // Now deal with fixed-pos things.... They should appear on all pages,
8723 // so we want to move over the placeholders when processing the child
8724 // of the pageContentFrame.
8729 }
8733 // document's root element frame missing
8735 }
8737 nsFrameItems fixedPlaceholders;
8741 }
8743 // Don't allow abs-pos descendants of the fixed content to escape the content.
8744 // This should not normally be possible (because fixed-pos elements should
8745 // be absolute containers) but fixed-pos tables currently aren't abs-pos
8746 // containers.
8748 nsnull,
8749 mRootElementFrame);
8752 // Iterate across fixed frames and replicate each whose placeholder is a
8753 // descendant of aFrame. (We don't want to explicitly copy placeholders that
8754 // are within fixed frames, because that would cause duplicates on the new
8755 // page - bug 389619)
8763 }
8764 }
8766 // Add the placeholders to our primary child list.
8767 // XXXbz this is a little screwed up, since the fixed frames will have
8768 // broken auto-positioning. Oh, well.
8773 }
8775 nsresult
8780 {
8781 // Make the insertion point be the parent frame by default, in case
8782 // we have to bail early.
8793 // We've got an explicit insertion child. Check to see if it's
8794 // anonymous.
8796 // This child content is anonymous. Don't use the insertion
8797 // point, since that's only for the explicit kids.
8799 }
8801 PRUint32 index;
8803 aChildContent,
8805 }
8807 PRBool multiple;
8808 PRUint32 index;
8814 }
8819 // Use the content insertion frame of the insertion point.
8823 }
8825 // There was no frame created yet for the insertion point.
8827 }
8828 }
8830 // fieldsets have multiple insertion points. Note that we might
8831 // have to look at insertionElement here...
8837 }
8838 }
8841 }
8843 // Capture state for the frame tree rooted at the frame associated with the
8844 // content object, aContent
8845 nsresult
8848 {
8852 }
8855 }
8857 }
8859 // Capture state for the frame tree rooted at aFrame.
8860 nsresult
8863 {
8866 }
8868 }
8870 nsresult
8872 {
8878 // The parent has a frame, so try resolving a new context.
8885 }
8886 }
8888 }
8892 {
8897 }
8899 }
8903 {
8910 }
8912 PRBool
8915 {
8923 // The removal functions can't handle removal of an {ib} split directly; we
8924 // need to rebuild the containing block.
8925 #ifdef DEBUG
8931 }
8932 #endif
8936 }
8940 // When we remove the legend for a fieldset, we should reframe
8941 // the fieldset to ensure another legend is used, if there is one
8944 }
8946 // Now check for possibly needing to reconstruct due to a pseudo parent
8955 // If we're a table-column-group, then the GetFirstChild check above is
8956 // not going to catch cases when we're the first child.
8959 // Similar if we're a table-caption.
8962 // We're the first or last frame in the pseudo. Need to reframe.
8963 // Good enough to recreate frames for |parent|'s content
8966 }
8967 }
8969 // Might need to reconstruct things if this frame's nextSibling is a table
8970 // pseudo, since removal of this frame might mean that this pseudo needs to
8971 // get merged with the frame's prevSibling.
8972 // XXXbz it would be really nice if we had the prevSibling here too, to check
8973 // whether this is in fact the case...
8978 #ifdef DEBUG
8984 }
8985 #endif
8986 // Good enough to recreate frames for aFrame's parent's content; even if
8987 // aFrame's parent is a table pseudo, that'll be the right content node.
8990 }
8992 #ifdef MOZ_XUL
8998 }
8999 }
9000 #endif
9002 // We might still need to reconstruct things if the parent of inFlowFrame is
9003 // special, since in that case the removal of aFrame might affect the
9004 // splitting of its parent.
9007 }
9009 // If inFlowFrame is not the only in-flow child of |parent|, then removing
9010 // it will change nothing about the {ib} split.
9014 }
9016 // If the parent is the first or last part of the {ib} split, then
9017 // removing one of its kids will have no effect on the splitting.
9018 // Get the first continuation up front so we don't have to do it twice.
9023 }
9025 #ifdef DEBUG
9031 }
9032 #endif
9036 }
9038 nsresult
9040 PRBool aAsyncInsert)
9041 {
9044 // If there is no document, we don't want to recreate frames for it. (You
9045 // shouldn't generally be giving this method content without a document
9046 // anyway).
9047 // Rebuilding the frame tree can have bad effects, especially if it's the
9048 // frame tree for chrome (see bug 157322).
9051 // Is the frame `special'? If so, we need to reframe the containing
9052 // block *here*, rather than trying to remove and re-insert the
9053 // content (which would otherwise result in *two* nested reframe
9054 // containing block from ContentRemoved() and ContentInserted(),
9055 // below!). We'd really like to optimize away one of those
9056 // containing block reframes, hence the code here.
9060 // Reframe the topmost MathML element to prevent exponential blowup
9061 // (see bug 397518)
9069 }
9070 }
9076 }
9080 // If the parent frame is a leaf then the subsequent insert will fail to
9081 // create a frame, so we need to recreate the parent content. This happens
9082 // with native anonymous content from the editor.
9086 }
9087 }
9093 }
9096 // XXXbz how can containerNode be null here?
9098 // Before removing the frames associated with the content object,
9099 // ask them to save their state onto a temporary state object.
9102 // Need the nsIContent parent, which might be null here, since we need to
9103 // pass it to ContentInserted and ContentRemoved.
9106 // Remove the frames associated with the content object.
9107 PRBool didReconstruct;
9110 nsnull :
9115 // Now, recreate the frames associated with this content object. If
9116 // ContentRemoved triggered reconstruction, then we don't need to do this
9117 // because the frames will already have been built.
9120 nsChangeHint_ReconstructFrame);
9123 }
9124 }
9125 }
9128 }
9130 //////////////////////////////////////////////////////////////////////
9132 // Block frame construction code
9137 {
9142 aStyleContext);
9143 }
9145 }
9150 {
9155 aStyleContext);
9156 }
9158 }
9160 // Predicate to see if a given content (block element) has
9161 // first-letter style applied to it.
9162 PRBool
9165 {
9169 }
9171 PRBool
9173 {
9179 }
9181 PRBool
9184 {
9185 PRBool hasFirstLine =
9190 // But disable for fieldsets
9191 PRInt32 namespaceID;
9194 // This check must match the one in FindHTMLData.
9197 }
9200 }
9202 void
9207 {
9212 }
9214 /* static */
9219 FCDATA_USE_CHILD_ITEMS |
9223 },
9226 FCDATA_USE_CHILD_ITEMS |
9230 },
9234 FCDATA_SKIP_ABSPOS_PUSH |
9236 NS_NewTableRowGroupFrame),
9238 },
9242 FCDATA_SKIP_ABSPOS_PUSH |
9244 NS_NewTableColGroupFrame),
9246 },
9251 }
9252 };
9254 /*
9255 * This function works as follows: we walk through the child list (aItems) and
9256 * find items that cannot have aParentFrame as their parent. We wrap
9257 * continuous runs of such items into a FrameConstructionItem for a frame that
9258 * gets them closer to their desired parents. For example, a run of non-row
9259 * children of a row-group will get wrapped in a row. When we later construct
9260 * the frame for this wrapper (in this case for the row), it'll be the correct
9261 * parent for the cells in the set of items we wrapped or we'll wrap cells
9262 * around everything else. At the end of this method, aItems is guaranteed to
9263 * contain only items for frames that can be direct kids of aParentFrame.
9264 */
9265 nsresult
9269 {
9272 // Nothing to do here
9274 }
9279 // Nothing else to do here; we're finished
9281 }
9283 // Now we're pointing to the first child that wants a different parent
9284 // type.
9286 // Now try to figure out what kids we can group together. We can generally
9287 // group everything that has a different desired parent type from us. Two
9288 // exceptions to this:
9289 // 1) If our parent type is table, we can't group columns with anything
9290 // else other than whitespace.
9291 // 2) Whitespace that lies between two things we can group which both want
9292 // a non-block parent should be dropped, even if we can't group them
9293 // with each other and even if the whitespace wants a parent of
9294 // ourParentType. Ends of the list count as things that don't want a
9295 // block parent (so that for example we'll drop a whitespace-only list).
9301 // Just group them all and be done with it. We need the check for
9302 // eTypeBlock here to catch the "all the items are whitespace" case
9303 // described above.
9306 // Locate the end of the group.
9308 // Keep track of the type the previous item wanted, in case we have to
9309 // deal with whitespace. Start it off with ourParentType, since that's
9310 // the last thing |iter| would have skipped over.
9313 /* Walk an iterator past any whitespace that we might be able to drop from the list */
9320 // See whether we can drop the whitespace
9329 }
9333 }
9336 // Update groupingParentType, since it might have been eTypeBlock
9337 // just because of the whitespace.
9339 }
9340 }
9341 }
9343 // Now endIter points to a non-whitespace item or a non-droppable
9344 // whitespace item. In the latter case, if this is the end of the group
9345 // we'll traverse this whitespace again. But it'll all just be quick
9346 // DesiredParentType() checks which will match ourParentType (that's
9347 // what it means that this is the group end), so it's OK.
9350 // End the group at endIter.
9352 }
9357 // Either we started with columns and now found something else, or vice
9358 // versa. In any case, end the grouping.
9360 }
9362 // Include the whitespace we didn't drop (if any) in the group, since
9363 // this is not the end of the group. Note that this doesn't change
9364 // prevParentType, since if we didn't drop the whitespace then we ended
9365 // at something that wants a block parent.
9370 }
9373 // Nothing to wrap here; just skipped some whitespace
9375 }
9377 // Now group together all the items between iter and endIter. The right
9378 // parent type to use depends on ourParentType.
9379 ParentType wrapperType;
9385 // The parent type for a cell is eTypeBlock, since that's what a cell
9386 // looks like to its kids.
9393 // Either colgroup or rowgroup, depending on what we're grouping.
9400 }
9410 }
9416 // Use the content of our parent frame
9417 parentContent,
9418 // Lie about the tag; it doesn't matter anyway
9419 pseudoType,
9420 // The namespace does matter, however; it needs
9421 // to match that of our first child item to
9422 // match the old behavior
9424 // no pending binding
9425 nsnull,
9427 PR_TRUE);
9431 }
9433 // Here we're cheating a tad... technically, table-internal items should be
9434 // inline if aParentFrame is inline, but they'll get wrapped in an
9435 // inline-table in the end, so it'll all work out. In any case, arguably
9436 // we don't need to maintain this state at this point... but it's better
9437 // to, I guess.
9441 // Table pseudo frames always induce line boundaries around their
9442 // contents.
9445 // The parent of the items in aItems is also the parent of the items
9446 // in mChildItems
9450 // Eat up all items between |iter| and |endIter| and put them in our wrapper
9451 // Advances |iter| to point to |endIter|.
9456 // Now |iter| points to the item that was the first one we didn't wrap;
9457 // loop and see whether we need to skip it or wrap it in something
9458 // different.
9462 }
9464 inline nsresult
9469 {
9473 #ifdef DEBUG
9477 }
9478 #endif
9483 }
9489 }
9491 nsresult
9500 {
9503 "Parent frame in ProcessChildren should be its own "
9506 // XXXbz ideally, this would do all the pushing of various
9507 // containing blocks as needed, so callers don't have to do it...
9513 }
9515 // The logic here needs to match the logic in GetFloatContainingBlock()
9516 nsFrameConstructorSaveState floatSaveState;
9522 }
9525 aPendingBinding);
9527 FrameConstructionItemList itemsToConstruct;
9530 // If we have first-letter or first-line style then frames can get
9531 // moved around so don't set these flags.
9535 }
9537 // Create any anonymous frames we need here. This must happen before the
9538 // non-anonymous children are processed to ensure that popups are never
9539 // constructed before the popupset.
9543 #ifdef DEBUG
9546 "If you need to use CreateFrameFor, you need to call "
9547 "CreateAnonymousFrames manually and not follow the standard "
9549 #endif
9551 itemsToConstruct);
9552 }
9555 // :before/:after content should have the same style context parent
9556 // as normal kids.
9557 // Note that we don't use this style context for looking up things like
9558 // special block styles because in some cases involving table pseudo-frames
9559 // it has nothing to do with the parent frame's desired behavior.
9563 styleContext =
9565 // Probe for generated content before
9568 itemsToConstruct);
9569 }
9576 // Frame construction item construction should not post
9577 // restyles, so removing restyle flags here is safe.
9580 }
9582 itemsToConstruct);
9583 }
9587 // Probe for generated content after
9590 itemsToConstruct);
9591 }
9594 }
9597 aFrameItems);
9605 }
9608 aFrameItems);
9609 }
9611 // We might end up with first-line frames that change
9612 // AnyKidsNeedBlockParent() without changing itemsToConstruct, but that
9613 // should never happen for cases whan aFrame->IsBoxFrame().
9622 // XXXbz we could do this on the FrameConstructionItemList level,
9623 // no? And if we cared we could look through the item list
9624 // instead of groveling through the framelist here..
9634 message,
9643 frameStyleContext);
9645 // We might, in theory, want to set NS_BLOCK_FLOAT_MGR and
9646 // NS_BLOCK_MARGIN_ROOT, but I think it's a bad idea given that
9647 // a real block placed here wouldn't get those set on it.
9661 }
9664 }
9666 //----------------------------------------------------------------------
9668 // Support for :first-line style
9670 // Special routine to handle placing a list of frames into a block
9671 // frame that has first-line style. The routine ensures that the first
9672 // collection of inline frames end up in a first-line frame.
9673 // NOTE: aState may have containing block information related to a
9674 // different part of the frame tree than where the first line occurs.
9675 // In particular aState may be set up for where ContentInserted or
9676 // ContentAppended is inserting content, which may be some
9677 // non-first-in-flow continuation of the block to which the first-line
9678 // belongs. So this function needs to be careful about how it uses
9679 // aState.
9680 nsresult
9687 {
9690 // Find the part of aFrameItems that we want to put in the first-line
9694 }
9699 // Nothing is supposed to go into the first-line; nothing to do
9701 }
9704 // Create line frame
9710 parentStyle);
9715 // Initialize the line frame
9717 aLineFrame);
9719 // The lineFrame will be the block's first child; the rest of the
9720 // frame list (after lastInlineFrame) will be the second and
9721 // subsequent children; insert lineFrame into aFrameItems.
9726 }
9727 }
9730 // Give the inline frames to the lineFrame <b>after</b> reparenting them
9737 }
9738 }
9741 }
9744 }
9746 // Special routine to handle appending a new frame to a block frame's
9747 // child list. Takes care of placing the new frame into the right
9748 // place when first-line style is present.
9749 nsresult
9755 {
9756 // It's possible that aBlockFrame needs to have a first-line frame
9757 // created because it doesn't currently have any children.
9762 }
9764 // Examine the last block child - if it's a first-line frame then
9765 // appended frames need special treatment.
9768 // No first-line frame at the end of the list, therefore there is
9769 // an intervening block between any first-line frame the frames
9770 // we are appending. Therefore, we don't need any special
9771 // treatment of the appended frames.
9773 }
9777 }
9779 // Special routine to handle inserting a new frame into a block
9780 // frame's child list. Takes care of placing the new frame into the
9781 // right place when first-line style is present.
9782 nsresult
9790 {
9792 // XXXbz If you make this method actually do something, check to
9793 // make sure that the caller is passing what you expect. In
9794 // particular, which content is aContent? And audit the rest of
9795 // this code too; it makes bogus assumptions and may not build.
9796 #if 0
9802 // Insertion will become the first frame. Two cases: we either
9803 // already have a first-line frame or we don't.
9806 // We already have a first-line frame
9810 // Easy case: the new inline frame will go into the lineFrame.
9813 newFrame);
9815 // Since the frame is going into the lineFrame, don't let it
9816 // go into the block too.
9819 }
9821 // Harder case: We are about to insert a block level element
9822 // before the first-line frame.
9823 // XXX need a method to steal away frames from the line-frame
9824 }
9825 }
9827 // We do not have a first-line frame
9829 // We now need a first-line frame to contain the inline frame.
9833 }
9836 // Lookup first-line style context
9844 // Initialize the line frame
9848 // Make sure the caller inserts the lineFrame into the
9849 // blocks list of children.
9853 // Give the inline frames to the lineFrame <b>after</b>
9854 // reparenting them
9859 }
9860 }
9862 // Easy case: the regular insertion logic can insert the new
9863 // frame because it's a block frame.
9864 }
9865 }
9866 }
9868 // Insertion will not be the first frame.
9871 // Easy case: The prev-siblings parent is the block
9872 // frame. Therefore the prev-sibling is not currently in a
9873 // line-frame. Therefore the new frame which is going after it,
9874 // regardless of type, is not going into a line-frame.
9875 }
9877 // If the prevSiblingParent is not the block-frame then it must
9878 // be a line-frame (if it were a letter-frame, that logic would
9879 // already have adjusted the prev-sibling to be the
9880 // letter-frame).
9882 // Easy case: the insertion can go where the caller thinks it
9883 // should go (which is into prevSiblingParent).
9884 }
9886 // Block elements don't end up in line-frames, therefore
9887 // change the insertion point to aBlockFrame. However, there
9888 // might be more inline elements following aPrevSibling that
9889 // need to be pulled out of the line-frame and become children
9890 // of the block.
9894 // Oy. We have work to do. Create a list of the new frames
9895 // that are going into the block by stripping them away from
9896 // the line-frame(s).
9900 // XXX do something with 'tail'
9901 }
9908 }
9910 }
9911 }
9913 // We got lucky: aPrevSibling was the last inline frame in
9914 // the line-frame.
9920 }
9921 }
9922 }
9923 }
9925 #endif
9927 }
9929 //----------------------------------------------------------------------
9931 // First-letter support
9933 // Determine how many characters in the text fragment apply to the
9934 // first letter
9935 static PRInt32
9937 {
9949 }
9950 count++;
9952 }
9953 // XXX I18n
9958 }
9959 // keep looping
9961 }
9963 count++;
9966 }
9967 }
9970 }
9972 static PRBool
9974 {
9985 }
9986 }
9987 }
9989 }
9992 {
9995 }
9997 /**
9998 * Create a letter frame, only make it a floating frame.
9999 */
10000 void
10010 {
10011 // Create the first-letter-frame
10012 nsresult rv;
10017 // We don't want to use a text content for a non-text frame (because we want
10018 // its primary frame to be a text frame). So use its parent for the
10019 // first-letter.
10024 letterFrame);
10026 // Init the text frame to refer to the letter frame. Make sure we
10027 // get a proper style context for it (the one passed in is for the
10028 // letter frame and will have the float property set on it; the text
10029 // frame shouldn't have that set).
10035 // And then give the text frame to the letter frame
10038 // See if we will need to continue the text frame (does it contain
10039 // more than just the first-letter text or not?) If it does, then we
10040 // create (in advance) a continuation frame for it.
10043 // Create continuation
10049 }
10050 // Repair the continuations style context
10057 }
10058 }
10059 }
10062 // Put the new float before any of the floats in the block we're doing
10063 // first-letter for, that is, before any floats whose parent is
10064 // containingBlock.
10068 }
10079 }
10080 }
10081 }
10083 /**
10084 * Create a new letter frame for aTextFrame. The letter frame will be
10085 * a child of aParentFrame.
10086 */
10087 nsresult
10093 {
10099 // Get style context for the first-letter-frame
10105 // Use content from containing block so that we can actually
10106 // find a matching style rule.
10109 // Create first-letter style rule
10111 parentStyleContext);
10116 // Create a new text frame (the original one will be discarded)
10117 // pass a temporary stylecontext, the correct one will be set
10118 // later. Start off by unsetting the primary frame for
10119 // aTextContent, so it's no longer pointing to the to-be-destroyed
10120 // frame.
10121 // XXXbz it would be really nice to destroy the old frame _first_,
10122 // then create the new one, so we could avoid this hack.
10130 aBlockContinuation);
10132 // Create the right type of first-letter frame
10135 // Make a floating first-letter frame
10138 }
10140 // Make an inflow first-letter frame
10144 // Initialize the first-letter-frame. We don't want to use a text
10145 // content for a non-text frame (because we want its primary frame to
10146 // be a text frame). So use its parent for the first-letter.
10151 textFrame);
10159 }
10160 }
10162 }
10165 }
10167 nsresult
10172 {
10180 nsFrameItems letterFrames;
10188 }
10191 // Take textFrame out of the block's frame list and substitute the
10192 // letter frame(s) instead.
10195 }
10197 // Take the old textFrame out of the inline parent's child list
10200 // Insert in the letter frame(s)
10202 }
10203 }
10206 }
10208 nsresult
10219 {
10230 // Wrap up first-letter content in a letter frame
10233 // Create letter frame to wrap up the text
10238 }
10240 // Provide adjustment information for parent
10246 }
10247 }
10255 }
10256 }
10258 // This will stop us looking to create more letter frames. For
10259 // example, maybe the frame-type is "letterFrame" or
10260 // "placeholderFrame". This keeps us from creating extra letter
10261 // frames, and also prevents us from creating letter frames when
10262 // the first real content child of a block is not text (e.g. an
10263 // image, hr, etc.)
10266 }
10270 }
10273 }
10275 nsresult
10282 {
10283 // First look for the float frame that is a letter frame
10286 // See if we found a floating letter frame
10289 }
10291 }
10293 // No such frame
10295 }
10297 // Take the text frame away from the letter frame (so it isn't
10298 // destroyed when we destroy the letter frame).
10302 }
10304 // Discover the placeholder frame for the letter frame
10310 // Somethings really wrong
10312 }
10315 // Somethings really wrong
10317 }
10319 // Create a new text frame with the right style context that maps
10320 // all of the content that was previously part of the letter frame
10321 // (and probably continued elsewhere).
10325 }
10329 }
10334 }
10338 }
10341 // Destroy the old text frame's continuations (the old text frame
10342 // will be destroyed when its letter frame is destroyed).
10348 }
10352 // Now that everything is set...
10353 #ifdef NOISY_FIRST_LETTER
10356 #endif
10358 // Remove placeholder frame and the float
10361 // Now that the old frames are gone, we can start pointing to our
10362 // new primary frame.
10365 // Insert text frame in its place
10370 }
10372 nsresult
10379 {
10385 // Bingo. Found it. First steal away the text frame.
10389 }
10391 // Create a new textframe
10395 }
10399 }
10404 }
10408 // Next rip out the kid and replace it with the text frame
10411 // Now that the old frames are gone, we can start pointing to our
10412 // new primary frame.
10415 // Insert text frame in its place
10424 }
10426 // Look inside child inline frame for the letter frame
10431 }
10432 }
10435 }
10438 }
10440 nsresult
10445 {
10450 nsresult rv;
10453 aFrameManager,
10458 }
10461 }
10465 }
10467 // Fixup the letter frame situation for the given block
10468 nsresult
10470 {
10477 nsFrameItems letterFrames;
10479 nsresult rv;
10481 // XXX shouldn't this bit be set already (bug 408493), assert instead?
10489 }
10492 }
10497 // Take the old textFrame out of the parents child list
10500 // Insert in the letter frame(s)
10502 }
10504 }
10506 //----------------------------------------------------------------------
10508 // listbox Widget Routines
10510 nsresult
10516 PRBool aIsAppend,
10517 PRBool aIsScrollbar,
10519 {
10520 #ifdef MOZ_XUL
10523 // Construct a new frame
10525 nsFrameItems frameItems;
10529 mTempFrameTreeState);
10534 // Pre-check for display "none" - only if we find that, do we create
10535 // any frame at all
10541 }
10545 FrameConstructionItemList items;
10556 // Notify the parent frame
10559 else
10561 }
10564 }
10567 #else
10569 #endif
10570 }
10572 //----------------------------------------
10574 nsresult
10583 PRBool aAbsPosContainer,
10585 {
10586 // Create column wrapper if necessary
10598 }
10601 // See if we need to create a view
10609 }
10615 aStyleContext,
10617 aParentFrame);
10620 }
10622 // See if we need to create a view, e.g. the frame is absolutely positioned
10626 // The frame we're constructing will be the root element frame.
10627 // Set mRootElementFrame before processing children.
10629 }
10631 // We should make the outer frame be the absolute containing block,
10632 // if one is required. We have to do this because absolute
10633 // positioning must be computed with respect to the CSS dimensions
10634 // of the element, which are the dimensions of the outer block. But
10635 // we can't really do that because only blocks can have absolute
10636 // children. So use the block and try to compensate with hacks
10637 // in nsBlockFrame::CalculateContainingBlockSizeForAbsolutes.
10638 nsFrameConstructorSaveState absoluteSaveState;
10640 // NS_ASSERTION(aRelPos, "should have made area frame for this");
10642 }
10644 // Process the child content
10645 nsFrameItems childItems;
10649 // Set the frame's initial child list
10653 }
10655 nsresult
10662 {
10663 // If an inline frame has non-inline kids, then we chop up the child list
10664 // into runs of blocks and runs of inlines, create anonymous block frames to
10665 // contain the runs of blocks, inline frames with our style context for the
10666 // runs of inlines, and put all these frames, in order, into aFrameItems. We
10667 // put the first one into *aNewFrame. The whole setup is called an {ib}
10668 // split; in what follows "frames in the split" refers to the anonymous blocks
10669 // and inlines that contain our children.
10670 //
10671 // {ib} splits maintain the following invariants:
10672 // 1) All frames in the split have the NS_FRAME_IS_SPECIAL bit set.
10673 // 2) Each frame in the split has the nsIFrame::IBSplitSpecialSibling
10674 // property pointing to the next frame in the split, except for the last
10675 // one, which does not have it set.
10676 // 3) Each frame in the split has the nsIFrame::IBSplitSpecialPrevSibling
10677 // property pointing to the previous frame in the split, except for the
10678 // first one, which does not have it set.
10679 // 4) The first and last frame in the split are always inlines.
10680 //
10681 // An invariant that is NOT maintained is that the wrappers are actually
10682 // linked via GetNextSibling linkage. A simple example is an inline
10683 // containing an inline that contains a block. The three parts of the inner
10684 // inline end up with three different parents.
10685 //
10686 // For example, this HTML:
10687 // <span>
10688 // <div>a</div>
10689 // <span>
10690 // b
10691 // <div>c</div>
10692 // </span>
10693 // d
10694 // <div>e</div>
10695 // f
10696 // </span>
10697 // Gives the following frame tree:
10698 //
10699 // Inline (outer span)
10700 // Block (anonymous, outer span)
10701 // Block (div)
10702 // Text("a")
10703 // Inline (outer span)
10704 // Inline (inner span)
10705 // Text("b")
10706 // Block (anonymous, outer span)
10707 // Block (anonymous, inner span)
10708 // Block (div)
10709 // Text("c")
10710 // Inline (outer span)
10711 // Inline (inner span)
10712 // Text("d")
10713 // Block (anonymous, outer span)
10714 // Block (div)
10715 // Text("e")
10716 // Inline (outer span)
10717 // Text("f")
10724 PRBool positioned =
10732 }
10734 // Initialize the frame
10738 // because the object's destructor is significant
10739 // this is part of the fix for bug 42372
10741 // Any inline frame might need a view (because of opacity, or fixed background)
10745 // Relatively positioned frames becomes a container for child
10746 // frames that are positioned
10748 }
10750 // Process the child content
10751 nsFrameItems childItems;
10753 childItems);
10755 // Clean up?
10757 }
10762 }
10765 // This part is easy. We either already know we have no non-inline kids,
10766 // or haven't found any when constructing actual frames (the latter can
10767 // happen only if out-of-flows that we thought had no containing block
10768 // acquired one when ancestor inline frames and {ib} splits got
10769 // constructed). Just put all the kids into the single inline frame and
10770 // bail.
10775 }
10777 }
10779 // This inline frame contains several types of children. Therefore this frame
10780 // has to be chopped into several pieces, as described above.
10782 // Grab the first inline's kids
10792 }
10794 void
10797 PRBool aIsPositioned,
10800 {
10805 // Resolve the right style context for our anonymous blocks.
10811 styleContext);
10815 // On entry to this loop aChildItems is not empty and the first frame in it
10816 // is block-level.
10821 // The initial run of blocks belongs to an anonymous block that we create
10822 // right now. The anonymous block will be the parent of these block
10823 // children of the inline.
10828 PR_FALSE);
10830 // Any frame could have a view
10833 // Find the first non-block child which defines the end of our block kids
10834 // and the start of our next inline's kids
10844 // Now grab the initial inlines in aChildItems and put them into an inline
10845 // frame
10849 }
10852 }
10855 PR_FALSE);
10857 // Any frame might need a view
10866 inlineKids);
10867 }
10875 }
10877 void
10880 {
10881 // XXXbz should we preallocate aParentItem.mChildItems to some sane
10882 // length? Maybe even to parentContent->GetChildCount()?
10886 // Probe for generated content before
10897 // Manually check for comments/PIs, since we do't have a frame to pass to
10898 // AddFrameConstructionItems. We know our parent is a non-replaced inline,
10899 // so there is no need to do the NeedFrameFor check.
10905 }
10907 // See comment explaining why we need to remove the "is possible
10908 // restyle root" flags in AddFrameConstructionItems. But note
10909 // that we can remove all restyle flags, just like in
10910 // ProcessChildren and for the same reason.
10912 }
10922 }
10924 // Probe for generated content after
10930 }
10932 // return whether it's ok to append (in the AppendFrames sense) to
10933 // aParentFrame if our nextSibling is aNextSibling. aParentFrame must
10934 // be an {ib} special inline.
10935 static PRBool
10937 {
10945 }
10952 }
10954 PRBool
10959 PRBool aIsAppend,
10961 {
10964 }
10966 // Before we go and append the frames, we must check for several
10967 // special situations.
10969 // Situation #1 is a XUL frame that contains frames that are required
10970 // to be wrapped in blocks.
10976 }
10980 // Situation #2 is a case when table pseudo-frames don't work out right
10982 // If all the kids want a parent of the type that aFrame is, then we're all
10983 // set to go. Indeed, there won't be any table pseudo-frames created between
10984 // aFrame and the kids, so those won't need to be merged with any table
10985 // pseudo-frames that might already be kids of aFrame. If aFrame itself is a
10986 // table pseudo-frame, then all the kids in this list would have wanted a
10987 // frame of that type wrapping them anyway, so putting them inside it is ok.
10989 // Don't give up yet. If parentType is not eTypeBlock and the parent is
10990 // not a generated content frame, then try filtering whitespace out of the
10991 // list.
10993 // For leading whitespace followed by a kid that wants our parent type,
10994 // there are four cases:
10995 // 1) We have a previous sibling which is not a table pseudo. That means
10996 // that previous sibling wanted a (non-block) parent of the type we're
10997 // looking at. Then the whitespace comes between two table-internal
10998 // elements, so should be collapsed out.
10999 // 2) We have a previous sibling which is a table pseudo. It might have
11000 // kids who want this whitespace, so we need to reframe.
11001 // 3) We have no previous sibling and our parent frame is not a table
11002 // pseudo. That means that we'll be at the beginning of our actual
11003 // non-block-type parent, and the whitespace is OK to collapse out.
11004 // If something is ever inserted before us, it'll find our own parent
11005 // as its parent and if it's something that would care about the
11006 // whitespace it'll want a block parent, so it'll trigger a reframe at
11007 // that point.
11008 // 4) We have no previous sibling and our parent frame is a table pseudo.
11009 // Need to reframe.
11010 // All that is predicated on finding the correct previous sibling. We
11011 // might have to walk backwards along continuations from aFrame to do so.
11012 //
11013 // It's always OK to drop whitespace between any two items that want a
11014 // parent of type parentType.
11015 //
11016 // For trailing whitespace preceded by a kid that wants our parent type,
11017 // there are four cases:
11018 // 1) We have a next sibling which is not a table pseudo. That means
11019 // that next sibling wanted a (non-block) parent of the type we're
11020 // looking at. Then the whitespace comes between two table-internal
11021 // elements, so should be collapsed out.
11022 // 2) We have a next sibling which is a table pseudo. It might have
11023 // kids who want this whitespace, so we need to reframe.
11024 // 3) We have no next sibling and our parent frame is not a table
11025 // pseudo. That means that we'll be at the end of our actual
11026 // non-block-type parent, and the whitespace is OK to collapse out.
11027 // If something is ever inserted after us, it'll find our own parent
11028 // as its parent and if it's something that would care about the
11029 // whitespace it'll want a block parent, so it'll trigger a reframe at
11030 // that point.
11031 // 4) We have no next sibling and our parent frame is a table pseudo.
11032 // Need to reframe.
11033 // All that is predicated on finding the correct next sibling. We might
11034 // have to walk forward along continuations from aFrame to do so. That
11035 // said, in the case when nextSibling is null at this point and aIsAppend
11036 // is true, we know we're in case 3. Furthermore, in that case we don't
11037 // even have to worry about the table pseudo situation; we know our
11038 // parent is not a table pseudo there.
11044 }
11046 // iter points to an item that wants a different parent. If it's not
11047 // whitespace, we're done; no more point scanning the list.
11050 }
11053 // Leading whitespace. How to handle this depends on our
11054 // previous sibling and aFrame. See the long comment above.
11057 // Try to find one after all
11063 }
11065 }
11066 };
11069 // need to reframe
11071 }
11073 // need to reframe
11075 }
11076 }
11079 // Advance spaceEndIter past any whitespace
11082 PRBool okToDrop;
11084 // Trailing whitespace. How to handle this depeds on aIsAppend, our
11085 // next sibling and aFrame. See the long comment above.
11089 // Try to find one after all
11095 }
11097 }
11098 }
11102 }
11103 #ifdef DEBUG
11106 }
11107 #endif
11110 }
11115 // We're done: we don't want to drop the whitespace, and it has the
11116 // wrong parent type.
11118 }
11120 // Now loop, since |iter| points to item right after the whitespace we
11121 // removed.
11123 }
11125 // We might be able to figure out some sort of optimizations here, but they
11126 // would have to depend on having a correct aPrevSibling and a correct next
11127 // sibling. For example, we can probably avoid reframing if none of
11128 // aFrame, aPrevSibling, and next sibling are table pseudo-frames. But it
11129 // doesn't seem worth it to worry about that for now, especially since we
11130 // in fact do not have a reliable aPrevSibling, nor any next sibling, in
11131 // this method.
11133 // aItems might have changed, so recheck the parent type thing. In fact,
11134 // it might be empty, so recheck that too.
11137 }
11140 // Reframing aFrame->GetContent() is good enough, since the content of
11141 // table pseudo-frames is the ancestor content.
11144 }
11145 }
11147 // Now we have several cases involving {ib} splits. Put them all in a
11148 // do/while with breaks to take us to the "go and reconstruct" code.
11152 // We can just put the kids in.
11154 }
11157 // Need to go ahead and reconstruct.
11159 }
11161 // Now we're adding kids including some blocks to an inline part of an
11162 // {ib} split. If we plan to call AppendFrames, and don't have a next
11163 // sibling for the new frames, and our parent is the last continuation of
11164 // the last part of the {ib} split, and the same is true of all our
11165 // ancestor inlines (they have no following continuations and they're the
11166 // last part of their {ib} splits and we'd be adding to the end for all
11167 // of them), then AppendFrames will handle things for us. Bail out in
11168 // that case.
11171 }
11173 // Need to reconstruct.
11175 }
11177 // Now we know we have a block parent. If it's not special, we're all set.
11180 }
11182 // We're adding some kids to a block part of an {ib} split. If all the
11183 // kids are blocks, we don't need to reconstruct.
11186 }
11188 // We might have some inline kids for this block. Just reconstruct.
11192 // If we don't have a containing block, start with aFrame and look for one.
11195 }
11197 // To find the right block to reframe, just walk up the tree until we find a
11198 // frame that is:
11199 // 1) Not part of an IB split (not special)
11200 // 2) Not a pseudo-frame
11201 // 3) Not an inline frame
11202 // We're guaranteed to find one, since nsStyleContext::ApplyStyleFixups
11203 // enforces that the root is display:none, display:table, or display:block.
11204 // Note that walking up "too far" is OK in terms of correctness, even if it
11205 // might be a little inefficient. This is why we walk out of all
11206 // pseudo-frames -- telling which ones are or are not OK to walk out of is
11207 // too hard (and I suspect that we do in fact need to walk out of all of
11208 // them).
11213 "Must have non-inline, non-special, non-pseudo frame as root "
11215 }
11217 // Tell parent of the containing block to reformulate the
11218 // entire block. This is painful and definitely not optimal
11219 // but it will *always* get the right answer.
11222 #ifdef DEBUG
11226 }
11227 #endif
11230 }
11232 nsresult
11234 {
11236 #ifdef DEBUG
11237 // ReframeContainingBlock is a NASTY routine, it causes terrible performance problems
11238 // so I want to see when it is happening! Unfortunately, it is happening way to often because
11239 // so much content on the web causes 'special' block-in-inline frame situations and we handle them
11240 // very poorly
11244 }
11245 #endif
11247 // XXXbz how exactly would we get here while isReflowing anyway? Should this
11248 // whole test be ifdef DEBUG?
11250 // don't ReframeContainingBlock, this will result in a crash
11251 // if we remove a tree that's in reflow - see bug 121368 for testcase
11254 }
11256 // Get the first "normal" ancestor of the target frame.
11259 // From here we look for the containing block in case the target
11260 // frame is already a block (which can happen when an inline frame
11261 // wraps some of its content in an anonymous block; see
11262 // ConstructInline)
11264 // NOTE: We used to get the FloatContainingBlock here, but it was often wrong.
11265 // GetIBContainingBlock works much better and provides the correct container in all cases
11266 // so GetFloatContainingBlock(aFrame) has been removed
11268 // And get the containingBlock's content
11271 #ifdef DEBUG
11274 }
11275 #endif
11277 }
11278 }
11280 // If we get here, we're screwed!
11282 PR_TRUE);
11283 }
11285 void
11287 {
11288 // In some cases (:empty + E, :empty ~ E), a change if the content of
11289 // an element requires restyling its parent's siblings.
11295 }
11297 }
11299 void
11302 {
11304 #ifdef DEBUG
11305 {
11309 }
11310 }
11311 #endif
11312 PRUint32 selectorFlags =
11319 // see whether we need to restyle the container
11324 // We don't know whether we're testing :empty or :-moz-only-whitespace,
11325 // so be conservative and assume :-moz-only-whitespace (i.e., make
11326 // IsSignificantChild less likely to be true, and thus make us more
11327 // likely to restyle).
11331 }
11332 }
11336 }
11337 }
11341 // Restyling the container is the most we can do here, so we're done.
11343 }
11346 // restyle the last element child before this node
11348 cur;
11353 }
11354 }
11355 }
11356 }
11358 // Needed since we can't use PostRestyleEvent on non-elements (with
11359 // eRestyle_LaterSiblings or nsRestyleHint(eRestyle_Subtree |
11360 // eRestyle_LaterSiblings) as appropriate).
11361 static void
11364 {
11368 aFrameConstructor->
11371 NS_STYLE_HINT_NONE);
11373 }
11374 }
11375 }
11377 // Restyling for a ContentInserted or CharacterDataChanged notification.
11378 // This could be used for ContentRemoved as well if we got the
11379 // notification before the removal happened (and sometimes
11380 // CharacterDataChanged is more like a removal than an addition).
11381 // The comments are written and variables are named in terms of it being
11382 // a ContentInserted notification.
11383 void
11386 {
11389 PRUint32 selectorFlags =
11395 // see whether we need to restyle the container
11398 child;
11402 // We don't know whether we're testing :empty or :-moz-only-whitespace,
11403 // so be conservative and assume :-moz-only-whitespace (i.e., make
11404 // IsSignificantChild less likely to be true, and thus make us more
11405 // likely to restyle).
11409 }
11410 }
11414 }
11415 }
11419 // Restyling the container is the most we can do here, so we're done.
11421 }
11424 // Restyle all later siblings.
11426 }
11429 // restyle the previously-first element child if it is after this node
11432 content;
11437 }
11441 NS_STYLE_HINT_NONE);
11442 }
11444 }
11445 }
11446 // restyle the previously-last element child if it is before this node
11449 content;
11454 }
11458 NS_STYLE_HINT_NONE);
11459 }
11461 }
11462 }
11463 }
11464 }
11466 void
11470 {
11473 PRUint32 selectorFlags =
11479 // see whether we need to restyle the container
11482 child;
11484 // We don't know whether we're testing :empty or :-moz-only-whitespace,
11485 // so be conservative and assume :-moz-only-whitespace (i.e., make
11486 // IsSignificantChild less likely to be true, and thus make us more
11487 // likely to restyle).
11491 }
11492 }
11496 }
11497 }
11501 // Restyling the container is the most we can do here, so we're done.
11503 }
11506 // Restyle all later siblings.
11508 }
11511 // restyle the now-first element child if it was after aOldChild
11514 content;
11518 // do NOT continue here; we might want to restyle this node
11519 }
11523 NS_STYLE_HINT_NONE);
11524 }
11526 }
11527 }
11528 // restyle the now-last element child if it was before aOldChild
11531 content;
11536 }
11538 }
11541 }
11542 }
11543 }
11544 }
11547 void
11549 {
11551 "Should not reconstruct the root of the frame tree. "
11561 // Make sure that the viewmanager will outlive the presshell
11564 // Processing the style changes could cause a flush that propagates to
11565 // the parent frame and thus destroys the pres shell.
11568 // We may reconstruct frames below and hence process anything that is in the
11569 // tree. We don't want to get notified to process those items again after.
11572 nsAutoScriptBlocker scriptBlocker;
11574 // Tell the style set to get the old rule tree out of the way
11575 // so we can recalculate while maintaining rule tree immutability
11580 }
11582 // Recalculate all of the style contexts for the document
11583 // Note that we can ignore the return value of ComputeStyleChangeFor
11584 // because we never need to reframe the root frame
11585 // XXX This could be made faster by not rerunning rule matching
11586 // (but note that nsPresShell::SetPreferenceStyleRules currently depends
11587 // on us re-running rule matching here
11588 nsStyleChangeList changeList;
11589 // XXX Does it matter that we're passing aExtraHint to the real root
11590 // frame and not the root node's primary frame?
11591 // Note: The restyle tracker we pass in here doesn't matter.
11595 // Process the required changes
11597 // Tell the style set it's safe to destroy the old rule tree. We
11598 // must do this after the ProcessRestyledFrames call in case the
11599 // change list has frame reconstructs in it (since frames to be
11600 // reconstructed will still have their old style context pointers
11601 // until they are destroyed).
11604 }
11606 void
11608 {
11613 // Process non-animation restyles...
11621 #ifdef DEBUG
11623 #endif
11625 // ...and then process animation restyles. This needs to happen
11626 // second because we need to start animations that resulted from the
11627 // first set of restyles (e.g., CSS transitions with negative
11628 // transition-delay), and because we need to immediately
11629 // restyle-with-animation any just-restyled elements that are
11630 // mid-transition (since processing the non-animation restyle ignores
11631 // the running transition so it can check for a new change on the same
11632 // property, and then posts an immediate animation style change).
11639 "We should not have posted new non-animation restyles while "
11643 // We probably wasted a lot of work up above, but this seems safest
11644 // and it should be rarely used.
11645 // This might add us as a refresh observer again; that's ok.
11647 }
11648 }
11650 void
11652 nsRestyleHint aRestyleHint,
11653 nsChangeHint aMinChangeHint,
11654 PRBool aForAnimation)
11655 {
11658 }
11661 // Nothing to do here
11663 }
11670 }
11672 void
11674 {
11675 // Make sure we're not in a style refresh; if we are, we still have
11676 // a call to ProcessPendingRestyles coming and there's no need to
11677 // add ourselves as a refresh observer until then.
11682 }
11683 }
11685 void
11687 {
11689 "Should not reconstruct the root of the frame tree. "
11694 // Get a restyle event posted if necessary
11696 }
11698 nsresult
11700 {
11701 {
11702 nsAutoScriptBlocker scriptBlocker;
11705 nsFrameItems childItems;
11707 // We don't have a parent frame with a pending binding constructor here,
11708 // so no need to worry about ordering of the kids' constructors with it.
11709 // Pass null for the PendingBinding.
11712 nsnull);
11716 }
11721 }
11723 // call XBL constructors after the frames are created
11727 }
11729 //////////////////////////////////////////////////////////
11730 // nsCSSFrameConstructor::FrameConstructionItem methods //
11731 //////////////////////////////////////////////////////////
11732 PRBool
11735 {
11740 }
11742 NS_REFRAME_IF_WHITESPACE);
11744 }
11746 //////////////////////////////////////////////////////////////
11747 // nsCSSFrameConstructor::FrameConstructionItemList methods //
11748 //////////////////////////////////////////////////////////////
11749 void
11752 {
11757 }
11760 }
11763 }
11765 }
11767 ////////////////////////////////////////////////////////////////////////
11768 // nsCSSFrameConstructor::FrameConstructionItemList::Iterator methods //
11769 ////////////////////////////////////////////////////////////////////////
11770 inline PRBool
11773 {
11779 }
11780 }
11782 }
11784 inline PRBool
11787 {
11794 }
11798 }
11800 void
11803 {
11814 }
11816 void
11820 {
11829 }
11831 // move over the list of items
11835 // Copy over the various counters
11843 // reset mList
11846 // Point ourselves to aEnd, as advertised
11849 }
11851 void
11854 {
11855 // Just insert the item before us. There's no magic here.
11860 }
11862 void
11865 {
11877 }