зеркало из https://github.com/mozilla/gecko-dev.git
437 строки
18 KiB
C++
437 строки
18 KiB
C++
/* -*- 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 <bzbarsky@mit.edu>.
|
|
* 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;
|
|
class nsIFontMetrics;
|
|
|
|
#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<nsStyleContext> 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);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Get the font metrics corresponding to the frame's style data.
|
|
* @param aFrame the frame
|
|
* @param aFontMetrics the font metrics result
|
|
* @return success or failure code
|
|
*/
|
|
static nsresult GetFontMetricsForFrame(nsIFrame* aFrame,
|
|
nsIFontMetrics** aFontMetrics);
|
|
};
|
|
|
|
#endif // nsLayoutUtils_h__
|