| blob | 697b139ed91a3e1154930f5091ede8cd7eb68faf |
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #ifndef nsLayoutUtils_h__
8 #define nsLayoutUtils_h__
34 #include <limits>
35 #include <algorithm>
36 // If you're thinking of adding a new include here, please try hard to not.
37 // This header file gets included just about everywhere and adding headers here
38 // can dramatically increase avoidable build activity. Try instead:
39 // - using a forward declaration
40 // - putting the include in the .cpp file, if it is only needed by the body
41 // - putting your new functions in some other less-widely-used header
123 }
126 // Flags to customize the behavior of nsLayoutUtils::DrawString.
130 };
138 };
142 /**
143 * nsLayoutUtils is a namespace class used for various helper
144 * functions that are useful in multiple places in layout. The goal
145 * is not to define multiple copies of the same static helper.
146 */
198 /**
199 * Finds previously assigned ViewID for the given content element, if any.
200 * Returns whether a ViewID was previously assigned.
201 */
204 /**
205 * Finds previously assigned or generates a unique ViewID for the given
206 * content element.
207 */
210 /**
211 * Find content for given ID.
212 */
215 /**
216 * Find the scrollable frame for a given content element.
217 */
220 /**
221 * Find the scrollable frame for a given ID.
222 */
225 /**
226 * Helper for FindScrollableFrameFor(), also used in DisplayPortUtils.
227 * Most clients should use FindScrollableFrameFor().
228 */
231 /**
232 * Find the ID for a given scrollable frame.
233 */
236 /**
237 * Notify the scroll frame with the given scroll id that its scroll offset
238 * is being sent to APZ as part of a paint-skip transaction.
239 *
240 * Normally, this notification happens during painting, after calls to
241 * ComputeScrollMetadata(). During paint-skipping that code is skipped,
242 * but it's still important for the scroll frame to be notified for
243 * correctness of relative scroll updates, so the code that sends the
244 * empty paint-skip transaction needs to call this.
245 */
248 /**
249 * Use heuristics to figure out the child list that
250 * aChildFrame is currently in.
251 */
254 /**
255 * Returns the ::before pseudo-element for aContent, if any.
256 */
259 /**
260 * Returns the frame corresponding to the ::before pseudo-element for
261 * aContent, if any.
262 */
265 /**
266 * Returns the ::after pseudo-element for aContent, if any.
267 */
270 /**
271 * Returns the frame corresponding to the ::after pseudo-element for aContent,
272 * if any.
273 */
276 /**
277 * Returns the ::marker pseudo-element for aContent, if any.
278 */
281 /**
282 * Returns the frame corresponding to the ::marker pseudo-element for
283 * aContent, if any.
284 */
287 #ifdef ACCESSIBILITY
288 /**
289 * Set aText to the spoken text for the given ::marker content (aContent)
290 * if it has a frame, or the empty string otherwise.
291 */
293 #endif
295 /**
296 * Given a frame, search up the frame tree until we find an
297 * ancestor that (or the frame itself) is of type aFrameType, if any.
298 *
299 * @param aFrame the frame to start at
300 * @param aFrameType the frame type to look for
301 * @param aStopAt a frame to stop at after we checked it
302 * @return a frame of the given type or nullptr if no
303 * such ancestor exists
304 */
309 /**
310 * Given a frame, search up the frame tree until we find an
311 * ancestor that (or the frame itself) is a "Page" frame, if any.
312 *
313 * @param aFrame the frame to start at
314 * @return a frame of type mozilla::LayoutFrameType::Page or nullptr if no
315 * such ancestor exists
316 */
319 /**
320 * Given a frame which is the primary frame for an element,
321 * return the frame that has the non-pseudoelement ComputedStyle for
322 * the content.
323 * This is aPrimaryFrame itself except for tableWrapper frames.
324 *
325 * Given a non-null input, this will return null if and only if its
326 * argument is a table wrapper frame that is mid-destruction (and its
327 * table frame has been destroyed).
328 */
332 /**
333 * Given a content node,
334 * return the frame that has the non-pseudoelement ComputedStyle for
335 * the content. May return null.
336 * This is aContent->GetPrimaryFrame() except for tableWrapper frames.
337 */
340 /**
341 * Returns the placeholder size for when the scrollbar is unthemed.
342 */
346 /**
347 * The inverse of GetStyleFrame. Returns |aStyleFrame| unless it is an inner
348 * table frame, in which case the table wrapper frame is returned.
349 */
354 /**
355 * Similar to nsIFrame::IsPrimaryFrame except that this will return true
356 * for the inner table frame rather than for its wrapper frame.
357 */
360 /**
361 * CompareTreePosition determines whether aFrame1 comes before or
362 * after aFrame2 in a preorder traversal of the frame tree, where out
363 * of flow frames are treated as children of their placeholders. This is
364 * basically the same ordering as DoCompareTreePosition(nsIContent*) except
365 * that it handles anonymous content properly and there are subtleties with
366 * continuations.
367 *
368 * @param aCommonAncestor either null, or a common ancestor of
369 * aContent1 and aContent2. Actually this is
370 * only a hint; if it's not an ancestor of
371 * aContent1 or aContent2, this function will
372 * still work, but it will be slower than
373 * normal.
374 * @return < 0 if aContent1 is before aContent2
375 * > 0 if aContent1 is after aContent2,
376 * 0 otherwise (meaning they're the same, or they're in
377 * different frame trees)
378 */
382 }
388 aCommonAncestor);
389 }
400 /**
401 * LastContinuationWithChild gets the last continuation in aFrame's chain
402 * that has a child, or the first continuation if the frame has no children.
403 */
406 /**
407 * GetLastSibling simply finds the last sibling of aFrame, or returns nullptr
408 * if aFrame is null.
409 */
412 /**
413 * FindSiblingViewFor locates the child of aParentView that aFrame's
414 * view should be inserted 'above' (i.e., before in sibling view
415 * order). This is the first child view of aParentView whose
416 * corresponding content is before aFrame's content (view siblings
417 * are in reverse content order).
418 */
421 /**
422 * Get the parent of aFrame. If aFrame is the root frame for a document,
423 * and the document has a parent document in the same view hierarchy, then
424 * we try to return the subdocumentframe in the parent document.
425 * @param aCrossDocOffset [in/out] if non-null, then as we cross documents
426 * an extra offset may be required and it will be added to aCrossDocOffset.
427 * Be careful dealing with this extra offset as it is in app units of the
428 * parent document, which may have a different app units per dev pixel ratio
429 * than the child document.
430 * Note that, while this function crosses document boundaries, it (naturally)
431 * cannot cross process boundaries.
432 */
436 /**
437 * Does the same thing as GetCrossDocParentFrameInProcess().
438 * The purpose of having two functions is to more easily track which call
439 * sites have been audited to consider out-of-process iframes (bug 1599913).
440 * Once all call sites have been audited, this function can be removed.
441 */
445 /**
446 * IsProperAncestorFrame checks whether aAncestorFrame is an ancestor
447 * of aFrame and not equal to aFrame.
448 * @param aCommonAncestor nullptr, or a common ancestor of aFrame and
449 * aAncestorFrame. If non-null, this can bound the search and speed up
450 * the function
451 */
456 /**
457 * Like IsProperAncestorFrame, but looks across document boundaries.
458 *
459 * Just like IsAncestorFrameCrossDoc, except that it returns false when
460 * aFrame == aAncestorFrame.
461 * TODO: Once after we fixed bug 1715932, this function should be removed.
462 */
467 /**
468 * Like IsProperAncestorFrame, but looks across document boundaries.
469 *
470 * Just like IsAncestorFrameCrossDoc, except that it returns false when
471 * aFrame == aAncestorFrame.
472 */
477 /**
478 * IsAncestorFrameCrossDoc checks whether aAncestorFrame is an ancestor
479 * of aFrame or equal to aFrame, looking across document boundaries.
480 * @param aCommonAncestor nullptr, or a common ancestor of aFrame and
481 * aAncestorFrame. If non-null, this can bound the search and speed up
482 * the function.
483 *
484 * Just like IsProperAncestorFrameCrossDoc, except that it returns true when
485 * aFrame == aAncestorFrame.
486 *
487 * TODO: Bug 1700245, all call sites of this function will be eventually
488 * replaced by IsAncestorFrameCrossDocInProcess.
489 */
494 /**
495 * IsAncestorFrameCrossDocInProcess checks whether aAncestorFrame is an
496 * ancestor of aFrame or equal to aFrame, looking across document boundaries
497 * in the same process.
498 * @param aCommonAncestor nullptr, or a common ancestor of aFrame and
499 * aAncestorFrame. If non-null, this can bound the search and speed up
500 * the function.
501 *
502 * Just like IsProperAncestorFrameCrossDoc, except that it returns true when
503 * aFrame == aAncestorFrame.
504 *
505 * NOTE: This function doesn't return true even if |aAncestorFrame| and
506 * |aFrame| is in the same process but they are not directly connected, e.g.
507 * both |aAncestorFrame| and |aFrame| in A domain documents, but there's
508 * another an iframe document domain B, such as A1 -> B1 ->A2 document tree.
509 */
517 /**
518 * Get the scroll id for the root scrollframe of the presshell of the given
519 * prescontext. Returns NULL_SCROLL_ID if it couldn't be found.
520 */
523 /**
524 * GetScrollableFrameFor returns the scrollable frame for a scrolled frame
525 */
529 /**
530 * GetNearestScrollableFrameForDirection locates the first ancestor of
531 * aFrame (or aFrame itself) that is scrollable with overflow:scroll or
532 * overflow:auto in the given direction and where either the scrollbar for
533 * that direction is visible or the frame can be scrolled by some
534 * positive amount in that direction.
535 * The search extends across document boundaries.
536 *
537 * @param aFrame the frame to start with
538 * @param aDirection Whether it's for horizontal or vertical scrolling.
539 * @return the nearest scrollable frame or nullptr if not found
540 */
545 /**
546 * If the SCROLLABLE_SAME_DOC flag is set, then we only walk the frame tree
547 * up to the root frame in the current document.
548 */
550 /**
551 * If the SCROLLABLE_INCLUDE_HIDDEN flag is set then we allow
552 * overflow:hidden scrollframes to be returned as scrollable frames.
553 */
555 /**
556 * If the SCROLLABLE_ONLY_ASYNC_SCROLLABLE flag is set, then we only
557 * want to match scrollable frames for which WantAsyncScroll() returns
558 * true.
559 */
561 /**
562 * If the SCROLLABLE_ALWAYS_MATCH_ROOT flag is set, then we will always
563 * return the root scrollable frame for the root document (in the current
564 * process) if we encounter it, whether or not it is async scrollable or
565 * overflow: hidden.
566 */
568 /**
569 * If the SCROLLABLE_FIXEDPOS_FINDS_ROOT flag is set, then for fixed-pos
570 * frames return the root scrollable frame for that document.
571 */
573 /**
574 * If the SCROLLABLE_STOP_AT_PAGE flag is set, then we stop searching
575 * for scrollable ancestors when seeing a nsPageFrame. This can be used
576 * to avoid finding the viewport scroll frame in Print Preview (which
577 * would be undesirable as a 'position:sticky' container for content).
578 */
580 };
581 /**
582 * GetNearestScrollableFrame locates the first ancestor of aFrame
583 * (or aFrame itself) that is scrollable with overflow:scroll or
584 * overflow:auto in some direction.
585 *
586 * @param aFrame the frame to start with
587 * @param aFlags if SCROLLABLE_SAME_DOC is set, do not search across
588 * document boundaries. If SCROLLABLE_INCLUDE_HIDDEN is set, include
589 * frames scrollable with overflow:hidden.
590 * @return the nearest scrollable frame or nullptr if not found
591 */
595 /**
596 * GetScrolledRect returns the range of allowable scroll offsets
597 * for aScrolledFrame, assuming the scrollable overflow area is
598 * aScrolledFrameOverflowArea and the scrollport size is aScrollPortSize.
599 */
605 /**
606 * HasPseudoStyle returns true if aContent (whose primary style
607 * context is aComputedStyle) has the aPseudoElement pseudo-style
608 * attached to it; returns false otherwise.
609 *
610 * @param aContent the content node we're looking at
611 * @param aComputedStyle aContent's ComputedStyle
612 * @param aPseudoElement the id of the pseudo style we care about
613 * @param aPresContext the presentation context
614 * @return whether aContent has aPseudoElement style attached to it
615 */
621 /**
622 * If this frame is a placeholder for a float, then return the float,
623 * otherwise return nullptr. aPlaceholder must be a placeholder frame.
624 */
627 // Combine aOrigClearType with aNewClearType, but limit the clear types
628 // to StyleClear::Left, Right, Both.
632 /**
633 * Get the coordinates of a given DOM mouse event, relative to a given
634 * frame. Works only for DOM events generated by WidgetGUIEvents.
635 * @param aDOMEvent the event
636 * @param aFrame the frame to make coordinates relative to
637 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
638 * for some reason the coordinates for the mouse are not known (e.g.,
639 * the event is not a GUI event).
640 */
644 /**
645 * Get the coordinates of a given native mouse event, relative to a given
646 * frame.
647 * @param aEvent the event
648 * @param aFrame the frame to make coordinates relative to
649 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
650 * for some reason the coordinates for the mouse are not known (e.g.,
651 * the event is not a GUI event).
652 */
656 /**
657 * Get the coordinates of a given point relative to an event and a
658 * given frame.
659 * @param aEvent the event
660 * @param aPoint the point to get the coordinates relative to
661 * @param aFrame the frame to make coordinates relative to
662 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
663 * for some reason the coordinates for the mouse are not known (e.g.,
664 * the event is not a GUI event).
665 */
670 /**
671 * Get the coordinates of a given point relative to a widget and a
672 * given frame.
673 * @param aWidget the event src widget
674 * @param aPoint the point to get the coordinates relative to
675 * @param aFrame the frame to make coordinates relative to
676 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
677 * for some reason the coordinates for the mouse are not known (e.g.,
678 * the event is not a GUI event).
679 */
682 RelativeTo aFrame);
684 /**
685 * Get the popup frame of a given native mouse event.
686 * @param aRootPresContext only check popups within aRootPresContext or a
687 * descendant
688 * @param aEvent the event.
689 * @return Null, if there is no popup frame at the point, otherwise,
690 * returns top-most popup frame at the point.
691 */
695 /**
696 * Get the popup frame of a given point relative to a widget.
697 * @param aRootPresContext only check popups within aRootPresContext or a
698 * descendant
699 * @param aEvent the event.
700 * @return Null, if there is no popup frame at the point, otherwise,
701 * returns top-most popup frame at the point.
702 */
705 };
711 /**
712 * Get container and offset if aEvent collapses Selection.
713 * @param aPresShell The PresShell handling aEvent.
714 * @param aEvent The event having coordinates where you want to
715 * collapse Selection.
716 * @param aContainer Returns the container node at the point.
717 * Set nullptr if you don't need this.
718 * @param aOffset Returns offset in the container node at the point.
719 * Set nullptr if you don't need this.
720 */
721 MOZ_CAN_RUN_SCRIPT
727 /**
728 * Translate from widget coordinates to the view's coordinates
729 * @param aPresContext the PresContext for the view
730 * @param aWidget the widget
731 * @param aPt the point relative to the widget
732 * @param aView view to which returned coordinates are relative
733 * @return the point in the view's coordinates
734 */
740 /**
741 * Translate from view coordinates to the widget's coordinates.
742 * @param aPresContext the PresContext for the view
743 * @param aView the view
744 * @param aPt the point relative to the view
745 * @param aViewportType whether the point is in visual or layout coordinates
746 * @param aWidget the widget to which returned coordinates are relative
747 * @return the point in the view's coordinates
748 */
757 /**
758 * When set, paint suppression is ignored, so we'll return non-root page
759 * elements even if paint suppression is stopping them from painting.
760 */
762 /**
763 * When set, clipping due to the root scroll frame (and any other viewport-
764 * related clipping) is ignored.
765 */
766 IgnoreRootScrollFrame,
767 /**
768 * When set, return only content in the same document as aFrame.
769 */
770 IgnoreCrossDoc,
771 /**
772 * When set, return only content that is actually visible.
773 */
774 OnlyVisible,
775 };
780 Bits mBits;
781 // If mBits contains OnlyVisible, what is the opacity threshold which we
782 // consider "opaque enough" to clobber stuff underneath.
792 };
794 /**
795 * Given aFrame, the root frame of a stacking context, find its descendant
796 * frame under the point aPt that receives a mouse event at that location,
797 * or nullptr if there is no such frame.
798 * @param aPt the point, relative to the frame origin, in either visual
799 * or layout coordinates depending on aRelativeTo.mViewportType
800 */
804 /**
805 * Given aFrame, the root frame of a stacking context, find all descendant
806 * frames under the area of a rectangle that receives a mouse event,
807 * or nullptr if there is no such frame.
808 * @param aRect the rect, relative to the frame origin, in either visual
809 * or layout coordinates depending on aRelativeTo.mViewportType
810 * @param aOutFrames an array to add all the frames found
811 */
816 /**
817 * Transform aRect relative to aFrame up to the coordinate system of
818 * aAncestor. Computes the bounding-box of the true quadrilateral.
819 * Pass non-null aPreservesAxisAlignedRectangles and it will be set to true if
820 * we only need to use a 2d transform that PreservesAxisAlignedRectangles().
821 * The corner positions of aRect are treated as meaningful even if aRect is
822 * empty.
823 *
824 * |aMatrixCache| allows for optimizations in recomputing the same matrix over
825 * and over. The argument can be one of the following values:
826 *
827 * nullptr (the default) - No optimization; the transform matrix is computed
828 * on every call to this function.
829 *
830 * non-null pointer to an empty Maybe<Matrix4x4> - Upon return, the Maybe is
831 * filled with the transform matrix that was computed. This can then be passed
832 * in to subsequent calls with the same source and destination frames to avoid
833 * recomputing the matrix.
834 *
835 * non-null pointer to a non-empty Matrix4x4 - The provided matrix will be
836 * used as the transform matrix and applied to the rect.
837 */
847 aOutAncestor);
848 }
856 /**
857 * Gets the transform for aFrame relative to aAncestor. Pass null for
858 * aAncestor to go up to the root frame. Including nsIFrame::IN_CSS_UNITS
859 * flag in aFlags will return CSS pixels, by default it returns device
860 * pixels.
861 * More info can be found in nsIFrame::GetTransformMatrix.
862 *
863 * Some notes on the possible combinations of |aFrame.mViewportType| and
864 * |aAncestor.mViewportType|:
865 *
866 * | aFrame. | aAncestor. | Notes
867 * | mViewportType | mViewportType |
868 * ==========================================================================
869 * | Layout | Layout | Commonplace, when both source and target
870 * | | | are inside zoom boundary.
871 * | | |
872 * | | | Could also happen in non-e10s setups
873 * | | | when both source and target are outside
874 * | | | the zoom boundary and the code is
875 * | | | oblivious to the existence of a zoom
876 * | | | boundary.
877 * ==========================================================================
878 * | Layout | Visual | Commonplace, used when hit testing visual
879 * | | | coordinates (e.g. coming from user input
880 * | | | events). We expected to encounter a
881 * | | | zoomed content root during traversal and
882 * | | | apply a layout-to-visual transform.
883 * ==========================================================================
884 * | Visual | Layout | Should never happen, will assert.
885 * ==========================================================================
886 * | Visual | Visual | In e10s setups, should only happen if
887 * | | | aFrame and aAncestor are both the
888 * | | | RCD viewport frame.
889 * | | |
890 * | | | In non-e10s setups, could happen with
891 * | | | different frames if they are both
892 * | | | outside the zoom boundary.
893 * ==========================================================================
894 */
899 /**
900 * Gets the scale factors of the transform for aFrame relative to the root
901 * frame if this transform can be drawn 2D, or the identity scale factors
902 * otherwise.
903 */
906 /**
907 * Gets the scale factors of the transform for aFrame relative to the root
908 * frame if this transform is 2D, or the identity scale factors otherwise.
909 * If some frame on the path from aFrame to the display root frame may have an
910 * animated scale, returns the identity scale factors.
911 */
915 /**
916 * Gets a scale that includes CSS transforms in this process as well as the
917 * transform to ancestor scale passed down from our direct ancestor process
918 * (which includes any enclosing CSS transforms and resolution). Note: this
919 * does not include any resolution in the current process (this is on purpose
920 * because that is what the transform to ancestor field on FrameMetrics needs,
921 * see its definition for explanation as to why). This is the transform to
922 * ancestor scale to set on FrameMetrics.
923 */
928 /**
929 * Find the nearest common ancestor frame for aFrame1 and aFrame2. The
930 * ancestor frame could be cross-doc.
931 */
935 /**
936 * Find the nearest common ancestor frame for aFrame1 and aFrame2, assuming
937 * that they are within the same block.
938 *
939 * Returns null if they are not within the same block.
940 */
944 /**
945 * Whether author-specified borders / backgrounds disable theming for a given
946 * appearance value.
947 */
951 /**
952 * Transforms a list of CSSPoints from aFromFrame to aToFrame, taking into
953 * account all relevant transformations on the frames up to (but excluding)
954 * their nearest common ancestor.
955 * If we encounter a transform that we need to invert but which is
956 * non-invertible, we return NONINVERTIBLE_TRANSFORM. If the frames have
957 * no common ancestor, we return NO_COMMON_ANCESTOR.
958 * If this returns TRANSFORM_SUCCEEDED, the points in aPoints are transformed
959 * in-place, otherwise they are untouched.
960 */
962 TRANSFORM_SUCCEEDED,
963 NO_COMMON_ANCESTOR,
964 NONINVERTIBLE_TRANSFORM
965 };
967 RelativeTo aToFrame,
971 /**
972 * Same as above function, but transform points in app units and
973 * handle 1 point per call.
974 */
978 /**
979 * Transforms a rect from aFromFrame to aToFrame. In app units.
980 * Returns the bounds of the actual rect if the transform requires rotation
981 * or anything complex like that.
982 */
986 /**
987 * Converts app units to pixels (with optional snapping) and appends as a
988 * translation to aTransform.
989 */
993 /*
994 * Whether the frame should snap to grid. This will end up being passed
995 * as the aRounded parameter in PostTranslate above. SVG frames should
996 * not have their translation rounded.
997 */
1000 /**
1001 * Get the border-box of aElement's primary frame, transformed it to be
1002 * relative to aFrame.
1003 */
1007 /**
1008 * Returns true if aRect with border inflation of size aInflateSize contains
1009 * aPoint.
1010 */
1012 nscoord aInflateSize);
1014 /**
1015 * Clamp aRect relative to aFrame to the scroll frames boundary searching from
1016 * aFrame.
1017 */
1020 /**
1021 * Given a point in the global coordinate space, returns that point expressed
1022 * in the coordinate system of aFrame. This effectively inverts all
1023 * transforms between this point and the root frame.
1024 *
1025 * @param aFromType Specifies whether |aPoint| is in layout or visual
1026 * coordinates.
1027 * @param aFrame The frame that acts as the coordinate space container.
1028 * @param aPoint The point, in global layout or visual coordinates (as per
1029 * |aFromType|, to get in the frame-local space.
1030 * @return aPoint, expressed in aFrame's canonical coordinate space.
1031 */
1033 RelativeTo aFrame,
1037 }
1039 /**
1040 * Transform aPoint relative to aAncestor down to the coordinate system of
1041 * aFrame.
1042 */
1045 RelativeTo aAncestor);
1047 /**
1048 * Helper function that, given a rectangle and a matrix, returns the smallest
1049 * rectangle containing the image of the source rectangle.
1050 *
1051 * @param aBounds The rectangle to transform.
1052 * @param aMatrix The matrix to transform it with.
1053 * @param aFactor The number of app units per graphics unit.
1054 * @return The smallest rect that contains the image of aBounds.
1055 */
1062 /**
1063 * Helper function that, given a point and a matrix, returns the image
1064 * of that point under the matrix transform.
1065 *
1066 * @param aPoint The point to transform.
1067 * @param aMatrix The matrix to transform it with.
1068 * @param aFactor The number of app units per graphics unit.
1069 * @return The image of the point under the transform.
1070 */
1074 /**
1075 * Given a graphics rectangle in graphics space, return a rectangle in
1076 * app space that contains the graphics rectangle, rounding out as necessary.
1077 *
1078 * @param aRect The graphics rect to round outward.
1079 * @param aFactor The number of app units per graphics unit.
1080 * @return The smallest rectangle in app space that contains aRect.
1081 */
1085 /**
1086 * Returns a subrectangle of aContainedRect that is entirely inside the
1087 * rounded rect. Complex cases are handled conservatively by returning a
1088 * smaller rect than necessary.
1089 */
1097 /**
1098 * Return whether any part of aTestRect is inside of the rounded
1099 * rectangle formed by aBounds and aRadii (which are indexed by the
1100 * enum HalfCorner constants in gfx/2d/Types.h). This is precise.
1101 */
1118 };
1120 /**
1121 * Given aFrame, the root frame of a stacking context, paint it and its
1122 * descendants to aRenderingContext.
1123 * @param aRenderingContext a rendering context translated so that (0,0)
1124 * is the origin of aFrame; for best results, (0,0) should transform
1125 * to pixel-aligned coordinates. This can be null, in which case
1126 * aFrame must be a "display root" (root frame for a root document,
1127 * or the root of a popup) with an associated widget and we draw using
1128 * the layer manager for the frame's widget.
1129 * @param aDirtyRegion the region that must be painted, in the coordinates
1130 * of aFrame.
1131 * @param aBackstop paint the dirty area with this color before drawing
1132 * the actual content; pass NS_RGBA(0,0,0,0) to draw no background.
1133 * @param aBuilderMode Passed through to the display-list builder.
1134 * @param aFlags if PAINT_IN_TRANSFORM is set, then we assume
1135 * this is inside a transform or SVG foreignObject. If
1136 * PAINT_SYNC_DECODE_IMAGES is set, we force synchronous decode on all
1137 * images. If PAINT_WIDGET_LAYERS is set, aFrame must be a display root,
1138 * and we will use the frame's widget's layer manager to paint
1139 * even if aRenderingContext is non-null. This is useful if you want
1140 * to force rendering to use the widget's layer manager for testing
1141 * or speed. PAINT_WIDGET_LAYERS must be set if aRenderingContext is null.
1142 * If PAINT_DOCUMENT_RELATIVE is used, the visible region is interpreted
1143 * as being relative to the document (normally it's relative to the CSS
1144 * viewport) and the document is painted as if no scrolling has occured.
1145 * Only considered if PresShell::IgnoringViewportScrolling is true.
1146 * If ResetViewportScrolling is used, then the root scroll frame's scroll
1147 * position is set to 0 during painting, so that position:fixed elements
1148 * are drawn in their initial position.
1149 * PAINT_TO_WINDOW sets painting to window to true on the display list
1150 * builder even if we can't tell that we are painting to the window.
1151 * If PAINT_EXISTING_TRANSACTION is set, then BeginTransaction() has already
1152 * been called on aFrame's widget's layer manager and should not be
1153 * called again.
1154 * If PAINT_COMPRESSED is set, the FrameLayerBuilder should be set to
1155 * compressed mode to avoid short cut optimizations.
1156 *
1157 * So there are three possible behaviours:
1158 * 1) PAINT_WIDGET_LAYERS is set and aRenderingContext is null; we paint
1159 * by calling BeginTransaction on the widget's layer manager.
1160 * 2) PAINT_WIDGET_LAYERS is set and aRenderingContext is non-null; we
1161 * paint by calling BeginTransactionWithTarget on the widget's layer
1162 * manager.
1163 * 3) PAINT_WIDGET_LAYERS is not set and aRenderingContext is non-null;
1164 * we paint by construct a BasicLayerManager and calling
1165 * BeginTransactionWithTarget on it. This is desirable if we're doing
1166 * something like drawWindow in a mode where what gets rendered doesn't
1167 * necessarily correspond to what's visible in the window; we don't
1168 * want to mess up the widget's layer tree.
1169 */
1172 nsDisplayListBuilderMode aBuilderMode,
1175 /**
1176 * Uses a binary search for find where the cursor falls in the line of text
1177 * It also keeps track of the part of the string that has already been
1178 * measured so it doesn't have to keep measuring the same text over and over.
1179 *
1180 * @param "aBaseWidth" contains the width in twips of the portion
1181 * of the text that has already been measured, and aBaseInx contains
1182 * the index of the text that has already been measured.
1183 *
1184 * @param aTextWidth returns (in twips) the length of the text that falls
1185 * before the cursor aIndex contains the index of the text where the cursor
1186 * falls.
1187 */
1200 // Whether we are in a continuation or ib-split-sibling of the target we're
1201 // measuring. This is useful because if we know we're in the target subtree
1202 // and measuring against it we can avoid finding the common ancestor.
1204 };
1205 /**
1206 * Collect all CSS boxes associated with aFrame and its
1207 * continuations, "drilling down" through table wrapper frames and
1208 * some anonymous blocks since they're not real CSS boxes.
1209 * If aFrame is null, no boxes are returned.
1210 * SVG frames return a single box, themselves.
1211 */
1214 /**
1215 * Like GetAllInFlowBoxes, but doesn't include continuations.
1216 */
1219 /**
1220 * Find the first frame descendant of aFrame (including aFrame) which is
1221 * not an anonymous frame that getBoxQuads/getClientRects should ignore.
1222 */
1226 nsRect mResultRect;
1227 nsRect mFirstRect;
1233 };
1240 };
1246 // Two bits for specifying which box type to use.
1247 // With neither bit set (default), use the border box.
1252 };
1253 /**
1254 * Collect all CSS boxes (content, padding, border, or margin) associated
1255 * with aFrame and its continuations, "drilling down" through table wrapper
1256 * frames and some anonymous blocks since they're not real CSS boxes.
1257 * The boxes are positioned relative to aRelativeTo (taking scrolling
1258 * into account) and passed to the callback in frame-tree order.
1259 * If aFrame is null, no boxes are returned.
1260 * For SVG frames, returns one rectangle, the bounding box.
1261 * If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting
1262 * the boxes into aRelativeTo coordinates, transforms (including CSS
1263 * and SVG transforms) are taken into account.
1264 * If aFlags includes one of RECTS_USE_CONTENT_BOX, RECTS_USE_PADDING_BOX,
1265 * or RECTS_USE_MARGIN_BOX, the corresponding type of box is used.
1266 * Otherwise (by default), the border box is used.
1267 */
1277 /**
1278 * Computes the union of all rects returned by GetAllInFlowRects. If
1279 * the union is empty, returns the first rect.
1280 * If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting
1281 * the boxes into aRelativeTo coordinates, transforms (including CSS
1282 * and SVG transforms) are taken into account.
1283 * If aFlags includes one of RECTS_USE_CONTENT_BOX, RECTS_USE_PADDING_BOX,
1284 * or RECTS_USE_MARGIN_BOX, the corresponding type of box is used.
1285 * Otherwise (by default), the border box is used.
1286 */
1292 /**
1293 * Takes a text-shadow array from the style properties of a given nsIFrame and
1294 * computes the union of those shadows along with the given initial rect.
1295 * If there are no shadows, the initial rect is returned.
1296 */
1300 /**
1301 * Computes the destination rect that a given replaced element should render
1302 * into, based on its CSS 'object-fit' and 'object-position' properties.
1303 *
1304 * @param aConstraintRect The constraint rect that we have at our disposal,
1305 * which would e.g. be exactly filled by the image
1306 * if we had "object-fit: fill".
1307 * @param aIntrinsicSize The replaced content's intrinsic size, as reported
1308 * by nsIFrame::GetIntrinsicSize().
1309 * @param aIntrinsicRatio The replaced content's intrinsic ratio, as reported
1310 * by nsIFrame::GetIntrinsicRatio().
1311 * @param aStylePos The nsStylePosition struct that contains the 'object-fit'
1312 * and 'object-position' values that we should rely on.
1313 * (This should usually be the nsStylePosition for the
1314 * replaced element in question, but not always. For
1315 * example, a <video>'s poster-image has a dedicated
1316 * anonymous element & child-frame, but we should still use
1317 * the <video>'s 'object-fit' and 'object-position' values.)
1318 * @param aAnchorPoint [out] A point that should be pixel-aligned by functions
1319 * like nsLayoutUtils::DrawImage. See documentation
1320 * in nsCSSRendering.h for ComputeObjectAnchorPoint.
1321 * @return The nsRect into which we should render the replaced content (using
1322 * the same coordinate space as the passed-in aConstraintRect).
1323 */
1330 /**
1331 * Get the font metrics corresponding to the frame's style data.
1332 * @param aFrame the frame
1333 * @param aSizeInflation number to multiply font size by
1334 */
1341 }
1343 /**
1344 * Get the font metrics corresponding to the given style data.
1345 * @param aComputedStyle the style data
1346 * @param aSizeInflation number to multiply font size by
1347 */
1353 /**
1354 * Get the font metrics of emphasis marks corresponding to the given
1355 * style data. The result is same as GetFontMetricsForComputedStyle
1356 * except that the font size is scaled down to 50%.
1357 * @param aComputedStyle the style data
1358 * @param aInflation number to multiple font size by
1359 */
1365 }
1367 /**
1368 * Find the immediate child of aParent whose frame subtree contains
1369 * aDescendantFrame. Returns null if aDescendantFrame is not a descendant
1370 * of aParent.
1371 */
1375 /**
1376 * Find the nearest ancestor that's a block
1377 */
1380 /**
1381 * Find the nearest ancestor that's not for generated content. Will return
1382 * aFrame if aFrame is not for generated content.
1383 */
1386 /*
1387 * Whether the frame is an nsBlockFrame which is not a wrapper block.
1388 */
1391 /**
1392 * If aFrame is an out of flow frame, return its placeholder, otherwise
1393 * return its parent.
1394 */
1397 /**
1398 * If aFrame is an out of flow frame, return its placeholder, otherwise
1399 * return its (possibly cross-doc) parent.
1400 */
1403 /**
1404 * Returns the frame that would act as the parent of aFrame when
1405 * descending through the frame tree in display list building.
1406 * Usually the same as GetParentOrPlaceholderForCrossDoc, except
1407 * that pushed floats are treated as children of their containing
1408 * block.
1409 */
1412 /**
1413 * Get a frame's previous continuation, or, if it doesn't have one, its
1414 * previous block-in-inline-split sibling.
1415 */
1418 /**
1419 * Get a frame's next continuation, or, if it doesn't have one, its
1420 * block-in-inline-split sibling.
1421 */
1424 /**
1425 * Get the first frame in the continuation-plus-ib-split-sibling chain
1426 * containing aFrame.
1427 */
1430 /**
1431 * Get the last frame in the continuation-plus-ib-split-sibling chain
1432 * containing aFrame.
1433 */
1436 /**
1437 * Is FirstContinuationOrIBSplitSibling(aFrame) going to return
1438 * aFrame?
1439 */
1442 /**
1443 * Check whether aFrame is a part of the scrollbar or scrollcorner of
1444 * the root content.
1445 * @param aFrame the checking frame.
1446 * @return true if the frame is a part of the scrollbar or scrollcorner of
1447 * the root content.
1448 */
1451 /**
1452 * Get the contribution of aFrame to its containing block's intrinsic
1453 * size for the given physical axis. This considers the child's intrinsic
1454 * width, its 'width', 'min-width', and 'max-width' properties (or 'height'
1455 * variations if that's what matches aAxis) and its padding, border and margin
1456 * in the corresponding dimension.
1457 * @param aPercentageBasis an optional percentage basis (in aFrame's WM).
1458 * If the basis is indefinite in a given axis, pass a size with
1459 * NS_UNCONSTRAINEDSIZE in that component.
1460 * If you pass Nothing() a percentage basis will be calculated from aFrame's
1461 * ancestors' computed size in the relevant axis, if needed.
1462 * @param aMarginBoxMinSizeClamp make the result fit within this margin-box
1463 * size by reducing the *content size* (flooring at zero). This is used for:
1464 * https://drafts.csswg.org/css-grid/#min-size-auto
1465 */
1470 };
1476 /**
1477 * Calls IntrinsicForAxis with aFrame's parent's inline physical axis.
1478 */
1484 /**
1485 * Get the definite size contribution of aFrame for the given physical axis.
1486 * This considers the child's 'min-width' property (or 'min-height' if the
1487 * given axis is vertical), and its padding, border, and margin in the
1488 * corresponding dimension. If the 'min-' property is 'auto' (and 'overflow'
1489 * is 'visible') and the corresponding 'width'/'height' is definite it returns
1490 * the "specified size" for:
1491 * https://drafts.csswg.org/css-grid/#min-size-auto
1492 * Note that the "transferred size" is not handled here; use IntrinsicForAxis.
1493 * Note that any percentage in 'width'/'height' makes it count as indefinite.
1494 * If the 'min-' property is 'auto' and 'overflow' is not 'visible', then it
1495 * calculates the result as if the 'min-' computed value is zero.
1496 * Otherwise, return NS_UNCONSTRAINEDSIZE.
1497 *
1498 * @param aPercentageBasis the percentage basis (in aFrame's WM).
1499 * Pass NS_UNCONSTRAINEDSIZE if the basis is indefinite in either/both axes.
1500 * @note this behavior is specific to Grid/Flexbox (currently) so aFrame
1501 * should be a grid/flex item.
1502 */
1509 /*
1510 * Convert LengthPercentage to nscoord when percentages depend on the
1511 * containing block size.
1512 * @param aPercentBasis The width or height of the containing block
1513 * (whichever the client wants to use for resolving percentages).
1514 */
1519 "have unconstrained width or height; this should only result from very "
1522 }
1527 }
1529 }
1535 nscoord aContentEdgeToBoxSizingBoxEdge,
1541 // Clamp calc(), and the subtraction for box-sizing.
1543 }
1545 /**
1546 * The "extremum length" values (see ExtremumLength) were originally aimed at
1547 * inline-size (or width, as it was before logicalization). For now, we return
1548 * true for those here, so that we don't call ComputeBSizeValue with value
1549 * types that it doesn't understand. (See bug 1113216.)
1550 *
1551 * FIXME (bug 567039, bug 527285)
1552 * This isn't correct for the 'fill' value or for the 'min-*' or 'max-*'
1553 * properties, which need to be handled differently by the callers of
1554 * IsAutoBSize().
1555 */
1560 }
1563 // clamp negative calc() to 0
1565 }
1569 }
1575 /*
1576 * Calculate the used values for 'width' and 'height' when width
1577 * and height are 'auto'. The tentWidth and tentHeight arguments should be
1578 * the result of applying the rules for computing intrinsic sizes and ratios.
1579 * as specified by CSS 2.1 sections 10.3.2 and 10.6.2
1580 */
1585 // Implement nsIFrame::GetPrefISize in terms of nsIFrame::AddInlinePrefISize
1589 // Implement nsIFrame::GetMinISize in terms of nsIFrame::AddInlineMinISize
1593 // Get a suitable foreground color for painting aColor for aFrame.
1596 // Get a suitable foreground color for painting aField for aFrame.
1597 // Type of aFrame is made a template parameter because nsIFrame is not
1598 // a complete type in the header. Type-safety is not harmed given that
1599 // DarkenColorIfNeeded requires an nsIFrame pointer.
1604 }
1606 // Get a baseline y position in app units that is snapped to device pixels.
1609 // Ditto for an x position (for vertical text). Note that for vertical-rl
1610 // writing mode, the ascent value should be negated by the caller.
1617 }
1623 }
1633 }
1659 /**
1660 * Supports only LTR or RTL. Bidi (mixed direction) is not supported.
1661 */
1667 /**
1668 * Helper function for drawing text-shadow. The callback's job
1669 * is to draw whatever needs to be blurred onto the given context.
1670 */
1677 TextShadowCallback aCallback,
1680 /**
1681 * Gets the baseline to vertically center text from a font within a
1682 * line of specified height.
1683 * aIsInverted: true if the text is inverted relative to the block
1684 * direction, so that the block-dir "ascent" corresponds to font
1685 * descent. (Applies to sideways text in vertical-lr mode.)
1686 *
1687 * Returns the baseline position relative to the top of the line.
1688 */
1692 /**
1693 * Derive a baseline of |aFrame| (measured from its top border edge)
1694 * from its first in-flow line box (not descending into anything with
1695 * 'overflow' not 'visible', potentially including aFrame itself).
1696 *
1697 * Returns true if a baseline was found (and fills in aResult).
1698 * Otherwise returns false.
1699 */
1703 /**
1704 * Just like GetFirstLineBaseline, except also returns the top and
1705 * bottom of the line with the baseline.
1706 *
1707 * Returns true if a line was found (and fills in aResult).
1708 * Otherwise returns false.
1709 */
1716 LinePosition result;
1721 }
1722 };
1727 /**
1728 * Derive a baseline of |aFrame| (measured from its top border edge)
1729 * from its last in-flow line box (not descending into anything with
1730 * 'overflow' not 'visible', potentially including aFrame itself).
1731 *
1732 * Returns true if a baseline was found (and fills in aResult).
1733 * Otherwise returns false.
1734 */
1738 /**
1739 * Returns a block-dir coordinate relative to this frame's origin that
1740 * represents the logical block-end of the frame or its visible content,
1741 * whichever is further from the origin.
1742 * Relative positioning is ignored and margins and glyph bounds are not
1743 * considered.
1744 * This value will be >= mRect.BSize() and <= overflowRect.BEnd() unless
1745 * relative positioning is applied.
1746 */
1750 /**
1751 * Gets the closest frame (the frame passed in or one of its parents) that
1752 * qualifies as a "layer"; used in DOM0 methods that depends upon that
1753 * definition. This is the nearest frame that is either positioned or scrolled
1754 * (the child of a scroll frame).
1755 */
1758 /**
1759 * Gets the graphics sampling filter for the frame
1760 */
1776 }
1777 }
1779 /**
1780 * Convert an nsRect to a gfxRect.
1781 */
1789 }
1791 /* N.B. The only difference between variants of the Draw*Image
1792 * functions below is the type of the aImage argument.
1793 */
1795 /**
1796 * Draw a background image. The image's dimensions are as specified in aDest;
1797 * the image itself is not consulted to determine a size.
1798 * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
1799 *
1800 * @param aContext
1801 * The context to draw to, already set up with an appropriate scale and
1802 * transform for drawing in app units.
1803 * @param aForFrame
1804 * The nsIFrame that we're drawing this image for.
1805 * @param aImage
1806 * The image.
1807 * @param aDest
1808 * The position and scaled area where one copy of the image should be drawn.
1809 * This area represents the image itself in its correct position as defined
1810 * with the background-position css property.
1811 * @param aFill
1812 * The area to be filled with copies of the image.
1813 * @param aRepeatSize
1814 * The distance between the positions of two subsequent repeats of the image.
1815 * Sizes larger than aDest.Size() create gaps between the images.
1816 * @param aAnchor
1817 * A point in aFill which we will ensure is pixel-aligned in the output.
1818 * @param aDirty
1819 * Pixels outside this area may be skipped.
1820 * @param aImageFlags
1821 * Image flags of the imgIContainer::FLAG_* variety.
1822 * @param aExtendMode
1823 * How to extend the image over the dest rect.
1824 */
1832 /**
1833 * Draw an image.
1834 * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
1835 * @param aRenderingContext Where to draw the image, set up with an
1836 * appropriate scale and transform for drawing in
1837 * app units.
1838 * @param aComputedStyle The ComputedStyle of the nsIFrame (or
1839 * pseudo-element) for which this image is being
1840 * drawn.
1841 * @param aImage The image.
1842 * @param aDest Where one copy of the image should mapped to.
1843 * @param aFill The area to be filled with copies of the
1844 * image.
1845 * @param aAnchor A point in aFill which we will ensure is
1846 * pixel-aligned in the output.
1847 * @param aDirty Pixels outside this area may be skipped.
1848 * @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
1849 */
1859 /**
1860 * Draw a whole image without scaling or tiling.
1861 *
1862 * @param aRenderingContext Where to draw the image, set up with an
1863 * appropriate scale and transform for drawing in
1864 * app units.
1865 * @param aImage The image.
1866 * @param aDest The top-left where the image should be drawn.
1867 * @param aDirty If non-null, then pixels outside this area may
1868 * be skipped.
1869 * @param aSVGContext Optionally provides an SVGImageContext.
1870 * Callers should pass an SVGImageContext with at
1871 * least the viewport size set if aImage may be of
1872 * type imgIContainer::TYPE_VECTOR, or pass
1873 * Nothing() if it is of type
1874 * imgIContainer::TYPE_RASTER (to save cycles
1875 * constructing an SVGImageContext, since this
1876 * argument will be ignored for raster images).
1877 * @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
1878 * @param aSourceArea If non-null, this area is extracted from
1879 * the image and drawn at aDest. It's
1880 * in appunits. For best results it should
1881 * be aligned with image pixels.
1882 */
1889 /**
1890 * Draw a whole image without tiling.
1891 *
1892 * @param aRenderingContext Where to draw the image, set up with an
1893 * appropriate scale and transform for drawing in
1894 * app units.
1895 * @param aImage The image.
1896 * @param aDest The area that the image should fill.
1897 * @param aDirty Pixels outside this area may be skipped.
1898 * @param aSVGContext Optionally provides an SVGImageContext.
1899 * Callers should pass an SVGImageContext with at
1900 * least the viewport size set if aImage may be of
1901 * type imgIContainer::TYPE_VECTOR, or pass
1902 * Nothing() if it is of type
1903 * imgIContainer::TYPE_RASTER (to save cycles
1904 * constructing an SVGImageContext, since this
1905 * argument will be ignored for raster images).
1906 * @param aImageFlags Image flags of the imgIContainer::FLAG_*
1907 * variety.
1908 * @param aAnchor If non-null, a point which we will ensure
1909 * is pixel-aligned in the output.
1910 */
1917 /**
1918 * Given an imgIContainer, this method attempts to obtain an intrinsic
1919 * px-valued height & width for it. If the imgIContainer has a non-pixel
1920 * value for either height or width, this method tries to generate a pixel
1921 * value for that dimension using the intrinsic ratio (if available). The
1922 * intrinsic ratio will be assigned to aIntrinsicRatio; if there's no
1923 * intrinsic ratio then (0, 0) will be assigned.
1924 *
1925 * This method will always set aGotWidth and aGotHeight to indicate whether
1926 * we were able to successfully obtain (or compute) a value for each
1927 * dimension.
1928 *
1929 * NOTE: This method is similar to ComputeSizeWithIntrinsicDimensions. The
1930 * difference is that this one is simpler and is suited to places where we
1931 * have less information about the frame tree.
1932 *
1933 * @param aResolution The resolution specified by the author for the image, or
1934 * its intrinsic resolution.
1935 *
1936 * This will affect the intrinsic size size of the image
1937 * (so e.g., if resolution is 2, and the image is 100x100,
1938 * the intrinsic size of the image will be 50x50).
1939 */
1946 /**
1947 * Given an imgIContainer, this method attempts to obtain an intrinsic
1948 * px-valued height & width for it. If the imgIContainer has a non-pixel
1949 * value for either height or width, this method tries to generate a pixel
1950 * value for that dimension using the intrinsic ratio (if available). If,
1951 * after trying all these methods, no value is available for one or both
1952 * dimensions, the corresponding dimension of aFallbackSize is used instead.
1953 */
1958 /**
1959 * Given the image container, frame, and dest rect, determine the best fitting
1960 * size to decode the image at, and calculate any necessary SVG parameters.
1961 */
1969 /**
1970 * Given a source area of an image (in appunits) and a destination area
1971 * that we want to map that source area too, computes the area that
1972 * would be covered by the whole image. This is useful for passing to
1973 * the aDest parameter of DrawImage, when we want to draw a subimage
1974 * of an overall image.
1975 */
1980 /**
1981 * Given an image container and an orientation, returns an image container
1982 * that contains the same image, reoriented appropriately. May return the
1983 * original image container if no changes are needed.
1984 *
1985 * @param aContainer The image container to apply the orientation to.
1986 * @param aOrientation The desired orientation.
1987 */
1992 /**
1993 * Given an image request, determine if the request uses CORS.
1994 */
1997 /**
1998 * Determine if any corner radius is of nonzero size
1999 * @param aCorners the |BorderRadius| object to check
2000 * @return true unless all the coordinates are 0%, 0 or null.
2001 *
2002 * A corner radius with one dimension zero and one nonzero is
2003 * treated as a nonzero-radius corner, even though it will end up
2004 * being rendered like a zero-radius corner. This is because such
2005 * corners are not expected to appear outside of test cases, and it's
2006 * simpler to implement the test this way.
2007 */
2010 /**
2011 * Determine if there is any corner radius on corners adjacent to the
2012 * given side.
2013 */
2017 /**
2018 * Determine if a widget is likely to require transparency or translucency.
2019 * @param aBackgroundFrame The frame that the background is set on. For
2020 * <window>s, this will be the canvas frame.
2021 * @param aCSSRootFrame The frame that holds CSS properties affecting
2022 * the widget's transparency. For menupopups,
2023 * aBackgroundFrame and aCSSRootFrame will be the
2024 * same.
2025 * @return a value suitable for passing to SetWindowTranslucency.
2026 */
2031 /**
2032 * A frame is a popup if it has its own floating window. Menus, panels
2033 * and combobox dropdowns are popups.
2034 */
2037 /**
2038 * Find the nearest "display root". This is the nearest enclosing
2039 * popup frame or the root prescontext's root frame.
2040 */
2044 /**
2045 * Get the reference frame that would be used when constructing a
2046 * display item for this frame. Rather than using their own frame
2047 * as a reference frame.)
2048 *
2049 * This duplicates some of the logic of GetDisplayRootFrame above and
2050 * of nsDisplayListBuilder::FindReferenceFrameFor.
2051 *
2052 * If you have an nsDisplayListBuilder, you should get the reference
2053 * frame from it instead of calling this.
2054 */
2057 /**
2058 * Get textrun construction flags determined by a given style; in particular
2059 * some combination of:
2060 * -- TEXT_DISABLE_OPTIONAL_LIGATURES if letter-spacing is in use
2061 * -- TEXT_OPTIMIZE_SPEED if the text-rendering CSS property and font size
2062 * and prefs indicate we should be optimizing for speed over quality
2063 */
2068 /**
2069 * Get orientation flags for textrun construction.
2070 */
2074 /**
2075 * Takes two rectangles whose origins must be the same, and computes
2076 * the difference between their union and their intersection as two
2077 * rectangles. (This difference is a superset of the difference
2078 * between the two rectangles.)
2079 */
2083 /**
2084 * Get a device context that can be used to get up-to-date device
2085 * dimensions for the given window. For some reason, this is more
2086 * complicated than it ought to be in multi-monitor situations.
2087 */
2091 /**
2092 * Some frames with 'position: fixed' (nsStyleDisplay::mPosition ==
2093 * StylePositionProperty::Fixed) are not really fixed positioned, since
2094 * they're inside a transformed element or other element that establishes a
2095 * fixed-pos containing block). This function says whether such an element is
2096 * a real fixed-pos element.
2097 */
2100 /**
2101 * This function says whether `aFrame` would really be a fixed positioned
2102 * frame if the frame was created with StylePositionProperty::Fixed.
2103 *
2104 * It is effectively the same as IsReallyFixedPos, but without asserting the
2105 * position value. Use it only when you know what you're doing, like when
2106 * tearing down the frame tree (where styles may have changed due to
2107 * ::first-line reparenting and rule changes at the same time).
2108 */
2111 /**
2112 * Returns true if |aFrame| is inside position:fixed subtree.
2113 */
2116 /**
2117 * Obtain a SourceSurface from the given DOM element, if possible.
2118 * This obtains the most natural surface from the element; that
2119 * is, the one that can be obtained with the fewest conversions.
2120 *
2121 * The flags below can modify the behaviour of this function. The
2122 * result is returned as a SurfaceFromElementResult struct, also
2123 * defined below.
2124 *
2125 * Currently, this will do:
2126 * - HTML Canvas elements: will return the underlying canvas surface
2127 * - HTML Video elements: will return the current video frame
2128 * - Image elements: will return the image
2129 *
2130 * The above results are modified by the below flags (copying,
2131 * forcing image surface, etc.).
2132 */
2135 /* Whether to extract the first frame (as opposed to the
2136 current frame) in the case that the element is an image. */
2138 /* Whether we should skip colorspace/gamma conversion */
2140 /* Caller handles SFER::mAlphaType = NonPremult */
2142 /* Whether we should skip getting a surface for vector images and
2143 return a DirectDrawInfo containing an imgIContainer instead. */
2145 /* If image type is vector, the return surface size will same as
2146 element size, not image's intrinsic size. */
2148 /* Ensure that the returned surface has a size that matches the
2149 * SurfaceFromElementResult::mSize. This is mostly a convenience thing so
2150 * that callers who want this don't have to deal with it themselves.
2151 * The surface might be different for, e.g., a EXIF-scaled raster image, if
2152 * we don't rescale during decode. */
2154 /* Use orientation from image */
2156 /* Caller handles SFER::mCropRect.isSome() */
2158 };
2160 // This function can be called on any thread.
2169 }
2170 // This function can be called on any thread.
2178 }
2179 // This function can be called on any thread.
2193 }
2199 }
2208 }
2210 // There are a bunch of callers of SurfaceFromElement. Just mark it as
2211 MOZ_CAN_RUN_SCRIPT_BOUNDARY
2217 // Need an HTMLImageElement overload, because otherwise the
2218 // nsIImageLoadingContent and mozilla::dom::Element overloads are ambiguous
2219 // for HTMLImageElement.
2230 }
2235 /**
2236 * When the document is editable by contenteditable attribute of its root
2237 * content or body content.
2238 *
2239 * Be aware, this returns nullptr if it's in designMode.
2240 *
2241 * For example:
2242 *
2243 * <html contenteditable="true"><body></body></html>
2244 * returns the <html>.
2245 *
2246 * <html><body contenteditable="true"></body></html>
2247 * <body contenteditable="true"></body>
2248 * With these cases, this returns the <body>.
2249 * NOTE: The latter case isn't created normally, however, it can be
2250 * created by script with XHTML.
2251 *
2252 * <body><p contenteditable="true"></p></body>
2253 * returns nullptr because <body> isn't editable.
2254 */
2262 nscolor aBackstop);
2264 /**
2265 * Returns true if the passed in prescontext needs the dark grey background
2266 * that goes behind the page of a print preview presentation.
2267 */
2270 /**
2271 * Types used by the helpers for InspectorUtils.getUsedFontFaces.
2272 * The API returns an array (UsedFontFaceList) that owns the
2273 * InspectorFontFace instances, but during range traversal we also
2274 * want to maintain a mapping from gfxFontEntry to InspectorFontFace
2275 * records, so use a temporary hashtable for that.
2276 */
2278 UsedFontFaceList;
2281 UsedFontFaceTable;
2283 /**
2284 * Adds all font faces used in the frame tree starting from aFrame
2285 * to the list aFontFaceList.
2286 * aMaxRanges: maximum number of text ranges to record for each face.
2287 */
2294 /**
2295 * Adds all font faces used within the specified range of text in aFrame,
2296 * and optionally its continuations, to the list in aFontFaceList.
2297 * Pass 0 and INT32_MAX for aStartOffset and aEndOffset to specify the
2298 * entire text is to be considered.
2299 * aMaxRanges: maximum number of text ranges to record for each face.
2300 */
2308 /**
2309 * Walks the frame tree starting at aFrame looking for textRuns.
2310 * If |clear| is true, just clears the TEXT_RUN_MEMORY_ACCOUNTED flag
2311 * on each textRun found (and |aMallocSizeOf| is not used).
2312 * If |clear| is false, adds the storage used for each textRun to the
2313 * total, and sets the TEXT_RUN_MEMORY_ACCOUNTED flag to avoid double-
2314 * accounting. (Runs with this flag already set will be skipped.)
2315 * Expected usage pattern is therefore to call twice:
2316 * (void)SizeOfTextRunsForFrames(rootFrame, nullptr, true);
2317 * total = SizeOfTextRunsForFrames(rootFrame, mallocSizeOf, false);
2318 */
2323 /**
2324 * Returns true if |aFrame| has an animation of a property in |aPropertySet|
2325 * regardless of whether any property in the set is overridden by an
2326 * !important rule.
2327 */
2331 /**
2332 * A variant of the above HasAnimationOfPropertySet that takes an optional
2333 * EffectSet parameter as an optimization to save redundant lookups of the
2334 * EffectSet.
2335 */
2340 /**
2341 * A variant of the above HasAnimationOfPropertySet. This is especially for
2342 * tranform-like properties with motion-path.
2343 * For transform-like properties with motion-path, we need to check if
2344 * offset-path has effect. If we don't have any animation on offset-path and
2345 * offset-path is none, there is no effective motion-path, and so we don't
2346 * care other offset-* properties. In this case, this function only checks the
2347 * rest of transform-like properties (i.e. transform/translate/rotate/scale).
2348 */
2351 /**
2352 * Returns true if |aFrame| has an animation of |aProperty| which is
2353 * not overridden by !important rules.
2354 */
2356 nsCSSPropertyID aProperty);
2358 /**
2359 * Returns true if |aFrame| has an animation where at least one of the
2360 * properties in |aPropertySet| is not overridden by !important rules.
2361 *
2362 * If |aPropertySet| includes transform-like properties (transform, rotate,
2363 * etc.) however, this will return false if any of the transform-like
2364 * properties is overriden by an !important rule since these properties should
2365 * be combined on the compositor.
2366 */
2370 /**
2371 * Returns all effective animated CSS properties on |aStyleFrame| and its
2372 * corresponding primary frame (for content that makes this distinction,
2373 * notable display:table content) that can be animated on the compositor.
2374 *
2375 * Properties that can be animated on the compositor but which are overridden
2376 * by !important rules are not returned.
2377 *
2378 * Unlike HasEffectiveAnimation, however, this does not check the set of
2379 * transform-like properties to ensure that if any such properties are
2380 * overridden by !important rules, the other transform-like properties are
2381 * not run on the compositor (see bug 1534884).
2382 */
2386 /**
2387 * Checks if off-main-thread animations are enabled.
2388 */
2391 /**
2392 * Checks if retained display lists are enabled.
2393 */
2401 /**
2402 * Find a suitable scale for a element (aFrame's content) over the course of
2403 * any animations and transitions of the CSS transform property on the element
2404 * that run on the compositor thread. It will check the maximum and minimum
2405 * scale during the animations and transitions and return a suitable value for
2406 * performance and quality. Will return scale(1,1) if there are no such
2407 * animations. Always returns a positive value.
2408 * @param aVisibleSize is the size of the area we want to paint
2409 * @param aDisplaySize is the size of the display area of the pres context
2410 */
2415 /**
2416 * Checks whether we want to use the GPU to scale images when
2417 * possible.
2418 */
2421 /**
2422 * Unions the overflow areas of the children of aFrame with aOverflowAreas.
2423 * aSkipChildLists specifies any child lists that should be skipped.
2424 * FrameChildListID::Popup is always skipped.
2425 */
2430 /**
2431 * Return the font size inflation *ratio* for a given frame. This is
2432 * the factor by which font sizes should be inflated; it is never
2433 * smaller than 1.
2434 */
2437 /**
2438 * Perform the first half of the computation of FontSizeInflationFor
2439 * (see above).
2440 * This includes determining whether inflation should be performed
2441 * within this container and returning 0 if it should not be.
2442 *
2443 * The result is guaranteed not to vary between line participants
2444 * (inlines, text frames) within a line.
2445 *
2446 * The result should not be used directly since font sizes slightly
2447 * above the minimum should always be adjusted as done by
2448 * FontSizeInflationInner.
2449 */
2452 /**
2453 * Perform the second half of the computation done by
2454 * FontSizeInflationFor (see above).
2455 *
2456 * aMinFontSize must be the result of one of the
2457 * InflationMinFontSizeFor methods above.
2458 */
2460 nscoord aMinFontSize);
2464 /**
2465 * Returns true if the nglayout.debug.invalidation pref is set to true.
2466 */
2470 }
2475 /**
2476 * Register an imgIRequest object with a refresh driver.
2477 *
2478 * @param aPresContext The nsPresContext whose refresh driver we want to
2479 * register with.
2480 * @param aRequest A pointer to the imgIRequest object which the client wants
2481 * to register with the refresh driver.
2482 * @param aRequestRegistered A pointer to a boolean value which indicates
2483 * whether the given image request is registered. If
2484 * *aRequestRegistered is true, then this request will not be
2485 * registered again. If the request is registered by this function,
2486 * then *aRequestRegistered will be set to true upon the completion of
2487 * this function.
2488 *
2489 */
2494 /**
2495 * Register an imgIRequest object with a refresh driver, but only if the
2496 * request is for an image that is animated.
2497 *
2498 * @param aPresContext The nsPresContext whose refresh driver we want to
2499 * register with.
2500 * @param aRequest A pointer to the imgIRequest object which the client wants
2501 * to register with the refresh driver.
2502 * @param aRequestRegistered A pointer to a boolean value which indicates
2503 * whether the given image request is registered. If
2504 * *aRequestRegistered is true, then this request will not be
2505 * registered again. If the request is registered by this function,
2506 * then *aRequestRegistered will be set to true upon the completion of
2507 * this function.
2508 *
2509 */
2514 /**
2515 * Deregister an imgIRequest object from a refresh driver.
2516 *
2517 * @param aPresContext The nsPresContext whose refresh driver we want to
2518 * deregister from.
2519 * @param aRequest A pointer to the imgIRequest object with which the client
2520 * previously registered and now wants to deregister from the refresh
2521 * driver.
2522 * @param aRequestRegistered A pointer to a boolean value which indicates
2523 * whether the given image request is registered. If
2524 * *aRequestRegistered is false, then this request will not be
2525 * deregistered. If the request is deregistered by this function,
2526 * then *aRequestRegistered will be set to false upon the completion of
2527 * this function.
2528 */
2533 /**
2534 * Shim to nsCSSFrameConstructor::PostRestyleEvent. Exists so that we
2535 * can avoid including nsCSSFrameConstructor.h and all its dependencies
2536 * in content files.
2537 */
2539 nsChangeHint aMinChangeHint);
2541 /**
2542 * Updates a pair of x and y distances if a given point is closer to a given
2543 * rectangle than the original distance values. If aPoint is closer to
2544 * aRect than aClosestXDistance and aClosestYDistance indicate, then those
2545 * two variables are updated with the distance between aPoint and aRect,
2546 * and true is returned. If aPoint is not closer, then aClosestXDistance
2547 * and aClosestYDistance are left unchanged, and false is returned.
2548 *
2549 * Distances are measured in the two dimensions separately; a closer x
2550 * distance beats a closer y distance.
2551 */
2556 /**
2557 * Computes the box shadow rect for the frame, or returns an empty rect if
2558 * there are no shadows.
2559 *
2560 * @param aFrame Frame to compute shadows for.
2561 * @param aFrameSize Size of aFrame (in case it hasn't been set yet).
2562 */
2566 #ifdef DEBUG
2567 /**
2568 * Assert that there are no duplicate continuations of the same frame
2569 * within aFrameList. Optimize the tests by assuming that all frames
2570 * in aFrameList have parent aContainer.
2571 */
2575 /**
2576 * Assert that the frame tree rooted at |aSubtreeRoot| is empty, i.e.,
2577 * that it contains no first-in-flows.
2578 */
2580 #endif
2582 /**
2583 * Helper method to transform |aBounds| from aFrame to aAncestorFrame,
2584 * and combine it with |aPreciseTargetDest| if it is axis-aligned, or
2585 * combine it with |aImpreciseTargetDest| if not. The transformed rect is
2586 * clipped to |aClip|; if |aClip| has rounded corners, that also causes
2587 * the imprecise target to be used.
2588 */
2595 /**
2596 * Populate aOutSize with the size of the content viewer corresponding
2597 * to the given prescontext. Return true if the size was set, false
2598 * otherwise.
2599 */
2605 /**
2606 * Whether to include the dynamic toolbar area automatically (depending
2607 * whether the root container is scrollable or not) or forcibly in below
2608 * UpdateCompositionBoundsForRCDRSF and CalculateCompositionSizeForFrame
2609 * functions.
2610 */
2616 IncludeDynamicToolbar aIncludeDynamicToolbar =
2620 /**
2621 * Calculate the compostion size for a frame. See FrameMetrics.h for
2622 * defintion of composition size (or bounds).
2623 * Note that for the root content document's root scroll frame (RCD-RSF),
2624 * the returned size does not change as the document's resolution changes,
2625 * but for all other frames it does. This means that callers that pass in
2626 * a frame that may or may not be the RCD-RSF (which is most callers),
2627 * are likely to need special-case handling of the RCD-RSF.
2628 */
2632 IncludeDynamicToolbar aIncludeDynamicToolbar =
2635 /**
2636 * Calculate a size suitable for bounding the size of the composition bounds
2637 * of scroll frames in the current process. This should be at most the
2638 * composition size of the cross-process RCD-RSF, but it may be a tighter
2639 * bounding size.
2640 * @param aFrame A frame in the (in-process) root content document (or a
2641 * descendant of it).
2642 * @param aIsRootContentDocRootScrollFrame Whether aFrame is the root
2643 * scroll frame of the *cross-process* root content document.
2644 * In this case we just use aFrame's own composition size.
2645 * @param aMetrics A partially populated FrameMetrics for aFrame. Must have at
2646 * least mCompositionBounds, mCumulativeResolution, and
2647 * mDevPixelsPerCSSPixel set.
2648 */
2653 /**
2654 * Calculate the scrollable rect for a frame. See FrameMetrics.h for
2655 * defintion of scrollable rect. aScrollableFrame is the scroll frame to
2656 * calculate the scrollable rect for. If it's null then we calculate the
2657 * scrollable rect as the rect of the root frame.
2658 */
2662 /**
2663 * Calculate the expanded scrollable rect for a frame. See FrameMetrics.h for
2664 * defintion of expanded scrollable rect.
2665 */
2668 /**
2669 * Returns true if the widget owning the given frame uses asynchronous
2670 * scrolling.
2671 */
2674 /**
2675 * Returns true if the widget owning the given frame has builtin APZ support
2676 * enabled.
2677 */
2680 /**
2681 * Returns true if aDocument should be allowed to use resolution
2682 * zooming.
2683 */
2686 /**
2687 * Returns true if we need to disable async scrolling for this particular
2688 * element. Note that this does a partial disabling - the displayport still
2689 * exists but uses a very small margin, and the compositor doesn't apply the
2690 * async transform. However, the content may still be layerized.
2691 */
2694 /**
2695 * Log a key/value pair as "additional data" (not associated with a paint)
2696 * for APZ testing.
2697 * While the data is not associated with a paint, the APZTestData object
2698 * is still owned by {Client,WebRender}LayerManager, so we need to be passed
2699 * something from which we can derive the layer manager.
2700 * This function takes a display list builder as the object to derive the
2701 * layer manager from, to facilitate logging test data during display list
2702 * building, but other overloads that take other objects could be added if
2703 * desired.
2704 */
2709 /**
2710 * Log a key/value pair for APZ testing during a paint.
2711 * @param aManager The data will be written to the APZTestData associated
2712 * with this layer manager.
2713 * @param aScrollId Identifies the scroll frame to which the data pertains.
2714 * @param aKey The key under which to log the data.
2715 * @param aValue The value of the data to be logged.
2716 */
2721 }
2723 /**
2724 * A convenience overload of LogTestDataForPaint() that accepts any type
2725 * as the value, and passes it through mozilla::ToString() to obtain a string
2726 * value. The type passed must support streaming to an std::ostream.
2727 */
2733 }
2735 /**
2736 * Calculate a basic FrameMetrics with enough fields set to perform some
2737 * layout calculations. The fields set are dev-to-css ratio, pres shell
2738 * resolution, cumulative resolution, zoom, composition size, root
2739 * composition size, scroll offset and scrollable rect.
2740 *
2741 * Note that for the RCD-RSF, the scroll offset returned is the layout
2742 * viewport offset; if you need the visual viewport offset, that needs to
2743 * be queried independently via PresShell::GetVisualViewportOffset().
2744 *
2745 * By contrast, ComputeFrameMetrics() computes all the fields, but requires
2746 * extra inputs and can only be called during frame layer building.
2747 */
2760 /**
2761 * Returns true if the given scroll origin is "higher priority" than APZ.
2762 * In general any content programmatic scrolls (e.g. scrollTo calls) are
2763 * higher priority, and take precedence over APZ scrolling. This function
2764 * returns true for those, and returns false for other origins like APZ
2765 * itself, or scroll position updates from the history restore code.
2766 */
2776 /**
2777 * Returns the metadata to put onto the root layer of a layer tree, if one is
2778 * needed. The last argument is a callback function to check if the caller
2779 * already has a metadata for a given scroll id.
2780 */
2786 /**
2787 * If the given scroll frame needs an area excluded from its composition
2788 * bounds due to scrollbars, return that area, otherwise return an empty
2789 * margin.
2790 * There is no need to exclude scrollbars in the following cases:
2791 * - If the scroll frame is not the RCD-RSF; in that case, the composition
2792 * bounds is calculated based on the scroll port which already excludes
2793 * the scrollbar area.
2794 * - If the scrollbars are overlay, since then they are drawn on top of the
2795 * scrollable content.
2796 */
2802 /**
2803 * Get the text content inside the frame. This methods traverse the
2804 * frame tree and collect the content from text frames. Note that this
2805 * method is similiar to nsContentUtils::GetNodeTextContent, but it at
2806 * least differs from that method in the following things:
2807 * 1. it skips text content inside nodes like style, script, textarea
2808 * which don't generate an in-tree text frame for the text;
2809 * 2. it skips elements with display property set to none;
2810 * 3. it skips out-of-flow elements;
2811 * 4. it includes content inside pseudo elements;
2812 * 5. it may include part of text content of a node if a text frame
2813 * inside is split to different continuations.
2814 */
2817 /**
2818 * Same as GetFrameTextContent but appends the result rather than sets it.
2819 */
2822 /**
2823 * Takes a selection, and returns selection's bounding rect which is relative
2824 * to its root frame.
2825 *
2826 * @param aSel Selection to check
2827 */
2830 /**
2831 * Calculate the bounding rect of |aContent|, relative to the origin
2832 * of the scrolled content of |aRootScrollFrame|.
2833 * Where the element is contained inside a scrollable subframe, the
2834 * bounding rect is clipped to the bounds of the subframe.
2835 * If non-null aOutNearestScrollClip will be filled in with the rect of the
2836 * nearest scroll frame (excluding aRootScrollFrame) that is an ancestor of
2837 * the frame of aContent, if such exists, in the same coords are the returned
2838 * rect. This rect is used to clip the result.
2839 */
2844 /**
2845 * Similar to GetBoundingContentRect for nsIFrame.
2846 */
2851 /**
2852 * Returns the first ancestor who is a float containing block.
2853 */
2856 /**
2857 * Walks up the frame tree from |aForFrame| up to |aTopFrame|, or to the
2858 * root of the frame tree if |aTopFrame| is nullptr, and returns true if
2859 * a transformed frame is encountered.
2860 */
2863 /**
2864 * Walk up from aFrame to the cross-doc root, accumulating all the APZ
2865 * callback transforms on the content elements encountered along the way.
2866 * Return the accumulated value.
2867 * XXX: Note that this does not take into account CSS transforms, nor
2868 * differences in structure between the frame tree and the layer tree (which
2869 * is probably what we *want* to be computing).
2870 */
2873 /**
2874 * Compute a rect to pre-render in cases where we want to render more of
2875 * something than what is visible (usually to support async transformation).
2876 * @param aFrame the target frame to be pre-rendered
2877 * @param aDirtyRect the area that's visible in the coordinate system of
2878 * |aFrame|.
2879 * @param aOverflow the total size of the thing we're rendering in the
2880 * coordinate system of |aFrame|.
2881 * @param aPrerenderSize how large of an area we're willing to render in the
2882 * coordinate system of the root frame.
2883 * @return A rectangle that includes |aDirtyRect|, is clamped to |aOverflow|,
2884 * and is no larger than |aPrerenderSize| (unless |aPrerenderSize| is
2885 * smaller than |aDirtyRect|, in which case the returned rect will
2886 * still include |aDirtyRect| and thus be larger than
2887 * |aPrerenderSize|).
2888 */
2894 /*
2895 * Checks whether a node is an invisible break.
2896 * If not, returns the first frame on the next line if such a next line
2897 * exists.
2898 *
2899 * @return
2900 * true if the node is an invisible break. aNextLineFrame is returned null
2901 * in this case.
2902 *
2903 * false if the node causes a visible break or if the node is no break.
2904 *
2905 * @param aNextLineFrame
2906 * assigned to first frame on the next line if such a next line exists, null
2907 * otherwise.
2908 */
2914 // Compute the geometry box for SVG layout. The caller should map the CSS box
2915 // into the proper SVG box.
2916 // |aMayHaveCyclicDependency| is used for stroke-box to avoid the cyclic
2917 // dependency if any of its descendants uses non-scaling-stroke.
2921 MayHaveNonScalingStrokeCyclicDependency =
2924 // Compute the geometry box for CSS layout. The caller should map the SVG box
2925 // into the proper CSS box.
2934 // Callers are responsible to ensure the user-font-set is up-to-date if
2935 // aUseUserFontSet is true.
2948 /**
2949 * Returns true if there are any preferences or overrides that indicate a
2950 * need to handle <meta name="viewport"> tags.
2951 */
2954 /**
2955 * Resolve a CSS <length-percentage> value to a definite size.
2956 */
2959 nscoord aPercentageBasis) {
2964 }
2966 /**
2967 * Resolve a column-gap/row-gap to a definite size.
2968 * @note This method resolves 'normal' to zero.
2969 * Callers who want different behavior should handle 'normal' on their own.
2970 */
2973 nscoord aPercentageBasis) {
2976 }
2978 }
2980 /**
2981 * Get the computed style from which the scrollbar style should be
2982 * used for the given scrollbar part frame.
2983 */
2986 /**
2987 * Returns true if |aFrame| is scrolled out of view by a scrollable element in
2988 * a cross-process ancestor document.
2989 * Note this function only works for frames in out-of-process iframes.
2990 **/
2993 /**
2994 * Similar to above FrameIsScrolledOutViewInCrossProcess but returns true even
2995 * if |aFrame| is not fully scrolled out of view and its visible area width or
2996 * height is smaller than |aMargin|.
2997 **/
3001 /**
3002 * Expand the height of |aSize| to the size of `vh` units.
3003 *
3004 * With dynamic toolbar(s) the height for `vh` units is greater than the
3005 * ICB height, we need to expand it in some places.
3006 **/
3015 /**
3016 * Returns the nsIFrame which clips overflow regions of the given |aFrame|.
3017 * Note CSS clip or clip-path isn't accounted for.
3018 **/
3021 /*
3022 * Returns true if the user's preferences allow for smooth scrolling.
3023 */
3026 /*
3027 * Recompute the default value of general.smoothScroll based on
3028 * the system settings for prefers-reduced-motion.
3029 *
3030 * Note: Must only be called from the main thread.
3031 */
3035 /**
3036 * Helper function for LogTestDataForPaint().
3037 */
3046 };
3058 CoordType xDistance;
3063 }
3068 }
3073 CoordType yDistance;
3078 }
3084 }
3085 }
3088 }
3093 // Get a new Rect whose units are app units by scaling by the specified
3094 // factor.
3098 // We now need to constrain our results to the max and min values for coords.
3104 }
3108 }
3110 // Now typecast everything back. This is guaranteed to be safe.
3113 }
3117 /**
3118 * Converts an nsPoint in app units to a Moz2D Point in pixels (whether those
3119 * are device pixels or CSS px depends on what the caller chooses to pass as
3120 * aAppUnitsPerPixel).
3121 */
3126 }
3128 /**
3129 * Converts an nsRect in app units to a Moz2D Rect in pixels (whether those
3130 * are device pixels or CSS px depends on what the caller chooses to pass as
3131 * aAppUnitsPerPixel).
3132 */
3135 /**
3136 * Converts an nsRect in app units to a Moz2D Rect in pixels (whether those
3137 * are device pixels or CSS px depends on what the caller chooses to pass as
3138 * aAppUnitsPerPixel).
3139 *
3140 * The passed DrawTarget is used to additionally snap the returned Rect to
3141 * device pixels, if appropriate (as decided and carried out by Moz2D's
3142 * MaybeSnapToDevicePixels helper, which this function calls to do any
3143 * snapping).
3144 */
3148 /**
3149 * Converts, where possible, an nsRect in app units to a Moz2D Rect in pixels
3150 * (whether those are device pixels or CSS px depends on what the caller
3151 * chooses to pass as aAppUnitsPerPixel).
3152 *
3153 * If snapping results in a rectangle with zero width or height, the affected
3154 * coordinates are left unsnapped
3155 */
3168 /**
3169 * An RAII class which will, for the duration of its lifetime,
3170 * **if** the frame given is a container for font size inflation,
3171 * set the current inflation container on the pres context to null
3172 * (and then, in its destructor, restore the old value).
3173 */
3183 };
3195 NS_DECL_NSIRUNNABLE
3199 nsAutoString mValue;
3200 };
3206 NS_DECL_NSIRUNNABLE
3210 };
3212 // This class allows you to easily set any pointer variable and ensure it's
3213 // set to nullptr when leaving its scope.
3220 }
3225 };