/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is Mozilla.org code. * * The Initial Developer of the Original Code is * Boris Zbarsky . * Portions created by the Initial Developer are Copyright (C) 2002 * the Initial Developer. All Rights Reserved. * * Contributor(s): * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #ifndef nsLayoutUtils_h__ #define nsLayoutUtils_h__ class nsIFrame; class nsIFormControlFrame; class nsPresContext; class nsIContent; class nsIAtom; class nsIScrollableView; class nsIScrollableFrame; class nsIDOMEvent; class nsRegion; class nsDisplayListBuilder; #include "prtypes.h" #include "nsStyleContext.h" #include "nsAutoPtr.h" #include "nsStyleSet.h" #include "nsIView.h" /** * nsLayoutUtils is a namespace class used for various helper * functions that are useful in multiple places in layout. The goal * is not to define multiple copies of the same static helper. */ class nsLayoutUtils { public: /** * GetBeforeFrame returns the :before frame of the given frame, if * one exists. This is typically O(1). The frame passed in must be * the first-in-flow. * * @param aFrame the frame whose :before is wanted * @return the :before frame or nsnull if there isn't one */ static nsIFrame* GetBeforeFrame(nsIFrame* aFrame); /** * GetAfterFrame returns the :after frame of the given frame, if one * exists. This will walk the in-flow chain to the last-in-flow if * needed. This function is typically O(N) in the number of child * frames, following in-flows, etc. * * @param aFrame the frame whose :after is wanted * @return the :after frame or nsnull if there isn't one */ static nsIFrame* GetAfterFrame(nsIFrame* aFrame); /** * Given a frame, search up the frame tree until we find an * ancestor "Page" frame, if any. * * @param the frame to start at * @return a frame of type nsLayoutAtoms::pageFrame or nsnull if no * such ancestor exists */ static nsIFrame* GetPageFrame(nsIFrame* aFrame); /** * IsGeneratedContentFor returns PR_TRUE if aFrame is generated * content of type aPseudoElement for aContent * * @param aContent the content node we're looking at. If this is * null, then we just assume that aFrame has the right content * pointer. * @param aFrame the frame we're looking at * @param aPseudoElement the pseudo type we're interested in * @return whether aFrame is the generated aPseudoElement frame for aContent */ static PRBool IsGeneratedContentFor(nsIContent* aContent, nsIFrame* aFrame, nsIAtom* aPseudoElement); /** * CompareTreePosition determines whether aContent1 comes before or * after aContent2 in a preorder traversal of the content tree. * * @param aCommonAncestor either null, or a common ancestor of * aContent1 and aContent2. Actually this is * only a hint; if it's not an ancestor of * aContent1 or aContent2, this function will * still work, but it will be slower than * normal. * @return < 0 if aContent1 is before aContent2 * > 0 if aContent1 is after aContent2, * 0 otherwise (meaning they're the same, or they're in * different documents) */ static PRInt32 CompareTreePosition(nsIContent* aContent1, nsIContent* aContent2, nsIContent* aCommonAncestor = nsnull) { return DoCompareTreePosition(aContent1, aContent2, -1, 1, aCommonAncestor); } /* * More generic version of |CompareTreePosition|. |aIf1Ancestor| * gives the value to return when 1 is an ancestor of 2, and likewise * for |aIf2Ancestor|. Passing (-1, 1) gives preorder traversal * order, and (1, -1) gives postorder traversal order. */ static PRInt32 DoCompareTreePosition(nsIContent* aContent1, nsIContent* aContent2, PRInt32 aIf1Ancestor, PRInt32 aIf2Ancestor, nsIContent* aCommonAncestor = nsnull); /** * GetLastSibling simply finds the last sibling of aFrame, or returns nsnull if * aFrame is null. */ static nsIFrame* GetLastSibling(nsIFrame* aFrame); /** * FindSiblingViewFor locates the child of aParentView that aFrame's * view should be inserted 'above' (i.e., before in sibling view * order). This is the first child view of aParentView whose * corresponding content is before aFrame's content (view siblings * are in reverse content order). */ static nsIView* FindSiblingViewFor(nsIView* aParentView, nsIFrame* aFrame); /** * Get the parent of aFrame. If aFrame is the root frame for a document, * and the document has a parent document in the same view hierarchy, then * we try to return the subdocumentframe in the parent document. */ static nsIFrame* GetCrossDocParentFrame(nsIFrame* aFrame); /** * IsProperAncestorFrame checks whether aAncestorFrame is an ancestor * of aFrame and not equal to aFrame. * @param aCommonAncestor nsnull, or a common ancestor of aFrame and * aAncestorFrame. If non-null, this can bound the search and speed up * the function */ static PRBool IsProperAncestorFrame(nsIFrame* aAncestorFrame, nsIFrame* aFrame, nsIFrame* aCommonAncestor = nsnull); /** * Like IsProperAncestorFrame, but looks across document boundaries. */ static PRBool IsProperAncestorFrameCrossDoc(nsIFrame* aAncestorFrame, nsIFrame* aFrame, nsIFrame* aCommonAncestor = nsnull); /** * GetFrameFor returns the root frame for a view * @param aView is the view to return the root frame for * @return the root frame for the view */ static nsIFrame* GetFrameFor(nsIView *aView) { return NS_STATIC_CAST(nsIFrame*, aView->GetClientData()); } /** * GetScrollableFrameFor returns the scrollable frame for a scrollable view * @param aScrollableView is the scrollable view to return the * scrollable frame for. * @return the scrollable frame for the scrollable view */ static nsIScrollableFrame* GetScrollableFrameFor(nsIScrollableView *aScrollableView); /** * GetScrollableFrameFor returns the scrollable frame for a scrolled frame */ static nsIScrollableFrame* GetScrollableFrameFor(nsIFrame *aScrolledFrame); static nsPresContext::ScrollbarStyles ScrollbarStylesOfView(nsIScrollableView *aScrollableView); /** * GetNearestScrollingView locates the first ancestor of aView (or * aView itself) that is scrollable. It does *not* count an * 'overflow' style of 'hidden' as scrollable, even though a scrolling * view is present. Thus, the direction of the scroll is needed as * an argument. * * @param aView the view we're looking at * @param aDirection Whether it's for horizontal or vertical scrolling. * @return the nearest scrollable view or nsnull if not found */ enum Direction { eHorizontal, eVertical, eEither }; static nsIScrollableView* GetNearestScrollingView(nsIView* aView, Direction aDirection); /** * HasPseudoStyle returns PR_TRUE if aContent (whose primary style * context is aStyleContext) has the aPseudoElement pseudo-style * attached to it; returns PR_FALSE otherwise. * * @param aContent the content node we're looking at * @param aStyleContext aContent's style context * @param aPseudoElement the name of the pseudo style we care about * @param aPresContext the presentation context * @return whether aContent has aPseudoElement style attached to it */ static PRBool HasPseudoStyle(nsIContent* aContent, nsStyleContext* aStyleContext, nsIAtom* aPseudoElement, nsPresContext* aPresContext) { NS_PRECONDITION(aPresContext, "Must have a prescontext"); NS_PRECONDITION(aPseudoElement, "Must have a pseudo name"); nsRefPtr pseudoContext; if (aContent) { pseudoContext = aPresContext->StyleSet()-> ProbePseudoStyleFor(aContent, aPseudoElement, aStyleContext); } return pseudoContext != nsnull; } /** * If this frame is a placeholder for a float, then return the float, * otherwise return nsnull. */ static nsIFrame* GetFloatFromPlaceholder(nsIFrame* aPossiblePlaceholder); // Combine aNewBreakType with aOrigBreakType, but limit the break types // to NS_STYLE_CLEAR_LEFT, RIGHT, LEFT_AND_RIGHT. static PRUint8 CombineBreakType(PRUint8 aOrigBreakType, PRUint8 aNewBreakType); /** * @return PR_TRUE if aFrame is the CSS initial containing block for * its pres-shell */ static PRBool IsInitialContainingBlock(nsIFrame* aFrame); /** * Get the coordinates of a given DOM mouse event, relative to a given * frame. Works only for DOM events generated by nsGUIEvents. * @param aDOMEvent the event * @param aFrame the frame to make coordinates relative to * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if * for some reason the coordinates for the mouse are not known (e.g., * the event is not a GUI event). */ static nsPoint GetDOMEventCoordinatesRelativeTo(nsIDOMEvent* aDOMEvent, nsIFrame* aFrame); /** * Get the coordinates of a given native mouse event, relative to a given * frame. * @param aEvent the event * @param aFrame the frame to make coordinates relative to * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if * for some reason the coordinates for the mouse are not known (e.g., * the event is not a GUI event). */ static nsPoint GetEventCoordinatesRelativeTo(nsEvent* aEvent, nsIFrame* aFrame); /** * Get the coordinates of a given native mouse event, relative to the nearest * view for a given frame. * The "nearest view" is the view returned by nsFrame::GetOffsetFromView. * XXX this is extremely BOGUS because "nearest view" is a mess; every * use of this method is really a bug! * @param aEvent the event * @param aFrame the frame to make coordinates relative to * @param aView view to which returned coordinates are relative * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if * for some reason the coordinates for the mouse are not known (e.g., * the event is not a GUI event). */ static nsPoint GetEventCoordinatesForNearestView(nsEvent* aEvent, nsIFrame* aFrame, nsIView** aView = nsnull); /** * Translate from widget coordinates to the view's coordinates * @param aPresContext the PresContext for the view * @param aWidget the widget * @param aPt the point relative to the widget * @param aView view to which returned coordinates are relative * @return the point in the view's coordinates */ static nsPoint TranslateWidgetToView(nsPresContext* aPresContext, nsIWidget* aWidget, nsIntPoint aPt, nsIView* aView); /** * Given aFrame, the root frame of a stacking context, find its descendant * frame under the point aPt that receives a mouse event at that location, * or nsnull if there is no such frame. * @param aPt the point, relative to the frame origin */ static nsIFrame* GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt); /** * Given aFrame, the root frame of a stacking context, paint it and its * descendants to aRenderingContext. * @param aRenderingContext a rendering context translated so that (0,0) * is the origin of aFrame * @param aDirtyRegion the region that must be painted, in the coordinates * of aFrame * @param aBackground paint the dirty area with this color before drawing * the actual content; pass NS_RGBA(0,0,0,0) to draw no background */ static nsresult PaintFrame(nsIRenderingContext* aRenderingContext, nsIFrame* aFrame, const nsRegion& aDirtyRegion, nscolor aBackground); /** * @param aRootFrame the root frame of the tree to be displayed * @param aMovingFrame a frame that has moved * @param aPt the amount by which aMovingFrame has moved and the rect will * be copied * @param aCopyRect a rectangle that will be copied, relative to aRootFrame * @param aRepaintRegion a subregion of aCopyRect+aDelta that must be repainted * after doing the bitblt * * Ideally this function would actually have the rect-to-copy as an output * rather than an input, but for now, scroll bitblitting is limited to * the whole of a single widget, so we cannot choose the rect. * * This function assumes that the caller will do a bitblt copy of aCopyRect * to aCopyRect+aPt. It computes a region that must be repainted in order * for the resulting rendering to be correct. * * The region consists of: * a) any visible background-attachment:fixed areas in the after-move display * list * b) any visible areas of the before-move display list corresponding to * frames that will not move (translated by aDelta) * c) any visible areas of the after-move display list corresponding to * frames that did not move * d) except that if the same display list element is visible in b) and c) * for a frame that did not move and paints a uniform color within its * bounds, then the intersection of its old and new bounds can be excluded * when it is processed by b) and c). * * We may return a larger region if computing the above region precisely is * too expensive. */ static nsresult ComputeRepaintRegionForCopy(nsIFrame* aRootFrame, nsIFrame* aMovingFrame, nsPoint aDelta, const nsRect& aCopyRect, nsRegion* aRepaintRegion); static nsresult CreateOffscreenContext(nsIDeviceContext* deviceContext, nsIDrawingSurface* surface, const nsRect& aRect, nsIRenderingContext** aResult); /** * Compute the used z-index of aFrame; returns zero for elements to which * z-index does not apply, and for z-index:auto */ static PRInt32 GetZIndex(nsIFrame* aFrame); /** * Uses a binary search for find where the cursor falls in the line of text * It also keeps track of the part of the string that has already been measured * so it doesn't have to keep measuring the same text over and over * * @param "aBaseWidth" contains the width in twips of the portion * of the text that has already been measured, and aBaseInx contains * the index of the text that has already been measured. * * @param aTextWidth returns the (in twips) the length of the text that falls * before the cursor aIndex contains the index of the text where the cursor falls */ static PRBool BinarySearchForPosition(nsIRenderingContext* acx, const PRUnichar* aText, PRInt32 aBaseWidth, PRInt32 aBaseInx, PRInt32 aStartInx, PRInt32 aEndInx, PRInt32 aCursorPos, PRInt32& aIndex, PRInt32& aTextWidth); /** * Scroll the given form control frame into view. * @param aFormFrame Frame to scroll into view. */ static void ScrollIntoView(nsIFormControlFrame* aFormFrame); // Safe wrappers around Gfx nsIRenderingContext functions to avoid passing // long strings to unreliable platform APIs, by breaking strings up into pieces. // // We avoid breaking strings at bad places (e.g. inside Unicode surrogate // pairs, or inside a cluster). However we still slightly alter output because // we will be disabling kerning at the boundaries where we break strings. At // least (hopefully) we disable kerning consistently when we measure and draw // strings. #define MAX_GFX_TEXT_BUF_SIZE 8000 static nsresult SafeGetWidth(nsIRenderingContext* aContext, const char *aString, PRUint32 aLength, nscoord& aWidth); static nsresult SafeGetWidth(nsIRenderingContext* aContext, const PRUnichar *aString, PRUint32 aLength, nscoord& aWidth); static nsresult SafeGetWidth(nsIRenderingContext* aContext, const char* aString, nscoord& aWidth) { return SafeGetWidth(aContext, aString, strlen(aString), aWidth); } static nsresult SafeGetWidth(nsIRenderingContext* aContext, const nsString& aString, nscoord& aWidth) { return SafeGetWidth(aContext, aString.get(), aString.Length(), aWidth); } static void SafeDrawString(nsIRenderingContext* aContext, const char *aString, PRUint32 aLength, nscoord aX, nscoord aY); static void SafeDrawString(nsIRenderingContext* aContext, const PRUnichar *aString, PRUint32 aLength, nscoord aX, nscoord aY, PRInt32 aFontID = -1, const nscoord* aSpacing = nsnull); static void SafeDrawString(nsIRenderingContext* aContext, const nsString& aString, nscoord aX, nscoord aY, PRInt32 aFontID = -1, const nscoord* aSpacing = nsnull) { SafeDrawString(aContext, aString.get(), aString.Length(), aX, aY, aFontID, aSpacing); } static void SafeGetTextDimensions(nsIRenderingContext* aContext, const char* aString, PRUint32 aLength, nsTextDimensions& aDimensions); static void SafeGetTextDimensions(nsIRenderingContext* aContext, const PRUnichar* aString, PRUint32 aLength, nsTextDimensions& aDimensions); #if defined(_WIN32) || defined(XP_OS2) || defined(MOZ_X11) || defined(XP_BEOS) static void SafeGetTextDimensions(nsIRenderingContext* aContext, const char* aString, PRInt32 aLength, PRInt32 aAvailWidth, PRInt32* aBreaks, PRInt32 aNumBreaks, nsTextDimensions& aDimensions, PRInt32& aNumCharsFit, nsTextDimensions& aLastWordDimensions); static void SafeGetTextDimensions(nsIRenderingContext* aContext, const PRUnichar* aString, PRInt32 aLength, PRInt32 aAvailWidth, PRInt32* aBreaks, PRInt32 aNumBreaks, nsTextDimensions& aDimensions, PRInt32& aNumCharsFit, nsTextDimensions& aLastWordDimensions); #endif #ifdef MOZ_MATHML static nsresult SafeGetBoundingMetrics(nsIRenderingContext* aContext, const char* aString, PRUint32 aLength, nsBoundingMetrics& aBoundingMetrics); static nsresult SafeGetBoundingMetrics(nsIRenderingContext* aContext, const PRUnichar* aString, PRUint32 aLength, nsBoundingMetrics& aBoundingMetrics); #endif /** * Get the union of all rects in aFrame and its continuations, relative * to aFrame's origin. Scrolling is taken into account, but this shouldn't * matter because it should be impossible to have some continuations scrolled * differently from others. */ static nsRect GetAllInFlowBoundingRect(nsIFrame* aFrame); }; #endif // nsLayoutUtils_h__