| blob | 28eb76efe405d375b80b122fdf5039a2efb8248e |
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
117 nsRect mRect;
120 };
126 ScreenMargin mMargins;
129 };
133 // For GetDisplayPort
136 // Flags to customize the behavior of nsLayoutUtils::DrawString.
140 };
143 /**
144 * nsLayoutUtils is a namespace class used for various helper
145 * functions that are useful in multiple places in layout. The goal
146 * is not to define multiple copies of the same static helper.
147 */
193 /**
194 * Finds previously assigned ViewID for the given content element, if any.
195 * Returns whether a ViewID was previously assigned.
196 */
199 /**
200 * Finds previously assigned or generates a unique ViewID for the given
201 * content element.
202 */
205 /**
206 * Find content for given ID.
207 */
210 /**
211 * Find the scrollable frame for a given content element.
212 */
215 /**
216 * Find the scrollable frame for a given ID.
217 */
220 /**
221 * Find the ID for a given scrollable frame.
222 */
225 /**
226 * Get display port for the given element, relative to the specified entity,
227 * defaulting to the scrollport.
228 */
234 /**
235 * Check whether the given element has a displayport.
236 */
239 /**
240 * Check whether the given element has a displayport that has already
241 * been sent to the compositor via a layers or WR transaction.
242 */
245 /**
246 * Mark the displayport of a given element as having been sent to
247 * the compositor via a layers or WR transaction.
248 */
251 /**
252 * Check whether the given frame has a displayport. It returns false
253 * for scrolled frames and true for the corresponding scroll frame.
254 * Optionally pass the child, and it only returns true if the child is the
255 * scrolled frame for the displayport.
256 */
260 /**
261 * Check if the given element has a margins based displayport but is missing a
262 * displayport base rect that it needs to properly compute a displayport rect.
263 */
266 /**
267 * Go through the IPC Channel and update displayport margins for content
268 * elements based on UpdateFrame messages. The messages are left in the
269 * queue and will be fully processed when dequeued. The aim is to paint
270 * the most up-to-date displayport without waiting for these message to
271 * go through the message queue.
272 */
275 /**
276 * @return the display port for the given element which should be used for
277 * visibility testing purposes.
278 *
279 * If low-precision buffers are enabled, this is the critical display port;
280 * otherwise, it's the same display port returned by GetDisplayPort().
281 */
288 /**
289 * Invalidate for displayport change.
290 */
296 /**
297 * Set the display port margins for a content element to be used with a
298 * display port base (see SetDisplayPortBase()).
299 * See also nsIDOMWindowUtils.setDisplayPortMargins.
300 * @param aContent the content element for which to set the margins
301 * @param aPresShell the pres shell for the document containing the element
302 * @param aMargins the margins to set
303 * @param aAlignmentX, alignmentY the amount of pixels to which to align the
304 * displayport built by combining the base
305 * rect with the margins, in either direction
306 * @param aPriority a priority value to determine which margins take effect
307 * when multiple callers specify margins
308 * @param aRepaintMode whether to schedule a paint after setting the margins
309 * @return true if the new margins were applied.
310 */
315 /**
316 * Set the display port base rect for given element to be used with display
317 * port margins.
318 * SetDisplayPortBaseIfNotSet is like SetDisplayPortBase except it only sets
319 * the display port base to aBase if no display port base is currently set.
320 */
325 /**
326 * Get the critical display port for the given element.
327 */
331 /**
332 * Check whether the given element has a critical display port.
333 */
336 /**
337 * If low-precision painting is turned on, delegates to
338 * GetCriticalDisplayPort. Otherwise, delegates to GetDisplayPort.
339 */
344 /**
345 * Remove the displayport for the given element.
346 */
349 /**
350 * Notify the scroll frame with the given scroll id that its scroll offset
351 * is being sent to APZ as part of a paint-skip transaction.
352 *
353 * Normally, this notification happens during painting, after calls to
354 * ComputeScrollMetadata(). During paint-skipping that code is skipped,
355 * but it's still important for the scroll frame to be notified for
356 * correctness of relative scroll updates, so the code that sends the
357 * empty paint-skip transaction needs to call this.
358 */
361 /**
362 * Use heuristics to figure out the child list that
363 * aChildFrame is currently in.
364 */
368 /**
369 * Returns the ::before pseudo-element for aContent, if any.
370 */
373 /**
374 * Returns the frame corresponding to the ::before pseudo-element for
375 * aContent, if any.
376 */
379 /**
380 * Returns the ::after pseudo-element for aContent, if any.
381 */
384 /**
385 * Returns the frame corresponding to the ::after pseudo-element for aContent,
386 * if any.
387 */
390 /**
391 * Returns the ::marker pseudo-element for aContent, if any.
392 */
395 /**
396 * Returns the frame corresponding to the ::marker pseudo-element for
397 * aContent, if any.
398 */
401 /**
402 * Given a frame, search up the frame tree until we find an
403 * ancestor that (or the frame itself) is of type aFrameType, if any.
404 *
405 * @param aFrame the frame to start at
406 * @param aFrameType the frame type to look for
407 * @param aStopAt a frame to stop at after we checked it
408 * @return a frame of the given type or nullptr if no
409 * such ancestor exists
410 */
415 /**
416 * Given a frame, search up the frame tree until we find an
417 * ancestor that (or the frame itself) is a "Page" frame, if any.
418 *
419 * @param aFrame the frame to start at
420 * @return a frame of type mozilla::LayoutFrameType::Page or nullptr if no
421 * such ancestor exists
422 */
425 /**
426 * Given a frame which is the primary frame for an element,
427 * return the frame that has the non-pseudoelement ComputedStyle for
428 * the content.
429 * This is aPrimaryFrame itself except for tableWrapper frames.
430 *
431 * Given a non-null input, this will return null if and only if its
432 * argument is a table wrapper frame that is mid-destruction (and its
433 * table frame has been destroyed).
434 */
438 /**
439 * Given a content node,
440 * return the frame that has the non-pseudoelement ComputedStyle for
441 * the content. May return null.
442 * This is aContent->GetPrimaryFrame() except for tableWrapper frames.
443 */
446 /**
447 * The inverse of GetStyleFrame. Returns |aStyleFrame| unless it is an inner
448 * table frame, in which case the table wrapper frame is returned.
449 */
454 /**
455 * Similar to nsIFrame::IsPrimaryFrame except that this will return true
456 * for the inner table frame rather than for its wrapper frame.
457 */
460 #ifdef DEBUG
461 // TODO: remove, see bug 598468.
465 /**
466 * CompareTreePosition determines whether aContent1 comes before or
467 * after aContent2 in a preorder traversal of the content tree.
468 *
469 * @param aCommonAncestor either null, or a common ancestor of
470 * aContent1 and aContent2. Actually this is
471 * only a hint; if it's not an ancestor of
472 * aContent1 or aContent2, this function will
473 * still work, but it will be slower than
474 * normal.
475 * @return < 0 if aContent1 is before aContent2
476 * > 0 if aContent1 is after aContent2,
477 * 0 otherwise (meaning they're the same, or they're in
478 * different documents)
479 */
484 }
486 /*
487 * More generic version of |CompareTreePosition|. |aIf1Ancestor|
488 * gives the value to return when 1 is an ancestor of 2, and likewise
489 * for |aIf2Ancestor|. Passing (-1, 1) gives preorder traversal
490 * order, and (1, -1) gives postorder traversal order.
491 */
496 /**
497 * CompareTreePosition determines whether aFrame1 comes before or
498 * after aFrame2 in a preorder traversal of the frame tree, where out
499 * of flow frames are treated as children of their placeholders. This is
500 * basically the same ordering as DoCompareTreePosition(nsIContent*) except
501 * that it handles anonymous content properly and there are subtleties with
502 * continuations.
503 *
504 * @param aCommonAncestor either null, or a common ancestor of
505 * aContent1 and aContent2. Actually this is
506 * only a hint; if it's not an ancestor of
507 * aContent1 or aContent2, this function will
508 * still work, but it will be slower than
509 * normal.
510 * @return < 0 if aContent1 is before aContent2
511 * > 0 if aContent1 is after aContent2,
512 * 0 otherwise (meaning they're the same, or they're in
513 * different frame trees)
514 */
518 }
524 aCommonAncestor);
525 }
527 /*
528 * More generic version of |CompareTreePosition|. |aIf1Ancestor|
529 * gives the value to return when 1 is an ancestor of 2, and likewise
530 * for |aIf2Ancestor|. Passing (-1, 1) gives preorder traversal
531 * order, and (1, -1) gives postorder traversal order.
532 */
547 /**
548 * LastContinuationWithChild gets the last continuation in aFrame's chain
549 * that has a child, or the first continuation if the frame has no children.
550 */
553 /**
554 * GetLastSibling simply finds the last sibling of aFrame, or returns nullptr
555 * if aFrame is null.
556 */
559 /**
560 * FindSiblingViewFor locates the child of aParentView that aFrame's
561 * view should be inserted 'above' (i.e., before in sibling view
562 * order). This is the first child view of aParentView whose
563 * corresponding content is before aFrame's content (view siblings
564 * are in reverse content order).
565 */
568 /**
569 * Get the parent of aFrame. If aFrame is the root frame for a document,
570 * and the document has a parent document in the same view hierarchy, then
571 * we try to return the subdocumentframe in the parent document.
572 * @param aExtraOffset [in/out] if non-null, then as we cross documents
573 * an extra offset may be required and it will be added to aCrossDocOffset.
574 * Be careful dealing with this extra offset as it is in app units of the
575 * parent document, which may have a different app units per dev pixel ratio
576 * than the child document.
577 */
581 /**
582 * IsProperAncestorFrame checks whether aAncestorFrame is an ancestor
583 * of aFrame and not equal to aFrame.
584 * @param aCommonAncestor nullptr, or a common ancestor of aFrame and
585 * aAncestorFrame. If non-null, this can bound the search and speed up
586 * the function
587 */
592 /**
593 * Like IsProperAncestorFrame, but looks across document boundaries.
594 *
595 * Just like IsAncestorFrameCrossDoc, except that it returns false when
596 * aFrame == aAncestorFrame.
597 */
602 /**
603 * IsAncestorFrameCrossDoc checks whether aAncestorFrame is an ancestor
604 * of aFrame or equal to aFrame, looking across document boundaries.
605 * @param aCommonAncestor nullptr, or a common ancestor of aFrame and
606 * aAncestorFrame. If non-null, this can bound the search and speed up
607 * the function.
608 *
609 * Just like IsProperAncestorFrameCrossDoc, except that it returns true when
610 * aFrame == aAncestorFrame.
611 */
616 /**
617 * Sets the fixed-pos metadata properties on aLayer.
618 * aAnchorRect is the basic anchor rectangle. If aFixedPosFrame is not a
619 * viewport frame, then we pick a corner of aAnchorRect to as the anchor point
620 * for the fixed-pos layer (i.e. the point to remain stable during zooming),
621 * based on which of the fixed-pos frame's CSS absolute positioning offset
622 * properties (top, left, right, bottom) are auto. aAnchorRect is in the
623 * coordinate space of aLayer's container layer (i.e. relative to the
624 * reference frame of the display item which is building aLayer's container
625 * layer).
626 */
638 /**
639 * Get the scroll id for the root scrollframe of the presshell of the given
640 * prescontext. Returns NULL_SCROLL_ID if it couldn't be found.
641 */
644 /**
645 * Return true if aPresContext's viewport has a displayport.
646 */
649 /**
650 * Return true if aFrame is a fixed-pos frame and is a child of a viewport
651 * which has a displayport. These frames get special treatment from the
652 * compositor. aDisplayPort, if non-null, is set to the display port rectangle
653 * (relative to the viewport).
654 */
657 /**
658 * GetScrollableFrameFor returns the scrollable frame for a scrolled frame
659 */
663 /**
664 * GetNearestScrollableFrameForDirection locates the first ancestor of
665 * aFrame (or aFrame itself) that is scrollable with overflow:scroll or
666 * overflow:auto in the given direction and where either the scrollbar for
667 * that direction is visible or the frame can be scrolled by some
668 * positive amount in that direction.
669 * The search extends across document boundaries.
670 *
671 * @param aFrame the frame to start with
672 * @param aDirection Whether it's for horizontal or vertical scrolling.
673 * @return the nearest scrollable frame or nullptr if not found
674 */
680 /**
681 * If the SCROLLABLE_SAME_DOC flag is set, then we only walk the frame tree
682 * up to the root frame in the current document.
683 */
685 /**
686 * If the SCROLLABLE_INCLUDE_HIDDEN flag is set then we allow
687 * overflow:hidden scrollframes to be returned as scrollable frames.
688 */
690 /**
691 * If the SCROLLABLE_ONLY_ASYNC_SCROLLABLE flag is set, then we only
692 * want to match scrollable frames for which WantAsyncScroll() returns
693 * true.
694 */
696 /**
697 * If the SCROLLABLE_ALWAYS_MATCH_ROOT flag is set, then we will always
698 * return the root scrollable frame for the root document (in the current
699 * process) if we encounter it, whether or not it is async scrollable or
700 * overflow: hidden.
701 */
703 /**
704 * If the SCROLLABLE_FIXEDPOS_FINDS_ROOT flag is set, then for fixed-pos
705 * frames return the root scrollable frame for that document.
706 */
708 /**
709 * If the SCROLLABLE_STOP_AT_PAGE flag is set, then we stop searching
710 * for scrollable ancestors when seeing a nsPageFrame. This can be used
711 * to avoid finding the viewport scroll frame in Print Preview (which
712 * would be undesirable as a 'position:sticky' container for content).
713 */
715 };
716 /**
717 * GetNearestScrollableFrame locates the first ancestor of aFrame
718 * (or aFrame itself) that is scrollable with overflow:scroll or
719 * overflow:auto in some direction.
720 *
721 * @param aFrame the frame to start with
722 * @param aFlags if SCROLLABLE_SAME_DOC is set, do not search across
723 * document boundaries. If SCROLLABLE_INCLUDE_HIDDEN is set, include
724 * frames scrollable with overflow:hidden.
725 * @return the nearest scrollable frame or nullptr if not found
726 */
730 /**
731 * GetScrolledRect returns the range of allowable scroll offsets
732 * for aScrolledFrame, assuming the scrollable overflow area is
733 * aScrolledFrameOverflowArea and the scrollport size is aScrollPortSize.
734 */
740 /**
741 * HasPseudoStyle returns true if aContent (whose primary style
742 * context is aComputedStyle) has the aPseudoElement pseudo-style
743 * attached to it; returns false otherwise.
744 *
745 * @param aContent the content node we're looking at
746 * @param aComputedStyle aContent's ComputedStyle
747 * @param aPseudoElement the id of the pseudo style we care about
748 * @param aPresContext the presentation context
749 * @return whether aContent has aPseudoElement style attached to it
750 */
756 /**
757 * If this frame is a placeholder for a float, then return the float,
758 * otherwise return nullptr. aPlaceholder must be a placeholder frame.
759 */
762 // Combine aNewBreakType with aOrigBreakType, but limit the break types
763 // to StyleClear::Left, Right, Both.
767 /**
768 * Get the coordinates of a given DOM mouse event, relative to a given
769 * frame. Works only for DOM events generated by WidgetGUIEvents.
770 * @param aDOMEvent the event
771 * @param aFrame the frame to make coordinates relative to
772 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
773 * for some reason the coordinates for the mouse are not known (e.g.,
774 * the event is not a GUI event).
775 */
779 /**
780 * Get the coordinates of a given native mouse event, relative to a given
781 * frame.
782 * @param aEvent the event
783 * @param aFrame the frame to make coordinates relative to
784 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
785 * for some reason the coordinates for the mouse are not known (e.g.,
786 * the event is not a GUI event).
787 */
791 /**
792 * Get the coordinates of a given point relative to an event and a
793 * given frame.
794 * @param aEvent the event
795 * @param aPoint the point to get the coordinates relative to
796 * @param aFrame the frame to make coordinates relative to
797 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
798 * for some reason the coordinates for the mouse are not known (e.g.,
799 * the event is not a GUI event).
800 */
805 /**
806 * Get the coordinates of a given point relative to a widget and a
807 * given frame.
808 * @param aWidget the event src widget
809 * @param aPoint the point to get the coordinates relative to
810 * @param aFrame the frame to make coordinates relative to
811 * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if
812 * for some reason the coordinates for the mouse are not known (e.g.,
813 * the event is not a GUI event).
814 */
817 RelativeTo aFrame);
819 /**
820 * Get the popup frame of a given native mouse event.
821 * @param aPresContext only check popups within aPresContext or a descendant
822 * @param aEvent the event.
823 * @return Null, if there is no popup frame at the point, otherwise,
824 * returns top-most popup frame at the point.
825 */
829 /**
830 * Get container and offset if aEvent collapses Selection.
831 * @param aPresShell The PresShell handling aEvent.
832 * @param aEvent The event having coordinates where you want to
833 * collapse Selection.
834 * @param aContainer Returns the container node at the point.
835 * Set nullptr if you don't need this.
836 * @param aOffset Returns offset in the container node at the point.
837 * Set nullptr if you don't need this.
838 */
839 MOZ_CAN_RUN_SCRIPT
845 /**
846 * Translate from widget coordinates to the view's coordinates
847 * @param aPresContext the PresContext for the view
848 * @param aWidget the widget
849 * @param aPt the point relative to the widget
850 * @param aView view to which returned coordinates are relative
851 * @return the point in the view's coordinates
852 */
858 /**
859 * Translate from view coordinates to the widget's coordinates.
860 * @param aPresContext the PresContext for the view
861 * @param aView the view
862 * @param aPt the point relative to the view
863 * @param aViewportType whether the point is in visual or layout coordinates
864 * @param aWidget the widget to which returned coordinates are relative
865 * @return the point in the view's coordinates
866 */
875 /**
876 * When set, paint suppression is ignored, so we'll return non-root page
877 * elements even if paint suppression is stopping them from painting.
878 */
880 /**
881 * When set, clipping due to the root scroll frame (and any other viewport-
882 * related clipping) is ignored.
883 */
884 IgnoreRootScrollFrame,
885 /**
886 * When set, return only content in the same document as aFrame.
887 */
888 IgnoreCrossDoc,
889 /**
890 * When set, return only content that is actually visible.
891 */
892 OnlyVisible,
893 };
895 /**
896 * Given aFrame, the root frame of a stacking context, find its descendant
897 * frame under the point aPt that receives a mouse event at that location,
898 * or nullptr if there is no such frame.
899 * @param aPt the point, relative to the frame origin, in either visual
900 * or layout coordinates depending on aRelativeTo.mViewportType
901 * @param aFlags some combination of FrameForPointOption.
902 */
906 /**
907 * Given aFrame, the root frame of a stacking context, find all descendant
908 * frames under the area of a rectangle that receives a mouse event,
909 * or nullptr if there is no such frame.
910 * @param aRect the rect, relative to the frame origin, in either visual
911 * or layout coordinates depending on aRelativeTo.mViewportType
912 * @param aOutFrames an array to add all the frames found
913 * @param aFlags some combination of FrameForPointOption.
914 */
919 /**
920 * Transform aRect relative to aFrame up to the coordinate system of
921 * aAncestor. Computes the bounding-box of the true quadrilateral.
922 * Pass non-null aPreservesAxisAlignedRectangles and it will be set to true if
923 * we only need to use a 2d transform that PreservesAxisAlignedRectangles().
924 * The corner positions of aRect are treated as meaningful even if aRect is
925 * empty.
926 *
927 * |aMatrixCache| allows for optimizations in recomputing the same matrix over
928 * and over. The argument can be one of the following values:
929 *
930 * nullptr (the default) - No optimization; the transform matrix is computed
931 * on every call to this function.
932 *
933 * non-null pointer to an empty Maybe<Matrix4x4> - Upon return, the Maybe is
934 * filled with the transform matrix that was computed. This can then be passed
935 * in to subsequent calls with the same source and destination frames to avoid
936 * recomputing the matrix.
937 *
938 * non-null pointer to a non-empty Matrix4x4 - The provided matrix will be
939 * used as the transform matrix and applied to the rect.
940 */
950 aOutAncestor);
951 }
959 /**
960 * Gets the transform for aFrame relative to aAncestor. Pass null for
961 * aAncestor to go up to the root frame. Including nsIFrame::IN_CSS_UNITS
962 * flag in aFlags will return CSS pixels, by default it returns device
963 * pixels.
964 * More info can be found in nsIFrame::GetTransformMatrix.
965 *
966 * Some notes on the possible combinations of |aFrame.mViewportType| and
967 * |aAncestor.mViewportType|:
968 *
969 * | aFrame. | aAncestor. | Notes
970 * | mViewportType | mViewportType |
971 * ==========================================================================
972 * | Layout | Layout | Commonplace, when both source and target
973 * | | | are inside zoom boundary.
974 * | | |
975 * | | | Could also happen in non-e10s setups
976 * | | | when both source and target are outside
977 * | | | the zoom boundary and the code is
978 * | | | oblivious to the existence of a zoom
979 * | | | boundary.
980 * ==========================================================================
981 * | Layout | Visual | Commonplace, used when hit testing visual
982 * | | | coordinates (e.g. coming from user input
983 * | | | events). We expected to encounter a
984 * | | | zoomed content root during traversal and
985 * | | | apply a layout-to-visual transform.
986 * ==========================================================================
987 * | Visual | Layout | Should never happen, will assert.
988 * ==========================================================================
989 * | Visual | Visual | In e10s setups, should only happen if
990 * | | | aFrame and aAncestor are both the
991 * | | | RCD viewport frame.
992 * | | |
993 * | | | In non-e10s setups, could happen with
994 * | | | different frames if they are both
995 * | | | outside the zoom boundary.
996 * ==========================================================================
997 */
1002 /**
1003 * Gets the scale factors of the transform for aFrame relative to the root
1004 * frame if this transform is 2D, or the identity scale factors otherwise.
1005 */
1008 /**
1009 * Gets the scale factors of the transform for aFrame relative to the root
1010 * frame if this transform is 2D, or the identity scale factors otherwise.
1011 * If some frame on the path from aFrame to the display root frame may have an
1012 * animated scale, returns the identity scale factors.
1013 */
1016 /**
1017 * Find the nearest common ancestor frame for aFrame1 and aFrame2. The
1018 * ancestor frame could be cross-doc.
1019 */
1023 /**
1024 * Find the nearest common ancestor frame for aFrame1 and aFrame2, assuming
1025 * that they are within the same block.
1026 *
1027 * Returns null if they are not within the same block.
1028 */
1032 /**
1033 * Transforms a list of CSSPoints from aFromFrame to aToFrame, taking into
1034 * account all relevant transformations on the frames up to (but excluding)
1035 * their nearest common ancestor.
1036 * If we encounter a transform that we need to invert but which is
1037 * non-invertible, we return NONINVERTIBLE_TRANSFORM. If the frames have
1038 * no common ancestor, we return NO_COMMON_ANCESTOR.
1039 * If this returns TRANSFORM_SUCCEEDED, the points in aPoints are transformed
1040 * in-place, otherwise they are untouched.
1041 */
1043 TRANSFORM_SUCCEEDED,
1044 NO_COMMON_ANCESTOR,
1045 NONINVERTIBLE_TRANSFORM
1046 };
1052 /**
1053 * Same as above function, but transform points in app units and
1054 * handle 1 point per call.
1055 */
1059 /**
1060 * Transforms a rect from aFromFrame to aToFrame. In app units.
1061 * Returns the bounds of the actual rect if the transform requires rotation
1062 * or anything complex like that.
1063 */
1067 /**
1068 * Converts app units to pixels (with optional snapping) and appends as a
1069 * translation to aTransform.
1070 */
1074 /*
1075 * Whether the frame should snap to grid. This will end up being passed
1076 * as the aRounded parameter in PostTranslate above. SVG frames should
1077 * not have their translation rounded.
1078 */
1081 /**
1082 * Get the border-box of aElement's primary frame, transformed it to be
1083 * relative to aFrame.
1084 */
1088 /**
1089 * Returns true if aRect with border inflation of size aInflateSize contains
1090 * aPoint.
1091 */
1093 nscoord aInflateSize);
1095 /**
1096 * Clamp aRect relative to aFrame to the scroll frames boundary searching from
1097 * aFrame.
1098 */
1101 /**
1102 * Return true if a "layer transform" could be computed for aFrame,
1103 * and optionally return the computed transform. The returned
1104 * transform is what would be set on the layer currently if a layers
1105 * transaction were opened at the time this helper is called.
1106 */
1110 /**
1111 * Given a point in the global coordinate space, returns that point expressed
1112 * in the coordinate system of aFrame. This effectively inverts all
1113 * transforms between this point and the root frame.
1114 *
1115 * @param aFromType Specifies whether |aPoint| is in layout or visual
1116 * coordinates.
1117 * @param aFrame The frame that acts as the coordinate space container.
1118 * @param aPoint The point, in global layout or visual coordinates (as per
1119 * |aFromType|, to get in the frame-local space.
1120 * @return aPoint, expressed in aFrame's canonical coordinate space.
1121 */
1123 RelativeTo aFrame,
1127 }
1129 /**
1130 * Transform aPoint relative to aAncestor down to the coordinate system of
1131 * aFrame.
1132 */
1135 RelativeTo aAncestor);
1137 /**
1138 * Helper function that, given a rectangle and a matrix, returns the smallest
1139 * rectangle containing the image of the source rectangle.
1140 *
1141 * @param aBounds The rectangle to transform.
1142 * @param aMatrix The matrix to transform it with.
1143 * @param aFactor The number of app units per graphics unit.
1144 * @return The smallest rect that contains the image of aBounds.
1145 */
1152 /**
1153 * Helper function that, given a point and a matrix, returns the image
1154 * of that point under the matrix transform.
1155 *
1156 * @param aPoint The point to transform.
1157 * @param aMatrix The matrix to transform it with.
1158 * @param aFactor The number of app units per graphics unit.
1159 * @return The image of the point under the transform.
1160 */
1164 /**
1165 * Given a graphics rectangle in graphics space, return a rectangle in
1166 * app space that contains the graphics rectangle, rounding out as necessary.
1167 *
1168 * @param aRect The graphics rect to round outward.
1169 * @param aFactor The number of app units per graphics unit.
1170 * @return The smallest rectangle in app space that contains aRect.
1171 */
1175 /**
1176 * Returns a subrectangle of aContainedRect that is entirely inside the
1177 * rounded rect. Complex cases are handled conservatively by returning a
1178 * smaller rect than necessary.
1179 */
1187 /**
1188 * Return whether any part of aTestRect is inside of the rounded
1189 * rectangle formed by aBounds and aRadii (which are indexed by the
1190 * enum HalfCorner constants in gfx/2d/Types.h). This is precise.
1191 */
1212 };
1214 /**
1215 * Given aFrame, the root frame of a stacking context, paint it and its
1216 * descendants to aRenderingContext.
1217 * @param aRenderingContext a rendering context translated so that (0,0)
1218 * is the origin of aFrame; for best results, (0,0) should transform
1219 * to pixel-aligned coordinates. This can be null, in which case
1220 * aFrame must be a "display root" (root frame for a root document,
1221 * or the root of a popup) with an associated widget and we draw using
1222 * the layer manager for the frame's widget.
1223 * @param aDirtyRegion the region that must be painted, in the coordinates
1224 * of aFrame.
1225 * @param aBackstop paint the dirty area with this color before drawing
1226 * the actual content; pass NS_RGBA(0,0,0,0) to draw no background.
1227 * @param aBuilderMode Passed through to the display-list builder.
1228 * @param aFlags if PAINT_IN_TRANSFORM is set, then we assume
1229 * this is inside a transform or SVG foreignObject. If
1230 * PAINT_SYNC_DECODE_IMAGES is set, we force synchronous decode on all
1231 * images. If PAINT_WIDGET_LAYERS is set, aFrame must be a display root,
1232 * and we will use the frame's widget's layer manager to paint
1233 * even if aRenderingContext is non-null. This is useful if you want
1234 * to force rendering to use the widget's layer manager for testing
1235 * or speed. PAINT_WIDGET_LAYERS must be set if aRenderingContext is null.
1236 * If PAINT_DOCUMENT_RELATIVE is used, the visible region is interpreted
1237 * as being relative to the document (normally it's relative to the CSS
1238 * viewport) and the document is painted as if no scrolling has occured.
1239 * Only considered if PresShell::IgnoringViewportScrolling is true.
1240 * PAINT_TO_WINDOW sets painting to window to true on the display list
1241 * builder even if we can't tell that we are painting to the window.
1242 * If PAINT_EXISTING_TRANSACTION is set, then BeginTransaction() has already
1243 * been called on aFrame's widget's layer manager and should not be
1244 * called again.
1245 * If PAINT_COMPRESSED is set, the FrameLayerBuilder should be set to
1246 * compressed mode to avoid short cut optimizations.
1247 *
1248 * So there are three possible behaviours:
1249 * 1) PAINT_WIDGET_LAYERS is set and aRenderingContext is null; we paint
1250 * by calling BeginTransaction on the widget's layer manager.
1251 * 2) PAINT_WIDGET_LAYERS is set and aRenderingContext is non-null; we
1252 * paint by calling BeginTransactionWithTarget on the widget's layer
1253 * manager.
1254 * 3) PAINT_WIDGET_LAYERS is not set and aRenderingContext is non-null;
1255 * we paint by construct a BasicLayerManager and calling
1256 * BeginTransactionWithTarget on it. This is desirable if we're doing
1257 * something like drawWindow in a mode where what gets rendered doesn't
1258 * necessarily correspond to what's visible in the window; we don't
1259 * want to mess up the widget's layer tree.
1260 */
1263 nsDisplayListBuilderMode aBuilderMode,
1266 /**
1267 * Uses a binary search for find where the cursor falls in the line of text
1268 * It also keeps track of the part of the string that has already been
1269 * measured so it doesn't have to keep measuring the same text over and over.
1270 *
1271 * @param "aBaseWidth" contains the width in twips of the portion
1272 * of the text that has already been measured, and aBaseInx contains
1273 * the index of the text that has already been measured.
1274 *
1275 * @param aTextWidth returns (in twips) the length of the text that falls
1276 * before the cursor aIndex contains the index of the text where the cursor
1277 * falls.
1278 */
1291 };
1292 /**
1293 * Collect all CSS boxes associated with aFrame and its
1294 * continuations, "drilling down" through table wrapper frames and
1295 * some anonymous blocks since they're not real CSS boxes.
1296 * If aFrame is null, no boxes are returned.
1297 * SVG frames return a single box, themselves.
1298 */
1301 /**
1302 * Like GetAllInFlowBoxes, but doesn't include continuations.
1303 */
1306 /**
1307 * Find the first frame descendant of aFrame (including aFrame) which is
1308 * not an anonymous frame that getBoxQuads/getClientRects should ignore.
1309 */
1315 };
1318 nsRect mResultRect;
1319 nsRect mFirstRect;
1325 };
1332 };
1338 // Two bits for specifying which box type to use.
1339 // With neither bit set (default), use the border box.
1344 };
1345 /**
1346 * Collect all CSS boxes (content, padding, border, or margin) associated
1347 * with aFrame and its continuations, "drilling down" through table wrapper
1348 * frames and some anonymous blocks since they're not real CSS boxes.
1349 * The boxes are positioned relative to aRelativeTo (taking scrolling
1350 * into account) and passed to the callback in frame-tree order.
1351 * If aFrame is null, no boxes are returned.
1352 * For SVG frames, returns one rectangle, the bounding box.
1353 * If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting
1354 * the boxes into aRelativeTo coordinates, transforms (including CSS
1355 * and SVG transforms) are taken into account.
1356 * If aFlags includes one of RECTS_USE_CONTENT_BOX, RECTS_USE_PADDING_BOX,
1357 * or RECTS_USE_MARGIN_BOX, the corresponding type of box is used.
1358 * Otherwise (by default), the border box is used.
1359 */
1367 /**
1368 * Computes the union of all rects returned by GetAllInFlowRects. If
1369 * the union is empty, returns the first rect.
1370 * If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting
1371 * the boxes into aRelativeTo coordinates, transforms (including CSS
1372 * and SVG transforms) are taken into account.
1373 * If aFlags includes one of RECTS_USE_CONTENT_BOX, RECTS_USE_PADDING_BOX,
1374 * or RECTS_USE_MARGIN_BOX, the corresponding type of box is used.
1375 * Otherwise (by default), the border box is used.
1376 */
1382 /**
1383 * Takes a text-shadow array from the style properties of a given nsIFrame and
1384 * computes the union of those shadows along with the given initial rect.
1385 * If there are no shadows, the initial rect is returned.
1386 */
1390 /**
1391 * Computes the destination rect that a given replaced element should render
1392 * into, based on its CSS 'object-fit' and 'object-position' properties.
1393 *
1394 * @param aConstraintRect The constraint rect that we have at our disposal,
1395 * which would e.g. be exactly filled by the image
1396 * if we had "object-fit: fill".
1397 * @param aIntrinsicSize The replaced content's intrinsic size, as reported
1398 * by nsIFrame::GetIntrinsicSize().
1399 * @param aIntrinsicRatio The replaced content's intrinsic ratio, as reported
1400 * by nsIFrame::GetIntrinsicRatio().
1401 * @param aStylePos The nsStylePosition struct that contains the 'object-fit'
1402 * and 'object-position' values that we should rely on.
1403 * (This should usually be the nsStylePosition for the
1404 * replaced element in question, but not always. For
1405 * example, a <video>'s poster-image has a dedicated
1406 * anonymous element & child-frame, but we should still use
1407 * the <video>'s 'object-fit' and 'object-position' values.)
1408 * @param aAnchorPoint [out] A point that should be pixel-aligned by functions
1409 * like nsLayoutUtils::DrawImage. See documentation
1410 * in nsCSSRendering.h for ComputeObjectAnchorPoint.
1411 * @return The nsRect into which we should render the replaced content (using
1412 * the same coordinate space as the passed-in aConstraintRect).
1413 */
1420 /**
1421 * Get the font metrics corresponding to the frame's style data.
1422 * @param aFrame the frame
1423 * @param aSizeInflation number to multiply font size by
1424 */
1431 }
1433 /**
1434 * Get the font metrics corresponding to the given style data.
1435 * @param aComputedStyle the style data
1436 * @param aSizeInflation number to multiply font size by
1437 */
1443 /**
1444 * Get the font metrics of emphasis marks corresponding to the given
1445 * style data. The result is same as GetFontMetricsForComputedStyle
1446 * except that the font size is scaled down to 50%.
1447 * @param aComputedStyle the style data
1448 * @param aInflation number to multiple font size by
1449 */
1455 }
1457 /**
1458 * Find the immediate child of aParent whose frame subtree contains
1459 * aDescendantFrame. Returns null if aDescendantFrame is not a descendant
1460 * of aParent.
1461 */
1465 /**
1466 * Find the nearest ancestor that's a block
1467 */
1470 /**
1471 * Find the nearest ancestor that's not for generated content. Will return
1472 * aFrame if aFrame is not for generated content.
1473 */
1476 /*
1477 * Whether the frame is an nsBlockFrame which is not a wrapper block.
1478 */
1481 /**
1482 * If aFrame is an out of flow frame, return its placeholder, otherwise
1483 * return its parent.
1484 */
1487 /**
1488 * If aFrame is an out of flow frame, return its placeholder, otherwise
1489 * return its (possibly cross-doc) parent.
1490 */
1493 /**
1494 * Returns the frame that would act as the parent of aFrame when
1495 * descending through the frame tree in display list building.
1496 * Usually the same as GetParentOrPlaceholderForCrossDoc, except
1497 * that pushed floats are treated as children of their containing
1498 * block.
1499 */
1502 /**
1503 * Get a frame's previous continuation, or, if it doesn't have one, its
1504 * previous block-in-inline-split sibling.
1505 */
1508 /**
1509 * Get a frame's next continuation, or, if it doesn't have one, its
1510 * block-in-inline-split sibling.
1511 */
1514 /**
1515 * Get the first frame in the continuation-plus-ib-split-sibling chain
1516 * containing aFrame.
1517 */
1520 /**
1521 * Get the last frame in the continuation-plus-ib-split-sibling chain
1522 * containing aFrame.
1523 */
1526 /**
1527 * Is FirstContinuationOrIBSplitSibling(aFrame) going to return
1528 * aFrame?
1529 */
1532 /**
1533 * Check whether aFrame is a part of the scrollbar or scrollcorner of
1534 * the root content.
1535 * @param aFrame the checking frame.
1536 * @return true if the frame is a part of the scrollbar or scrollcorner of
1537 * the root content.
1538 */
1541 /**
1542 * Get the contribution of aFrame to its containing block's intrinsic
1543 * size for the given physical axis. This considers the child's intrinsic
1544 * width, its 'width', 'min-width', and 'max-width' properties (or 'height'
1545 * variations if that's what matches aAxis) and its padding, border and margin
1546 * in the corresponding dimension.
1547 * @param aPercentageBasis an optional percentage basis (in aFrame's WM).
1548 * If the basis is indefinite in a given axis, pass a size with
1549 * NS_UNCONSTRAINEDSIZE in that component.
1550 * If you pass Nothing() a percentage basis will be calculated from aFrame's
1551 * ancestors' computed size in the relevant axis, if needed.
1552 * @param aMarginBoxMinSizeClamp make the result fit within this margin-box
1553 * size by reducing the *content size* (flooring at zero). This is used for:
1554 * https://drafts.csswg.org/css-grid/#min-size-auto
1555 */
1563 };
1569 /**
1570 * Calls IntrinsicForAxis with aFrame's parent's inline physical axis.
1571 */
1574 IntrinsicISizeType aType,
1577 /**
1578 * Get the definite size contribution of aFrame for the given physical axis.
1579 * This considers the child's 'min-width' property (or 'min-height' if the
1580 * given axis is vertical), and its padding, border, and margin in the
1581 * corresponding dimension. If the 'min-' property is 'auto' (and 'overflow'
1582 * is 'visible') and the corresponding 'width'/'height' is definite it returns
1583 * the "specified size" for:
1584 * https://drafts.csswg.org/css-grid/#min-size-auto
1585 * Note that the "transferred size" is not handled here; use IntrinsicForAxis.
1586 * Note that any percentage in 'width'/'height' makes it count as indefinite.
1587 * If the 'min-' property is 'auto' and 'overflow' is not 'visible', then it
1588 * calculates the result as if the 'min-' computed value is zero.
1589 * Otherwise, return NS_UNCONSTRAINEDSIZE.
1590 *
1591 * @param aPercentageBasis the percentage basis (in aFrame's WM).
1592 * Pass NS_UNCONSTRAINEDSIZE if the basis is indefinite in either/both axes.
1593 * @note this behavior is specific to Grid/Flexbox (currently) so aFrame
1594 * should be a grid/flex item.
1595 */
1598 IntrinsicISizeType aType,
1602 /*
1603 * Convert LengthPercentage to nscoord when percentages depend on the
1604 * containing block size.
1605 * @param aPercentBasis The width or height of the containing block
1606 * (whichever the client wants to use for resolving percentages).
1607 */
1612 "have unconstrained width or height; this should only result from very "
1615 }
1620 }
1622 }
1628 nscoord aContentEdgeToBoxSizingBoxEdge,
1634 // Clamp calc(), and the subtraction for box-sizing.
1636 }
1638 /**
1639 * The "extremum length" values (see ExtremumLength) were originally aimed at
1640 * inline-size (or width, as it was before logicalization). For now, we return
1641 * true for those here, so that we don't call ComputeBSizeValue with value
1642 * types that it doesn't understand. (See bug 1113216.)
1643 *
1644 * FIXME (bug 567039, bug 527285)
1645 * This isn't correct for the 'fill' value or for the 'min-*' or 'max-*'
1646 * properties, which need to be handled differently by the callers of
1647 * IsAutoBSize().
1648 */
1653 }
1656 // clamp negative calc() to 0
1658 }
1662 }
1668 /*
1669 * Calculate the used values for 'width' and 'height' when width
1670 * and height are 'auto'. The tentWidth and tentHeight arguments should be
1671 * the result of applying the rules for computing intrinsic sizes and ratios.
1672 * as specified by CSS 2.1 sections 10.3.2 and 10.6.2
1673 */
1678 // Implement nsIFrame::GetPrefISize in terms of nsIFrame::AddInlinePrefISize
1682 // Implement nsIFrame::GetMinISize in terms of nsIFrame::AddInlineMinISize
1686 // Get a suitable foreground color for painting aColor for aFrame.
1689 // Get a suitable foreground color for painting aField for aFrame.
1690 // Type of aFrame is made a template parameter because nsIFrame is not
1691 // a complete type in the header. Type-safety is not harmed given that
1692 // DarkenColorIfNeeded requires an nsIFrame pointer.
1697 }
1699 // Get a baseline y position in app units that is snapped to device pixels.
1702 // Ditto for an x position (for vertical text). Note that for vertical-rl
1703 // writing mode, the ascent value should be negated by the caller.
1710 }
1716 }
1726 }
1752 /**
1753 * Supports only LTR or RTL. Bidi (mixed direction) is not supported.
1754 */
1760 /**
1761 * Helper function for drawing text-shadow. The callback's job
1762 * is to draw whatever needs to be blurred onto the given context.
1763 */
1770 TextShadowCallback aCallback,
1773 /**
1774 * Gets the baseline to vertically center text from a font within a
1775 * line of specified height.
1776 * aIsInverted: true if the text is inverted relative to the block
1777 * direction, so that the block-dir "ascent" corresponds to font
1778 * descent. (Applies to sideways text in vertical-lr mode.)
1779 *
1780 * Returns the baseline position relative to the top of the line.
1781 */
1785 /**
1786 * Derive a baseline of |aFrame| (measured from its top border edge)
1787 * from its first in-flow line box (not descending into anything with
1788 * 'overflow' not 'visible', potentially including aFrame itself).
1789 *
1790 * Returns true if a baseline was found (and fills in aResult).
1791 * Otherwise returns false.
1792 */
1796 /**
1797 * Just like GetFirstLineBaseline, except also returns the top and
1798 * bottom of the line with the baseline.
1799 *
1800 * Returns true if a line was found (and fills in aResult).
1801 * Otherwise returns false.
1802 */
1807 LinePosition result;
1812 }
1813 };
1818 /**
1819 * Derive a baseline of |aFrame| (measured from its top border edge)
1820 * from its last in-flow line box (not descending into anything with
1821 * 'overflow' not 'visible', potentially including aFrame itself).
1822 *
1823 * Returns true if a baseline was found (and fills in aResult).
1824 * Otherwise returns false.
1825 */
1829 /**
1830 * Returns a block-dir coordinate relative to this frame's origin that
1831 * represents the logical block-end of the frame or its visible content,
1832 * whichever is further from the origin.
1833 * Relative positioning is ignored and margins and glyph bounds are not
1834 * considered.
1835 * This value will be >= mRect.BSize() and <= overflowRect.BEnd() unless
1836 * relative positioning is applied.
1837 */
1841 /**
1842 * Gets the closest frame (the frame passed in or one of its parents) that
1843 * qualifies as a "layer"; used in DOM0 methods that depends upon that
1844 * definition. This is the nearest frame that is either positioned or scrolled
1845 * (the child of a scroll frame).
1846 */
1849 /**
1850 * Gets the graphics sampling filter for the frame
1851 */
1867 }
1868 }
1870 /**
1871 * Convert an nsRect to a gfxRect.
1872 */
1880 }
1882 /* N.B. The only difference between variants of the Draw*Image
1883 * functions below is the type of the aImage argument.
1884 */
1886 /**
1887 * Draw a background image. The image's dimensions are as specified in aDest;
1888 * the image itself is not consulted to determine a size.
1889 * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
1890 *
1891 * @param aContext
1892 * The context to draw to, already set up with an appropriate scale and
1893 * transform for drawing in app units.
1894 * @param aForFrame
1895 * The nsIFrame that we're drawing this image for.
1896 * @param aImage
1897 * The image.
1898 * @param aDest
1899 * The position and scaled area where one copy of the image should be drawn.
1900 * This area represents the image itself in its correct position as defined
1901 * with the background-position css property.
1902 * @param aFill
1903 * The area to be filled with copies of the image.
1904 * @param aRepeatSize
1905 * The distance between the positions of two subsequent repeats of the image.
1906 * Sizes larger than aDest.Size() create gaps between the images.
1907 * @param aAnchor
1908 * A point in aFill which we will ensure is pixel-aligned in the output.
1909 * @param aDirty
1910 * Pixels outside this area may be skipped.
1911 * @param aImageFlags
1912 * Image flags of the imgIContainer::FLAG_* variety.
1913 * @param aExtendMode
1914 * How to extend the image over the dest rect.
1915 */
1923 /**
1924 * Draw an image.
1925 * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
1926 * @param aRenderingContext Where to draw the image, set up with an
1927 * appropriate scale and transform for drawing in
1928 * app units.
1929 * @param aComputedStyle The ComputedStyle of the nsIFrame (or
1930 * pseudo-element) for which this image is being
1931 * drawn.
1932 * @param aImage The image.
1933 * @param aDest Where one copy of the image should mapped to.
1934 * @param aFill The area to be filled with copies of the
1935 * image.
1936 * @param aAnchor A point in aFill which we will ensure is
1937 * pixel-aligned in the output.
1938 * @param aDirty Pixels outside this area may be skipped.
1939 * @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
1940 */
1950 /**
1951 * Draw a whole image without scaling or tiling.
1952 *
1953 * @param aRenderingContext Where to draw the image, set up with an
1954 * appropriate scale and transform for drawing in
1955 * app units.
1956 * @param aImage The image.
1957 * @param aDest The top-left where the image should be drawn.
1958 * @param aDirty If non-null, then pixels outside this area may
1959 * be skipped.
1960 * @param aSVGContext Optionally provides an SVGImageContext.
1961 * Callers should pass an SVGImageContext with at
1962 * least the viewport size set if aImage may be of
1963 * type imgIContainer::TYPE_VECTOR, or pass
1964 * Nothing() if it is of type
1965 * imgIContainer::TYPE_RASTER (to save cycles
1966 * constructing an SVGImageContext, since this
1967 * argument will be ignored for raster images).
1968 * @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
1969 * @param aSourceArea If non-null, this area is extracted from
1970 * the image and drawn at aDest. It's
1971 * in appunits. For best results it should
1972 * be aligned with image pixels.
1973 */
1980 /**
1981 * Draw a whole image without tiling.
1982 *
1983 * @param aRenderingContext Where to draw the image, set up with an
1984 * appropriate scale and transform for drawing in
1985 * app units.
1986 * @param aImage The image.
1987 * @param aDest The area that the image should fill.
1988 * @param aDirty Pixels outside this area may be skipped.
1989 * @param aSVGContext Optionally provides an SVGImageContext.
1990 * Callers should pass an SVGImageContext with at
1991 * least the viewport size set if aImage may be of
1992 * type imgIContainer::TYPE_VECTOR, or pass
1993 * Nothing() if it is of type
1994 * imgIContainer::TYPE_RASTER (to save cycles
1995 * constructing an SVGImageContext, since this
1996 * argument will be ignored for raster images).
1997 * @param aImageFlags Image flags of the imgIContainer::FLAG_*
1998 * variety.
1999 * @param aAnchor If non-null, a point which we will ensure
2000 * is pixel-aligned in the output.
2001 * @param aSourceArea If non-null, this area is extracted from
2002 * the image and drawn in aDest. It's
2003 * in appunits. For best results it should
2004 * be aligned with image pixels.
2005 */
2013 /**
2014 * Given an imgIContainer, this method attempts to obtain an intrinsic
2015 * px-valued height & width for it. If the imgIContainer has a non-pixel
2016 * value for either height or width, this method tries to generate a pixel
2017 * value for that dimension using the intrinsic ratio (if available). The
2018 * intrinsic ratio will be assigned to aIntrinsicRatio; if there's no
2019 * intrinsic ratio then (0, 0) will be assigned.
2020 *
2021 * This method will always set aGotWidth and aGotHeight to indicate whether
2022 * we were able to successfully obtain (or compute) a value for each
2023 * dimension.
2024 *
2025 * NOTE: This method is similar to ComputeSizeWithIntrinsicDimensions. The
2026 * difference is that this one is simpler and is suited to places where we
2027 * have less information about the frame tree.
2028 */
2034 /**
2035 * Given an imgIContainer, this method attempts to obtain an intrinsic
2036 * px-valued height & width for it. If the imgIContainer has a non-pixel
2037 * value for either height or width, this method tries to generate a pixel
2038 * value for that dimension using the intrinsic ratio (if available). If,
2039 * after trying all these methods, no value is available for one or both
2040 * dimensions, the corresponding dimension of aFallbackSize is used instead.
2041 */
2045 /**
2046 * Given the image container, frame, and dest rect, determine the best fitting
2047 * size to decode the image at, and calculate any necessary SVG parameters.
2048 */
2054 /**
2055 * Given a source area of an image (in appunits) and a destination area
2056 * that we want to map that source area too, computes the area that
2057 * would be covered by the whole image. This is useful for passing to
2058 * the aDest parameter of DrawImage, when we want to draw a subimage
2059 * of an overall image.
2060 */
2065 /**
2066 * Given an image container and an orientation, returns an image container
2067 * that contains the same image, reoriented appropriately. May return the
2068 * original image container if no changes are needed.
2069 *
2070 * @param aContainer The image container to apply the orientation to.
2071 * @param aOrientation The desired orientation.
2072 */
2077 /**
2078 * Determine if any corner radius is of nonzero size
2079 * @param aCorners the |BorderRadius| object to check
2080 * @return true unless all the coordinates are 0%, 0 or null.
2081 *
2082 * A corner radius with one dimension zero and one nonzero is
2083 * treated as a nonzero-radius corner, even though it will end up
2084 * being rendered like a zero-radius corner. This is because such
2085 * corners are not expected to appear outside of test cases, and it's
2086 * simpler to implement the test this way.
2087 */
2090 /**
2091 * Determine if there is any corner radius on corners adjacent to the
2092 * given side.
2093 */
2097 /**
2098 * Determine if a widget is likely to require transparency or translucency.
2099 * @param aBackgroundFrame The frame that the background is set on. For
2100 * <window>s, this will be the canvas frame.
2101 * @param aCSSRootFrame The frame that holds CSS properties affecting
2102 * the widget's transparency. For menupopups,
2103 * aBackgroundFrame and aCSSRootFrame will be the
2104 * same.
2105 * @return a value suitable for passing to SetWindowTranslucency.
2106 */
2110 /**
2111 * A frame is a popup if it has its own floating window. Menus, panels
2112 * and combobox dropdowns are popups.
2113 */
2116 /**
2117 * Find the nearest "display root". This is the nearest enclosing
2118 * popup frame or the root prescontext's root frame.
2119 */
2122 /**
2123 * Get the reference frame that would be used when constructing a
2124 * display item for this frame. Rather than using their own frame
2125 * as a reference frame.)
2126 *
2127 * This duplicates some of the logic of GetDisplayRootFrame above and
2128 * of nsDisplayListBuilder::FindReferenceFrameFor.
2129 *
2130 * If you have an nsDisplayListBuilder, you should get the reference
2131 * frame from it instead of calling this.
2132 */
2135 /**
2136 * Get textrun construction flags determined by a given style; in particular
2137 * some combination of:
2138 * -- TEXT_DISABLE_OPTIONAL_LIGATURES if letter-spacing is in use
2139 * -- TEXT_OPTIMIZE_SPEED if the text-rendering CSS property and font size
2140 * and prefs indicate we should be optimizing for speed over quality
2141 */
2145 nscoord aLetterSpacing);
2147 /**
2148 * Get orientation flags for textrun construction.
2149 */
2153 /**
2154 * Takes two rectangles whose origins must be the same, and computes
2155 * the difference between their union and their intersection as two
2156 * rectangles. (This difference is a superset of the difference
2157 * between the two rectangles.)
2158 */
2162 /**
2163 * Get a device context that can be used to get up-to-date device
2164 * dimensions for the given window. For some reason, this is more
2165 * complicated than it ought to be in multi-monitor situations.
2166 */
2170 /**
2171 * Some frames with 'position: fixed' (nsStyleDisplay::mPosition ==
2172 * StylePositionProperty::Fixed) are not really fixed positioned, since
2173 * they're inside an element with -moz-transform. This function says
2174 * whether such an element is a real fixed-pos element.
2175 */
2178 /**
2179 * This function says whether `aFrame` would really be a fixed positioned
2180 * frame if the frame was created with StylePositionProperty::Fixed.
2181 *
2182 * It is effectively the same as IsReallyFixedPos, but without asserting the
2183 * position value. Use it only when you know what you're doing, like when
2184 * tearing down the frame tree (where styles may have changed due to
2185 * ::first-line reparenting and rule changes at the same time).
2186 */
2189 /**
2190 * Returns true if |aFrame| is inside position:fixed subtree.
2191 */
2194 /**
2195 * Obtain a SourceSurface from the given DOM element, if possible.
2196 * This obtains the most natural surface from the element; that
2197 * is, the one that can be obtained with the fewest conversions.
2198 *
2199 * The flags below can modify the behaviour of this function. The
2200 * result is returned as a SurfaceFromElementResult struct, also
2201 * defined below.
2202 *
2203 * Currently, this will do:
2204 * - HTML Canvas elements: will return the underlying canvas surface
2205 * - HTML Video elements: will return the current video frame
2206 * - Image elements: will return the image
2207 *
2208 * The above results are modified by the below flags (copying,
2209 * forcing image surface, etc.).
2210 */
2213 /* When creating a new surface, create an image surface */
2215 /* Whether to extract the first frame (as opposed to the
2216 current frame) in the case that the element is an image. */
2218 /* Whether we should skip colorspace/gamma conversion */
2220 /* Caller handles SFER::mAlphaType = NonPremult */
2222 /* Whether we should skip getting a surface for vector images and
2223 return a DirectDrawInfo containing an imgIContainer instead. */
2225 /* If image type is vector, the return surface size will same as
2226 element size, not image's intrinsic size. */
2228 };
2231 /* imgIContainer to directly draw to a context */
2233 /* which frame to draw */
2235 /* imgIContainer flags to use when drawing */
2237 };
2243 /* If SFEResult contains a valid surface, it either mLayersImage or
2244 * mSourceSurface will be non-null, and GetSourceSurface() will not be null.
2245 *
2246 * For valid surfaces, mSourceSurface may be null if mLayersImage is
2247 * non-null, but GetSourceSurface() will create mSourceSurface from
2248 * mLayersImage when called.
2249 */
2251 /* Video elements (at least) often are already decoded as layers::Images. */
2255 /* GetSourceSurface() fills this and returns its non-null value if this
2256 * SFEResult was successful. */
2260 /* Contains info for drawing when there is no mSourceSurface. */
2261 DirectDrawInfo mDrawInfo;
2263 /* The size of the surface */
2265 /* The size the surface is intended to be rendered at */
2267 /* The principal associated with the element whose surface was returned.
2268 If there is a surface, this will never be null. */
2270 /* The image request, if the element is an nsIImageLoadingContent */
2272 /* True if cross-origins redirects have been done in order to load this
2273 * resource */
2275 /* Whether the element was "write only", that is, the bits should not be
2276 * exposed to content */
2278 /* Whether the element was still loading. Some consumers need to handle
2279 this case specially. */
2281 /* Whether the element has a valid size. */
2283 /* Whether the element used CORS when loading. */
2286 gfxAlphaType mAlphaType;
2288 // Methods:
2292 // Gets mSourceSurface, or makes a SourceSurface from mLayersImage.
2294 };
2296 // This function can be called on any thread.
2305 }
2314 }
2316 // There are a bunch of callers of SurfaceFromElement. Just mark it as
2317 MOZ_CAN_RUN_SCRIPT_BOUNDARY
2321 // Need an HTMLImageElement overload, because otherwise the
2322 // nsIImageLoadingContent and mozilla::dom::Element overloads are ambiguous
2323 // for HTMLImageElement.
2334 /**
2335 * When the document is editable by contenteditable attribute of its root
2336 * content or body content.
2337 *
2338 * Be aware, this returns nullptr if it's in designMode.
2339 *
2340 * For example:
2341 *
2342 * <html contenteditable="true"><body></body></html>
2343 * returns the <html>.
2344 *
2345 * <html><body contenteditable="true"></body></html>
2346 * <body contenteditable="true"></body>
2347 * With these cases, this returns the <body>.
2348 * NOTE: The latter case isn't created normally, however, it can be
2349 * created by script with XHTML.
2350 *
2351 * <body><p contenteditable="true"></p></body>
2352 * returns nullptr because <body> isn't editable.
2353 */
2361 nscolor aBackstop);
2363 /**
2364 * Returns true if the passed in prescontext needs the dark grey background
2365 * that goes behind the page of a print preview presentation.
2366 */
2369 /**
2370 * Types used by the helpers for InspectorUtils.getUsedFontFaces.
2371 * The API returns an array (UsedFontFaceList) that owns the
2372 * InspectorFontFace instances, but during range traversal we also
2373 * want to maintain a mapping from gfxFontEntry to InspectorFontFace
2374 * records, so use a temporary hashtable for that.
2375 */
2377 UsedFontFaceList;
2380 UsedFontFaceTable;
2382 /**
2383 * Adds all font faces used in the frame tree starting from aFrame
2384 * to the list aFontFaceList.
2385 * aMaxRanges: maximum number of text ranges to record for each face.
2386 */
2393 /**
2394 * Adds all font faces used within the specified range of text in aFrame,
2395 * and optionally its continuations, to the list in aFontFaceList.
2396 * Pass 0 and INT32_MAX for aStartOffset and aEndOffset to specify the
2397 * entire text is to be considered.
2398 * aMaxRanges: maximum number of text ranges to record for each face.
2399 */
2407 /**
2408 * Walks the frame tree starting at aFrame looking for textRuns.
2409 * If |clear| is true, just clears the TEXT_RUN_MEMORY_ACCOUNTED flag
2410 * on each textRun found (and |aMallocSizeOf| is not used).
2411 * If |clear| is false, adds the storage used for each textRun to the
2412 * total, and sets the TEXT_RUN_MEMORY_ACCOUNTED flag to avoid double-
2413 * accounting. (Runs with this flag already set will be skipped.)
2414 * Expected usage pattern is therefore to call twice:
2415 * (void)SizeOfTextRunsForFrames(rootFrame, nullptr, true);
2416 * total = SizeOfTextRunsForFrames(rootFrame, mallocSizeOf, false);
2417 */
2422 /**
2423 * Returns true if |aFrame| has an animation of a property in |aPropertySet|
2424 * regardless of whether any property in the set is overridden by an
2425 * !important rule.
2426 */
2430 /**
2431 * A variant of the above HasAnimationOfPropertySet that takes an optional
2432 * EffectSet parameter as an optimization to save redundant lookups of the
2433 * EffectSet.
2434 */
2439 /**
2440 * A variant of the above HasAnimationOfPropertySet. This is especially for
2441 * tranform-like properties with motion-path.
2442 * For transform-like properties with motion-path, we need to check if
2443 * offset-path has effect. If we don't have any animation on offset-path and
2444 * offset-path is none, there is no effective motion-path, and so we don't
2445 * care other offset-* properties. In this case, this function only checks the
2446 * rest of transform-like properties (i.e. transform/translate/rotate/scale).
2447 */
2450 /**
2451 * Returns true if |aFrame| has an animation of |aProperty| which is
2452 * not overridden by !important rules.
2453 */
2455 nsCSSPropertyID aProperty);
2457 /**
2458 * Returns true if |aFrame| has an animation where at least one of the
2459 * properties in |aPropertySet| is not overridden by !important rules.
2460 *
2461 * If |aPropertySet| includes transform-like properties (transform, rotate,
2462 * etc.) however, this will return false if any of the transform-like
2463 * properties is overriden by an !important rule since these properties should
2464 * be combined on the compositor.
2465 */
2469 /**
2470 * Returns all effective animated CSS properties on |aStyleFrame| and its
2471 * corresponding primary frame (for content that makes this distinction,
2472 * notable display:table content) that can be animated on the compositor.
2473 *
2474 * Properties that can be animated on the compositor but which are overridden
2475 * by !important rules are not returned.
2476 *
2477 * Unlike HasEffectiveAnimation, however, this does not check the set of
2478 * transform-like properties to ensure that if any such properties are
2479 * overridden by !important rules, the other transform-like properties are
2480 * not run on the compositor (see bug 1534884).
2481 */
2485 /**
2486 * Checks if off-main-thread animations are enabled.
2487 */
2490 /**
2491 * Checks if retained display lists are enabled.
2492 */
2497 /**
2498 * Find a suitable scale for a element (aFrame's content) over the course of
2499 * any animations and transitions of the CSS transform property on the element
2500 * that run on the compositor thread. It will check the maximum and minimum
2501 * scale during the animations and transitions and return a suitable value for
2502 * performance and quality. Will return scale(1,1) if there are no such
2503 * animations. Always returns a positive value.
2504 * @param aVisibleSize is the size of the area we want to paint
2505 * @param aDisplaySize is the size of the display area of the pres context
2506 */
2511 /**
2512 * Checks whether we want to use the GPU to scale images when
2513 * possible.
2514 */
2517 /**
2518 * Unions the overflow areas of the children of aFrame with aOverflowAreas.
2519 * aSkipChildLists specifies any child lists that should be skipped.
2520 * kSelectPopupList and kPopupList are always skipped.
2521 */
2527 /**
2528 * Return the font size inflation *ratio* for a given frame. This is
2529 * the factor by which font sizes should be inflated; it is never
2530 * smaller than 1.
2531 */
2534 /**
2535 * Perform the first half of the computation of FontSizeInflationFor
2536 * (see above).
2537 * This includes determining whether inflation should be performed
2538 * within this container and returning 0 if it should not be.
2539 *
2540 * The result is guaranteed not to vary between line participants
2541 * (inlines, text frames) within a line.
2542 *
2543 * The result should not be used directly since font sizes slightly
2544 * above the minimum should always be adjusted as done by
2545 * FontSizeInflationInner.
2546 */
2549 /**
2550 * Perform the second half of the computation done by
2551 * FontSizeInflationFor (see above).
2552 *
2553 * aMinFontSize must be the result of one of the
2554 * InflationMinFontSizeFor methods above.
2555 */
2557 nscoord aMinFontSize);
2561 /**
2562 * Returns true if the nglayout.debug.invalidation pref is set to true.
2563 */
2567 }
2572 /**
2573 * Register an imgIRequest object with a refresh driver.
2574 *
2575 * @param aPresContext The nsPresContext whose refresh driver we want to
2576 * register with.
2577 * @param aRequest A pointer to the imgIRequest object which the client wants
2578 * to register with the refresh driver.
2579 * @param aRequestRegistered A pointer to a boolean value which indicates
2580 * whether the given image request is registered. If
2581 * *aRequestRegistered is true, then this request will not be
2582 * registered again. If the request is registered by this function,
2583 * then *aRequestRegistered will be set to true upon the completion of
2584 * this function.
2585 *
2586 */
2591 /**
2592 * Register an imgIRequest object with a refresh driver, but only if the
2593 * request is for an image that is animated.
2594 *
2595 * @param aPresContext The nsPresContext whose refresh driver we want to
2596 * register with.
2597 * @param aRequest A pointer to the imgIRequest object which the client wants
2598 * to register with the refresh driver.
2599 * @param aRequestRegistered A pointer to a boolean value which indicates
2600 * whether the given image request is registered. If
2601 * *aRequestRegistered is true, then this request will not be
2602 * registered again. If the request is registered by this function,
2603 * then *aRequestRegistered will be set to true upon the completion of
2604 * this function.
2605 *
2606 */
2611 /**
2612 * Deregister an imgIRequest object from a refresh driver.
2613 *
2614 * @param aPresContext The nsPresContext whose refresh driver we want to
2615 * deregister from.
2616 * @param aRequest A pointer to the imgIRequest object with which the client
2617 * previously registered and now wants to deregister from the refresh
2618 * driver.
2619 * @param aRequestRegistered A pointer to a boolean value which indicates
2620 * whether the given image request is registered. If
2621 * *aRequestRegistered is false, then this request will not be
2622 * deregistered. If the request is deregistered by this function,
2623 * then *aRequestRegistered will be set to false upon the completion of
2624 * this function.
2625 */
2630 /**
2631 * Shim to nsCSSFrameConstructor::PostRestyleEvent. Exists so that we
2632 * can avoid including nsCSSFrameConstructor.h and all its dependencies
2633 * in content files.
2634 */
2636 nsChangeHint aMinChangeHint);
2638 /**
2639 * Updates a pair of x and y distances if a given point is closer to a given
2640 * rectangle than the original distance values. If aPoint is closer to
2641 * aRect than aClosestXDistance and aClosestYDistance indicate, then those
2642 * two variables are updated with the distance between aPoint and aRect,
2643 * and true is returned. If aPoint is not closer, then aClosestXDistance
2644 * and aClosestYDistance are left unchanged, and false is returned.
2645 *
2646 * Distances are measured in the two dimensions separately; a closer x
2647 * distance beats a closer y distance.
2648 */
2653 /**
2654 * Computes the box shadow rect for the frame, or returns an empty rect if
2655 * there are no shadows.
2656 *
2657 * @param aFrame Frame to compute shadows for.
2658 * @param aFrameSize Size of aFrame (in case it hasn't been set yet).
2659 */
2663 #ifdef DEBUG
2664 /**
2665 * Assert that there are no duplicate continuations of the same frame
2666 * within aFrameList. Optimize the tests by assuming that all frames
2667 * in aFrameList have parent aContainer.
2668 */
2672 /**
2673 * Assert that the frame tree rooted at |aSubtreeRoot| is empty, i.e.,
2674 * that it contains no first-in-flows.
2675 */
2677 #endif
2679 /**
2680 * Helper method to get touch action behaviour from the frame
2681 */
2684 /**
2685 * Helper method to transform |aBounds| from aFrame to aAncestorFrame,
2686 * and combine it with |aPreciseTargetDest| if it is axis-aligned, or
2687 * combine it with |aImpreciseTargetDest| if not. The transformed rect is
2688 * clipped to |aClip|; if |aClip| has rounded corners, that also causes
2689 * the imprecise target to be used.
2690 */
2697 /**
2698 * Populate aOutSize with the size of the content viewer corresponding
2699 * to the given prescontext. Return true if the size was set, false
2700 * otherwise.
2701 */
2712 /**
2713 * Calculate the compostion size for a frame. See FrameMetrics.h for
2714 * defintion of composition size (or bounds).
2715 * Note that for the root content document's root scroll frame (RCD-RSF),
2716 * the returned size does not change as the document's resolution changes,
2717 * but for all other frames it does. This means that callers that pass in
2718 * a frame that may or may not be the RCD-RSF (which is most callers),
2719 * are likely to need special-case handling of the RCD-RSF.
2720 */
2725 /**
2726 * Calculate the composition size for the root scroll frame of the root
2727 * content document.
2728 * @param aFrame A frame in the root content document (or a descendant of it).
2729 * @param aIsRootContentDocRootScrollFrame Whether aFrame is already the root
2730 * scroll frame of the root content document. In this case we just
2731 * use aFrame's own composition size.
2732 * @param aMetrics A partially populated FrameMetrics for aFrame. Must have at
2733 * least mCompositionBounds, mCumulativeResolution, and
2734 * mDevPixelsPerCSSPixel set.
2735 */
2740 /**
2741 * Calculate the scrollable rect for a frame. See FrameMetrics.h for
2742 * defintion of scrollable rect. aScrollableFrame is the scroll frame to
2743 * calculate the scrollable rect for. If it's null then we calculate the
2744 * scrollable rect as the rect of the root frame.
2745 */
2749 /**
2750 * Calculate the expanded scrollable rect for a frame. See FrameMetrics.h for
2751 * defintion of expanded scrollable rect.
2752 */
2755 /**
2756 * Returns true if the widget owning the given frame uses asynchronous
2757 * scrolling.
2758 */
2761 /**
2762 * Returns true if the widget owning the given frame has builtin APZ support
2763 * enabled.
2764 */
2767 /**
2768 * Returns the current APZ Resolution Scale. When Java Pan/Zoom is
2769 * enabled in Fennec it will always return 1.0.
2770 */
2773 /**
2774 * Returns true if aDocument should be allowed to use resolution
2775 * zooming.
2776 */
2779 /**
2780 * Returns true if we need to disable async scrolling for this particular
2781 * element. Note that this does a partial disabling - the displayport still
2782 * exists but uses a very small margin, and the compositor doesn't apply the
2783 * async transform. However, the content may still be layerized.
2784 */
2787 /**
2788 * Log a key/value pair as "additional data" (not associated with a paint)
2789 * for APZ testing.
2790 * While the data is not associated with a paint, the APZTestData object
2791 * is still owned by {Client,WebRender}LayerManager, so we need to be passed
2792 * something from which we can derive the layer manager.
2793 * This function takes a display list builder as the object to derive the
2794 * layer manager from, to facilitate logging test data during display list
2795 * building, but other overloads that take other objects could be added if
2796 * desired.
2797 */
2802 /**
2803 * Log a key/value pair for APZ testing during a paint.
2804 * @param aManager The data will be written to the APZTestData associated
2805 * with this layer manager.
2806 * @param aScrollId Identifies the scroll frame to which the data pertains.
2807 * @param aKey The key under which to log the data.
2808 * @param aValue The value of the data to be logged.
2809 */
2814 }
2816 /**
2817 * A convenience overload of LogTestDataForPaint() that accepts any type
2818 * as the value, and passes it through mozilla::ToString() to obtain a string
2819 * value. The type passed must support streaming to an std::ostream.
2820 */
2826 }
2828 /**
2829 * Calculate a basic FrameMetrics with enough fields set to perform some
2830 * layout calculations. The fields set are dev-to-css ratio, pres shell
2831 * resolution, cumulative resolution, zoom, composition size, root
2832 * composition size, scroll offset and scrollable rect.
2833 *
2834 * Note that for the RCD-RSF, the scroll offset returned is the layout
2835 * viewport offset; if you need the visual viewport offset, that needs to
2836 * be queried independently via PresShell::GetVisualViewportOffset().
2837 *
2838 * By contrast, ComputeFrameMetrics() computes all the fields, but requires
2839 * extra inputs and can only be called during frame layer building.
2840 */
2844 /**
2845 * Calculate a default set of displayport margins for the given scrollframe
2846 * and set them on the scrollframe's content element. The margins are set with
2847 * the default priority, which may clobber previously set margins. The repaint
2848 * mode provided is passed through to the call to SetDisplayPortMargins.
2849 * The |aScrollFrame| parameter must be non-null and queryable to an nsIFrame.
2850 * @return true iff the call to SetDisplayPortMargins returned true.
2851 */
2855 /**
2856 * If |aScrollFrame| WantsAsyncScroll() and we don't have a scrollable
2857 * displayport yet (as tracked by |aBuilder|), calculate and set a
2858 * displayport.
2859 *
2860 * If this is called during display list building pass DoNotRepaint in
2861 * aRepaintMode.
2862 *
2863 * Returns true if there is a displayport on an async scrollable scrollframe
2864 * after this call, either because one was just added or it already existed.
2865 */
2868 RepaintMode aRepaintMode);
2872 /**
2873 * Sets a zero margin display port on all proper ancestors of aFrame that
2874 * are async scrollable.
2875 */
2878 /**
2879 * Finds the closest ancestor async scrollable frame from aFrame that has a
2880 * displayport and attempts to trigger the displayport expiry on that
2881 * ancestor.
2882 */
2892 /**
2893 * Returns true if the given scroll origin is "higher priority" than APZ.
2894 * In general any content programmatic scrolls (e.g. scrollTo calls) are
2895 * higher priority, and take precedence over APZ scrolling. This function
2896 * returns true for those, and returns false for other origins like APZ
2897 * itself, or scroll position updates from the history restore code.
2898 */
2909 /**
2910 * Returns the metadata to put onto the root layer of a layer tree, if one is
2911 * needed. The last argument is a callback function to check if the caller
2912 * already has a metadata for a given scroll id.
2913 */
2920 /**
2921 * If the given scroll frame needs an area excluded from its composition
2922 * bounds due to scrollbars, return that area, otherwise return an empty
2923 * margin.
2924 * There is no need to exclude scrollbars in the following cases:
2925 * - If the scroll frame is not the RCD-RSF; in that case, the composition
2926 * bounds is calculated based on the scroll port which already excludes
2927 * the scrollbar area.
2928 * - If the scrollbars are overlay, since then they are drawn on top of the
2929 * scrollable content.
2930 */
2934 /**
2935 * Looks in the layer subtree rooted at aLayer for a metrics with scroll id
2936 * aScrollId. Returns true if such is found.
2937 */
2944 /**
2945 * Get the text content inside the frame. This methods traverse the
2946 * frame tree and collect the content from text frames. Note that this
2947 * method is similiar to nsContentUtils::GetNodeTextContent, but it at
2948 * least differs from that method in the following things:
2949 * 1. it skips text content inside nodes like style, script, textarea
2950 * which don't generate an in-tree text frame for the text;
2951 * 2. it skips elements with display property set to none;
2952 * 3. it skips out-of-flow elements;
2953 * 4. it includes content inside pseudo elements;
2954 * 5. it may include part of text content of a node if a text frame
2955 * inside is split to different continuations.
2956 */
2959 /**
2960 * Same as GetFrameTextContent but appends the result rather than sets it.
2961 */
2964 /**
2965 * Takes a selection, and returns selection's bounding rect which is relative
2966 * to its root frame.
2967 *
2968 * @param aSel Selection to check
2969 */
2972 /**
2973 * Calculate the bounding rect of |aContent|, relative to the origin
2974 * of the scrolled content of |aRootScrollFrame|.
2975 * Where the element is contained inside a scrollable subframe, the
2976 * bounding rect is clipped to the bounds of the subframe.
2977 */
2981 /**
2982 * Returns the first ancestor who is a float containing block.
2983 */
2986 /**
2987 * Walks up the frame tree from |aForFrame| up to |aTopFrame|, or to the
2988 * root of the frame tree if |aTopFrame| is nullptr, and returns true if
2989 * a transformed frame is encountered.
2990 */
2993 /**
2994 * Walk up from aFrame to the cross-doc root, accumulating all the APZ
2995 * callback transforms on the content elements encountered along the way.
2996 * Return the accumulated value.
2997 * XXX: Note that this does not take into account CSS transforms, nor
2998 * differences in structure between the frame tree and the layer tree (which
2999 * is probably what we *want* to be computing).
3000 */
3003 /**
3004 * Compute a rect to pre-render in cases where we want to render more of
3005 * something than what is visible (usually to support async transformation).
3006 * @param aFrame the target frame to be pre-rendered
3007 * @param aDirtyRect the area that's visible in the coordinate system of
3008 * |aFrame|.
3009 * @param aOverflow the total size of the thing we're rendering in the
3010 * coordinate system of |aFrame|.
3011 * @param aPrerenderSize how large of an area we're willing to render in the
3012 * coordinate system of the root frame.
3013 * @return A rectangle that includes |aDirtyRect|, is clamped to |aOverflow|,
3014 * and is no larger than |aPrerenderSize| (unless |aPrerenderSize| is
3015 * smaller than |aDirtyRect|, in which case the returned rect will
3016 * still include |aDirtyRect| and thus be larger than
3017 * |aPrerenderSize|).
3018 */
3024 /*
3025 * Checks whether a node is an invisible break.
3026 * If not, returns the first frame on the next line if such a next line
3027 * exists.
3028 *
3029 * @return
3030 * true if the node is an invisible break. aNextLineFrame is returned null
3031 * in this case.
3032 *
3033 * false if the node causes a visible break or if the node is no break.
3034 *
3035 * @param aNextLineFrame
3036 * assigned to first frame on the next line if such a next line exists, null
3037 * otherwise.
3038 */
3052 // Return the default value to be used for -moz-control-character-visibility,
3053 // from preferences.
3057 // Callers are responsible to ensure the user-font-set is up-to-date if
3058 // aUseUserFontSet is true.
3070 /**
3071 * Returns true if there are any preferences or overrides that indicate a
3072 * need to handle <meta name="viewport"> tags.
3073 */
3076 /**
3077 * Resolve a CSS <length-percentage> value to a definite size.
3078 */
3081 nscoord aPercentageBasis) {
3086 }
3088 /**
3089 * Resolve a column-gap/row-gap to a definite size.
3090 * @note This method resolves 'normal' to zero.
3091 * Callers who want different behavior should handle 'normal' on their own.
3092 */
3095 nscoord aPercentageBasis) {
3098 }
3100 }
3102 /**
3103 * Get the computed style from which the scrollbar style should be
3104 * used for the given scrollbar part frame.
3105 */
3108 /**
3109 * Returns true if |aFrame| is scrolled out of view by a scrollable element in
3110 * a cross-process ancestor document.
3111 * Note this function only works for frames in out-of-process iframes.
3112 **/
3115 /**
3116 * Similar to above FrameIsScrolledOutViewInCrossProcess but returns true even
3117 * if |aFrame| is not fully scrolled out of view and its visible area width or
3118 * height is smaller than |aMargin|.
3119 **/
3123 /**
3124 * Expand the height of |aSize| to the size of `vh` units.
3125 *
3126 * With dynamic toolbar(s) the height for `vh` units is greater than the
3127 * ICB height, we need to expand it in some places.
3128 **/
3138 /**
3139 * Helper function for LogTestDataForPaint().
3140 */
3149 };
3160 CoordType xDistance;
3165 }
3170 }
3175 CoordType yDistance;
3180 }
3186 }
3187 }
3190 }
3195 // Get a new Rect whose units are app units by scaling by the specified
3196 // factor.
3200 // We now need to constrain our results to the max and min values for coords.
3206 }
3210 }
3212 // Now typecast everything back. This is guaranteed to be safe.
3215 }
3219 /**
3220 * Converts an nsPoint in app units to a Moz2D Point in pixels (whether those
3221 * are device pixels or CSS px depends on what the caller chooses to pass as
3222 * aAppUnitsPerPixel).
3223 */
3228 }
3230 /**
3231 * Converts an nsRect in app units to a Moz2D Rect in pixels (whether those
3232 * are device pixels or CSS px depends on what the caller chooses to pass as
3233 * aAppUnitsPerPixel).
3234 */
3237 /**
3238 * Converts an nsRect in app units to a Moz2D Rect in pixels (whether those
3239 * are device pixels or CSS px depends on what the caller chooses to pass as
3240 * aAppUnitsPerPixel).
3241 *
3242 * The passed DrawTarget is used to additionally snap the returned Rect to
3243 * device pixels, if appropriate (as decided and carried out by Moz2D's
3244 * MaybeSnapToDevicePixels helper, which this function calls to do any
3245 * snapping).
3246 */
3250 /**
3251 * Converts, where possible, an nsRect in app units to a Moz2D Rect in pixels
3252 * (whether those are device pixels or CSS px depends on what the caller
3253 * chooses to pass as aAppUnitsPerPixel).
3254 *
3255 * If snapping results in a rectangle with zero width or height, the affected
3256 * coordinates are left unsnapped
3257 */
3270 /**
3271 * An RAII class which will, for the duration of its lifetime,
3272 * **if** the frame given is a container for font size inflation,
3273 * set the current inflation container on the pres context to null
3274 * (and then, in its destructor, restore the old value).
3275 */
3285 };
3300 NS_DECL_NSIRUNNABLE
3304 nsAutoString mValue;
3305 };
3311 NS_DECL_NSIRUNNABLE
3315 };
3317 // This class allows you to easily set any pointer variable and ensure it's
3318 // set to nullptr when leaving its scope.
3325 }
3330 };