2003-01-05 08:05:17 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 18:30:37 +04:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2003-01-05 08:05:17 +03:00
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* 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/
|
2003-01-05 08:05:17 +03:00
|
|
|
*
|
|
|
|
* 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):
|
2007-03-20 03:58:20 +03:00
|
|
|
* Boris Zbarsky <bzbarsky@mit.edu> (original author)
|
|
|
|
* L. David Baron <dbaron@dbaron.org>, Mozilla Corporation
|
2011-06-22 22:11:48 +04:00
|
|
|
* Mats Palmgren <matspal@gmail.com>
|
2003-01-05 08:05:17 +03:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 18:30:37 +04:00
|
|
|
* 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"),
|
2003-01-05 08:05:17 +03:00
|
|
|
* 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
|
2004-04-18 18:30:37 +04:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2003-01-05 08:05:17 +03:00
|
|
|
* 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
|
2004-04-18 18:30:37 +04:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2003-01-05 08:05:17 +03:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
#ifndef nsLayoutUtils_h__
|
|
|
|
#define nsLayoutUtils_h__
|
|
|
|
|
2005-12-13 02:53:06 +03:00
|
|
|
class nsIFormControlFrame;
|
2004-08-01 03:15:21 +04:00
|
|
|
class nsPresContext;
|
2003-04-22 03:06:40 +04:00
|
|
|
class nsIContent;
|
|
|
|
class nsIAtom;
|
2004-10-19 06:24:27 +04:00
|
|
|
class nsIScrollableFrame;
|
2005-06-02 13:00:48 +04:00
|
|
|
class nsIDOMEvent;
|
2006-01-26 05:29:17 +03:00
|
|
|
class nsRegion;
|
2006-04-18 03:16:46 +04:00
|
|
|
class nsDisplayListBuilder;
|
2011-04-06 09:00:25 +04:00
|
|
|
class nsDisplayItem;
|
2011-04-08 05:05:49 +04:00
|
|
|
class nsFontMetrics;
|
2009-09-25 01:01:48 +04:00
|
|
|
class nsClientRectList;
|
2011-06-16 10:31:36 +04:00
|
|
|
class nsFontFaceList;
|
2003-04-22 03:06:40 +04:00
|
|
|
|
|
|
|
#include "prtypes.h"
|
|
|
|
#include "nsStyleContext.h"
|
|
|
|
#include "nsAutoPtr.h"
|
2004-01-28 03:18:22 +03:00
|
|
|
#include "nsStyleSet.h"
|
2004-10-19 06:24:27 +04:00
|
|
|
#include "nsIView.h"
|
2007-08-25 02:20:24 +04:00
|
|
|
#include "nsIFrame.h"
|
2008-04-15 03:59:21 +04:00
|
|
|
#include "nsThreadUtils.h"
|
2009-01-19 12:29:48 +03:00
|
|
|
#include "nsIPresShell.h"
|
2009-07-02 13:57:35 +04:00
|
|
|
#include "nsIPrincipal.h"
|
2009-04-05 13:52:14 +04:00
|
|
|
#include "gfxPattern.h"
|
2009-09-13 02:44:18 +04:00
|
|
|
#include "imgIContainer.h"
|
2009-12-11 10:37:40 +03:00
|
|
|
#include "nsCSSPseudoElements.h"
|
2010-08-25 14:17:56 +04:00
|
|
|
#include "nsHTMLReflowState.h"
|
2011-01-13 20:45:14 +03:00
|
|
|
#include "nsIFrameLoader.h"
|
|
|
|
#include "Layers.h"
|
2003-01-05 08:05:17 +03:00
|
|
|
|
2007-01-17 05:37:19 +03:00
|
|
|
class nsBlockFrame;
|
2010-08-13 17:30:37 +04:00
|
|
|
class gfxDrawable;
|
2007-01-17 05:37:19 +03:00
|
|
|
|
2011-12-04 01:50:16 +04:00
|
|
|
namespace mozilla {
|
|
|
|
namespace dom {
|
|
|
|
class Element;
|
|
|
|
} // namespace dom
|
|
|
|
} // namespace mozilla
|
|
|
|
|
2003-01-05 08:05:17 +03:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
{
|
2010-10-12 00:07:59 +04:00
|
|
|
typedef gfxPattern::GraphicsFilter GraphicsFilter;
|
|
|
|
|
2003-01-05 08:05:17 +03:00
|
|
|
public:
|
2011-01-13 20:45:14 +03:00
|
|
|
typedef mozilla::layers::FrameMetrics::ViewID ViewID;
|
2009-12-24 08:20:41 +03:00
|
|
|
|
2011-01-13 20:45:14 +03:00
|
|
|
/**
|
|
|
|
* Finds previously assigned or generates a unique ViewID for the given
|
|
|
|
* content element.
|
|
|
|
*/
|
|
|
|
static ViewID FindIDFor(nsIContent* aContent);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Find content for given ID.
|
|
|
|
*/
|
|
|
|
static nsIContent* FindContentFor(ViewID aId);
|
|
|
|
|
2011-03-16 02:20:19 +03:00
|
|
|
/**
|
|
|
|
* Get display port for the given element.
|
|
|
|
*/
|
|
|
|
static bool GetDisplayPort(nsIContent* aContent, nsRect *aResult);
|
|
|
|
|
2009-12-24 08:20:41 +03:00
|
|
|
/**
|
2011-08-25 00:54:30 +04:00
|
|
|
* Use heuristics to figure out the child list that
|
2010-07-03 08:18:55 +04:00
|
|
|
* aChildFrame is currently in.
|
2009-12-24 08:20:41 +03:00
|
|
|
*/
|
2011-08-25 00:54:30 +04:00
|
|
|
static nsIFrame::ChildListID GetChildListNameFor(nsIFrame* aChildFrame);
|
2009-12-24 08:20:41 +03:00
|
|
|
|
2003-01-05 08:05:17 +03:00
|
|
|
/**
|
2008-08-18 05:16:42 +04:00
|
|
|
* GetBeforeFrame returns the outermost :before frame of the given frame, if
|
2003-01-05 08:05:17 +03:00
|
|
|
* one exists. This is typically O(1). The frame passed in must be
|
2010-04-27 20:15:01 +04:00
|
|
|
* the first-in-flow.
|
2003-01-05 08:05:17 +03:00
|
|
|
*
|
|
|
|
* @param aFrame the frame whose :before is wanted
|
|
|
|
* @return the :before frame or nsnull if there isn't one
|
|
|
|
*/
|
2005-02-18 09:06:47 +03:00
|
|
|
static nsIFrame* GetBeforeFrame(nsIFrame* aFrame);
|
2003-01-05 08:05:17 +03:00
|
|
|
|
|
|
|
/**
|
2008-08-18 05:16:42 +04:00
|
|
|
* GetAfterFrame returns the outermost :after frame of the given frame, if one
|
2003-01-05 08:05:17 +03:00
|
|
|
* 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
|
|
|
|
*/
|
2005-02-18 09:06:47 +03:00
|
|
|
static nsIFrame* GetAfterFrame(nsIFrame* aFrame);
|
2003-01-05 08:05:17 +03:00
|
|
|
|
2010-04-27 20:15:01 +04:00
|
|
|
/**
|
2003-04-22 03:06:40 +04:00
|
|
|
* Given a frame, search up the frame tree until we find an
|
2007-07-04 05:13:07 +04:00
|
|
|
* ancestor that (or the frame itself) is of type aFrameType, if any.
|
2003-04-22 03:06:40 +04:00
|
|
|
*
|
2007-07-04 05:13:07 +04:00
|
|
|
* @param aFrame the frame to start at
|
|
|
|
* @param aFrameType the frame type to look for
|
|
|
|
* @return a frame of the given type or nsnull if no
|
|
|
|
* such ancestor exists
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetClosestFrameOfType(nsIFrame* aFrame, nsIAtom* aFrameType);
|
|
|
|
|
2010-04-27 20:15:01 +04:00
|
|
|
/**
|
2007-07-04 05:13:07 +04:00
|
|
|
* Given a frame, search up the frame tree until we find an
|
|
|
|
* ancestor that (or the frame itself) is a "Page" frame, if any.
|
|
|
|
*
|
|
|
|
* @param aFrame the frame to start at
|
2007-01-30 03:06:41 +03:00
|
|
|
* @return a frame of type nsGkAtoms::pageFrame or nsnull if no
|
2003-04-22 03:06:40 +04:00
|
|
|
* such ancestor exists
|
2003-02-23 05:49:22 +03:00
|
|
|
*/
|
2007-07-04 05:13:07 +04:00
|
|
|
static nsIFrame* GetPageFrame(nsIFrame* aFrame)
|
|
|
|
{
|
|
|
|
return GetClosestFrameOfType(aFrame, nsGkAtoms::pageFrame);
|
|
|
|
}
|
2003-04-22 03:06:40 +04:00
|
|
|
|
2009-12-01 20:21:00 +03:00
|
|
|
/**
|
|
|
|
* Given a frame which is the primary frame for an element,
|
|
|
|
* return the frame that has the non-psuedoelement style context for
|
|
|
|
* the content.
|
|
|
|
* This is aPrimaryFrame itself except for tableOuter frames.
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetStyleFrame(nsIFrame* aPrimaryFrame);
|
|
|
|
|
2003-04-22 03:06:40 +04:00
|
|
|
/**
|
2011-10-17 18:59:28 +04:00
|
|
|
* IsGeneratedContentFor returns true if aFrame is the outermost
|
2008-08-18 05:16:42 +04:00
|
|
|
* frame for generated content of type aPseudoElement for aContent.
|
|
|
|
* aFrame *might not* have the aPseudoElement pseudo-style! For example
|
|
|
|
* it might be a table outer frame and the inner table frame might
|
|
|
|
* have the pseudo-style.
|
2003-04-22 03:06:40 +04:00
|
|
|
*
|
|
|
|
* @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
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsGeneratedContentFor(nsIContent* aContent, nsIFrame* aFrame,
|
2003-04-22 03:06:40 +04:00
|
|
|
nsIAtom* aPseudoElement);
|
2003-10-15 04:49:03 +04:00
|
|
|
|
2010-10-13 14:52:45 +04:00
|
|
|
#ifdef DEBUG
|
|
|
|
// TODO: remove, see bug 598468.
|
|
|
|
static bool gPreventAssertInCompareTreePosition;
|
|
|
|
#endif // DEBUG
|
|
|
|
|
2003-10-15 04:49:03 +04:00
|
|
|
/**
|
2004-04-13 01:53:22 +04:00
|
|
|
* CompareTreePosition determines whether aContent1 comes before or
|
|
|
|
* after aContent2 in a preorder traversal of the content tree.
|
2010-04-27 20:15:01 +04:00
|
|
|
*
|
2004-04-13 01:53:22 +04:00
|
|
|
* @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)
|
2003-10-15 04:49:03 +04:00
|
|
|
*/
|
2004-04-13 01:53:22 +04:00
|
|
|
static PRInt32 CompareTreePosition(nsIContent* aContent1,
|
|
|
|
nsIContent* aContent2,
|
2009-09-18 22:52:27 +04:00
|
|
|
const nsIContent* aCommonAncestor = nsnull)
|
2004-04-13 01:53:22 +04:00
|
|
|
{
|
|
|
|
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,
|
2009-09-18 22:52:27 +04:00
|
|
|
const nsIContent* aCommonAncestor = nsnull);
|
2007-01-18 01:48:24 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* CompareTreePosition determines whether aFrame1 comes before or
|
|
|
|
* after aFrame2 in a preorder traversal of the frame tree, where out
|
|
|
|
* of flow frames are treated as children of their placeholders. This is
|
|
|
|
* basically the same ordering as DoCompareTreePosition(nsIContent*) except
|
|
|
|
* that it handles anonymous content properly and there are subtleties with
|
|
|
|
* continuations.
|
2010-04-27 20:15:01 +04:00
|
|
|
*
|
2007-01-18 01:48:24 +03:00
|
|
|
* @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 frame trees)
|
|
|
|
*/
|
|
|
|
static PRInt32 CompareTreePosition(nsIFrame* aFrame1,
|
|
|
|
nsIFrame* aFrame2,
|
|
|
|
nsIFrame* aCommonAncestor = nsnull)
|
|
|
|
{
|
|
|
|
return DoCompareTreePosition(aFrame1, aFrame2, -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(nsIFrame* aFrame1,
|
|
|
|
nsIFrame* aFrame2,
|
|
|
|
PRInt32 aIf1Ancestor,
|
|
|
|
PRInt32 aIf2Ancestor,
|
|
|
|
nsIFrame* aCommonAncestor = nsnull);
|
|
|
|
|
2008-01-27 11:13:19 +03:00
|
|
|
/**
|
|
|
|
* GetLastContinuationWithChild gets the last continuation in aFrame's chain
|
|
|
|
* that has a child, or the first continuation if the frame has no children.
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetLastContinuationWithChild(nsIFrame* aFrame);
|
|
|
|
|
2003-10-15 04:49:03 +04:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
/**
|
|
|
|
* 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.
|
2008-09-04 01:35:52 +04:00
|
|
|
* @param aExtraOffset [in/out] if non-null, then as we cross documents
|
2010-07-19 06:23:47 +04:00
|
|
|
* an extra offset may be required and it will be added to aCrossDocOffset.
|
|
|
|
* Be careful dealing with this extra offset as it is in app units of the
|
|
|
|
* parent document, which may have a different app units per dev pixel ratio
|
|
|
|
* than the child document.
|
2006-01-26 05:29:17 +03:00
|
|
|
*/
|
2008-09-04 01:35:52 +04:00
|
|
|
static nsIFrame* GetCrossDocParentFrame(const nsIFrame* aFrame,
|
|
|
|
nsPoint* aCrossDocOffset = nsnull);
|
2010-04-27 20:15:01 +04:00
|
|
|
|
2003-10-15 04:49:03 +04:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsProperAncestorFrame(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
|
2003-10-15 04:49:03 +04:00
|
|
|
nsIFrame* aCommonAncestor = nsnull);
|
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
/**
|
|
|
|
* Like IsProperAncestorFrame, but looks across document boundaries.
|
2009-07-22 04:44:56 +04:00
|
|
|
*
|
|
|
|
* Just like IsAncestorFrameCrossDoc, except that it returns false when
|
|
|
|
* aFrame == aAncestorFrame.
|
2006-01-26 05:29:17 +03:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsProperAncestorFrameCrossDoc(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
|
2006-01-26 05:29:17 +03:00
|
|
|
nsIFrame* aCommonAncestor = nsnull);
|
|
|
|
|
2009-07-22 04:44:56 +04:00
|
|
|
/**
|
|
|
|
* IsAncestorFrameCrossDoc checks whether aAncestorFrame is an ancestor
|
|
|
|
* of aFrame or equal to aFrame, looking across document boundaries.
|
|
|
|
* @param aCommonAncestor nsnull, or a common ancestor of aFrame and
|
|
|
|
* aAncestorFrame. If non-null, this can bound the search and speed up
|
|
|
|
* the function.
|
|
|
|
*
|
|
|
|
* Just like IsProperAncestorFrameCrossDoc, except that it returns true when
|
|
|
|
* aFrame == aAncestorFrame.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsAncestorFrameCrossDoc(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
|
2009-07-22 04:44:56 +04:00
|
|
|
nsIFrame* aCommonAncestor = nsnull);
|
|
|
|
|
2010-07-16 01:07:51 +04:00
|
|
|
/**
|
|
|
|
* Finds the nearest ancestor frame that is the root of an "actively
|
|
|
|
* scrolled" frame subtree, or aStopAtAncestor if there is no
|
|
|
|
* such ancestor before we reach aStopAtAncestor in the ancestor chain.
|
|
|
|
* We expect frames with the same "active scrolled root" to be
|
|
|
|
* scrolled together, so we'll place them in the same ThebesLayer.
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetActiveScrolledRootFor(nsIFrame* aFrame,
|
2010-08-08 22:49:06 +04:00
|
|
|
nsIFrame* aStopAtAncestor);
|
2010-07-16 01:07:51 +04:00
|
|
|
|
2011-04-06 09:00:25 +04:00
|
|
|
static nsIFrame* GetActiveScrolledRootFor(nsDisplayItem* aItem,
|
2011-05-09 12:40:09 +04:00
|
|
|
nsDisplayListBuilder* aBuilder,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool* aShouldFixToViewport = nsnull);
|
2011-04-06 09:00:25 +04:00
|
|
|
|
2012-05-04 17:26:09 +04:00
|
|
|
static bool ScrolledByViewportScrolling(nsIFrame* aActiveScrolledRoot,
|
|
|
|
nsDisplayListBuilder* aBuilder);
|
2011-04-06 09:00:25 +04:00
|
|
|
|
2004-11-03 05:52:16 +03:00
|
|
|
/**
|
|
|
|
* GetScrollableFrameFor returns the scrollable frame for a scrolled frame
|
|
|
|
*/
|
|
|
|
static nsIScrollableFrame* GetScrollableFrameFor(nsIFrame *aScrolledFrame);
|
|
|
|
|
2004-08-06 19:55:17 +04:00
|
|
|
/**
|
2009-09-01 15:29:27 +04:00
|
|
|
* GetNearestScrollableFrameForDirection locates the first ancestor of
|
|
|
|
* aFrame (or aFrame itself) that is scrollable with overflow:scroll or
|
|
|
|
* overflow:auto in the given direction and where either the scrollbar for
|
|
|
|
* that direction is visible or the frame can be scrolled by some
|
|
|
|
* positive amount in that direction.
|
|
|
|
* The search extends across document boundaries.
|
2004-08-06 19:55:17 +04:00
|
|
|
*
|
2009-09-01 15:29:27 +04:00
|
|
|
* @param aFrame the frame to start with
|
2004-09-21 08:41:08 +04:00
|
|
|
* @param aDirection Whether it's for horizontal or vertical scrolling.
|
2009-09-01 15:29:27 +04:00
|
|
|
* @return the nearest scrollable frame or nsnull if not found
|
|
|
|
*/
|
|
|
|
enum Direction { eHorizontal, eVertical };
|
|
|
|
static nsIScrollableFrame* GetNearestScrollableFrameForDirection(nsIFrame* aFrame,
|
|
|
|
Direction aDirection);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetNearestScrollableFrame locates the first ancestor of aFrame
|
|
|
|
* (or aFrame itself) that is scrollable with overflow:scroll or
|
|
|
|
* overflow:auto in some direction.
|
|
|
|
* The search extends across document boundaries.
|
|
|
|
*
|
|
|
|
* @param aFrame the frame to start with
|
|
|
|
* @return the nearest scrollable frame or nsnull if not found
|
2004-08-06 19:55:17 +04:00
|
|
|
*/
|
2009-09-01 15:29:27 +04:00
|
|
|
static nsIScrollableFrame* GetNearestScrollableFrame(nsIFrame* aFrame);
|
2004-08-06 19:55:17 +04:00
|
|
|
|
2003-04-22 03:06:40 +04:00
|
|
|
/**
|
2011-10-17 18:59:28 +04:00
|
|
|
* HasPseudoStyle returns true if aContent (whose primary style
|
2003-04-22 03:06:40 +04:00
|
|
|
* context is aStyleContext) has the aPseudoElement pseudo-style
|
2011-10-17 18:59:28 +04:00
|
|
|
* attached to it; returns false otherwise.
|
2003-04-22 03:06:40 +04:00
|
|
|
*
|
|
|
|
* @param aContent the content node we're looking at
|
|
|
|
* @param aStyleContext aContent's style context
|
2009-12-11 10:37:40 +03:00
|
|
|
* @param aPseudoElement the id of the pseudo style we care about
|
2003-04-22 03:06:40 +04:00
|
|
|
* @param aPresContext the presentation context
|
|
|
|
* @return whether aContent has aPseudoElement style attached to it
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool HasPseudoStyle(nsIContent* aContent,
|
2003-04-22 03:06:40 +04:00
|
|
|
nsStyleContext* aStyleContext,
|
2009-12-11 10:37:40 +03:00
|
|
|
nsCSSPseudoElements::Type aPseudoElement,
|
2010-08-06 02:11:23 +04:00
|
|
|
nsPresContext* aPresContext);
|
2004-09-13 17:35:46 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* If this frame is a placeholder for a float, then return the float,
|
2009-11-17 00:00:07 +03:00
|
|
|
* otherwise return nsnull. aPlaceholder must be a placeholder frame.
|
2004-09-13 17:35:46 +04:00
|
|
|
*/
|
2009-11-17 00:00:07 +03:00
|
|
|
static nsIFrame* GetFloatFromPlaceholder(nsIFrame* aPlaceholder);
|
2004-11-25 17:51:00 +03:00
|
|
|
|
|
|
|
// 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);
|
2005-02-08 05:15:26 +03:00
|
|
|
|
2005-06-02 13:00:48 +04:00
|
|
|
/**
|
|
|
|
* 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).
|
|
|
|
*/
|
2005-08-23 07:57:07 +04:00
|
|
|
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).
|
|
|
|
*/
|
2007-06-27 04:30:21 +04:00
|
|
|
static nsPoint GetEventCoordinatesRelativeTo(const nsEvent* aEvent,
|
2005-08-23 07:57:07 +04:00
|
|
|
nsIFrame* aFrame);
|
|
|
|
|
2011-12-17 04:24:11 +04:00
|
|
|
/**
|
|
|
|
* Get the coordinates of a given point relative to an event and a
|
|
|
|
* given frame.
|
|
|
|
* @param aEvent the event
|
|
|
|
* @param aPoint the point to get the coordinates relative to
|
|
|
|
* @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(const nsEvent* aEvent,
|
|
|
|
const nsIntPoint aPoint,
|
|
|
|
nsIFrame* aFrame);
|
|
|
|
|
2009-09-10 09:16:18 +04:00
|
|
|
/**
|
2010-03-19 08:02:53 +03:00
|
|
|
* Get the popup frame of a given native mouse event.
|
2010-07-27 17:38:03 +04:00
|
|
|
* @param aPresContext only check popups within aPresContext or a descendant
|
2010-03-19 08:02:53 +03:00
|
|
|
* @param aEvent the event.
|
|
|
|
* @return Null, if there is no popup frame at the point, otherwise,
|
|
|
|
* returns top-most popup frame at the point.
|
|
|
|
*/
|
2010-07-27 17:38:03 +04:00
|
|
|
static nsIFrame* GetPopupFrameForEventCoordinates(nsPresContext* aPresContext,
|
|
|
|
const nsEvent* aEvent);
|
2010-03-19 08:02:53 +03:00
|
|
|
|
|
|
|
/**
|
2005-08-23 07:57:07 +04:00
|
|
|
* 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
|
|
|
|
*/
|
2010-04-27 20:15:01 +04:00
|
|
|
static nsPoint TranslateWidgetToView(nsPresContext* aPresContext,
|
2005-08-23 07:57:07 +04:00
|
|
|
nsIWidget* aWidget, nsIntPoint aPt,
|
|
|
|
nsIView* aView);
|
|
|
|
|
2008-09-13 13:42:11 +04:00
|
|
|
/**
|
|
|
|
* Given a matrix and a point, let T be the transformation matrix translating points
|
|
|
|
* in the coordinate space with origin aOrigin to the coordinate space used by the
|
|
|
|
* matrix. If M is the stored matrix, this function returns (T-1)MT, the matrix
|
|
|
|
* that's equivalent to aMatrix but in the coordinate space that treats aOrigin
|
|
|
|
* as the origin.
|
|
|
|
*
|
|
|
|
* @param aOrigin The origin to translate to.
|
|
|
|
* @param aMatrix The matrix to change the basis of.
|
|
|
|
* @return A matrix equivalent to aMatrix, but operating in the coordinate system with
|
|
|
|
* origin aOrigin.
|
|
|
|
*/
|
2011-08-03 07:04:23 +04:00
|
|
|
static gfx3DMatrix ChangeMatrixBasis(const gfxPoint3D &aOrigin, const gfx3DMatrix &aMatrix);
|
2008-09-13 13:42:11 +04:00
|
|
|
|
2011-01-13 20:45:14 +03:00
|
|
|
/**
|
|
|
|
* Find IDs corresponding to a scrollable content element in the child process.
|
|
|
|
* In correspondence with the shadow layer tree, you can use this to perform a
|
|
|
|
* hit test that corresponds to a specific shadow layer that you can then perform
|
|
|
|
* transformations on to do parent-side scrolling.
|
|
|
|
*
|
|
|
|
* @param aFrame The root frame of a stack context
|
|
|
|
* @param aTarget The rect to hit test relative to the frame origin
|
|
|
|
* @param aOutIDs All found IDs are added here
|
|
|
|
* @param aIgnoreRootScrollFrame a boolean to control if the display list
|
|
|
|
* builder should ignore the root scroll frame
|
|
|
|
*/
|
|
|
|
static nsresult GetRemoteContentIds(nsIFrame* aFrame,
|
|
|
|
const nsRect& aTarget,
|
|
|
|
nsTArray<ViewID> &aOutIDs,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aIgnoreRootScrollFrame);
|
2011-01-13 20:45:14 +03:00
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
/**
|
|
|
|
* 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
|
2007-08-30 00:38:44 +04:00
|
|
|
* @param aShouldIgnoreSuppression a boolean to control if the display
|
|
|
|
* list builder should ignore paint suppression or not
|
2008-11-28 22:53:33 +03:00
|
|
|
* @param aIgnoreRootScrollFrame whether or not the display list builder
|
|
|
|
* should ignore the root scroll frame.
|
2006-01-26 05:29:17 +03:00
|
|
|
*/
|
2007-08-30 00:38:44 +04:00
|
|
|
static nsIFrame* GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aShouldIgnoreSuppression = false,
|
|
|
|
bool aIgnoreRootScrollFrame = false);
|
2006-01-26 05:29:17 +03:00
|
|
|
|
2010-04-08 04:31:26 +04:00
|
|
|
/**
|
|
|
|
* Given aFrame, the root frame of a stacking context, find all descendant
|
|
|
|
* frames under the area of a rectangle that receives a mouse event,
|
|
|
|
* or nsnull if there is no such frame.
|
|
|
|
* @param aRect the rect, relative to the frame origin
|
|
|
|
* @param aOutFrames an array to add all the frames found
|
|
|
|
* @param aShouldIgnoreSuppression a boolean to control if the display
|
|
|
|
* list builder should ignore paint suppression or not
|
|
|
|
* @param aIgnoreRootScrollFrame whether or not the display list builder
|
|
|
|
* should ignore the root scroll frame.
|
|
|
|
*/
|
|
|
|
static nsresult GetFramesForArea(nsIFrame* aFrame, const nsRect& aRect,
|
|
|
|
nsTArray<nsIFrame*> &aOutFrames,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aShouldIgnoreSuppression = false,
|
|
|
|
bool aIgnoreRootScrollFrame = false);
|
2010-04-08 04:31:26 +04:00
|
|
|
|
2011-12-28 07:24:18 +04:00
|
|
|
/**
|
|
|
|
* Transform aRect relative to aAncestor down to the coordinate system of
|
|
|
|
* aFrame. Computes the bounding-box of the true quadrilateral.
|
|
|
|
*/
|
|
|
|
static nsRect TransformAncestorRectToFrame(nsIFrame* aFrame,
|
|
|
|
const nsRect& aRect,
|
|
|
|
nsIFrame* aAncestor);
|
2011-08-03 07:04:21 +04:00
|
|
|
|
2011-12-28 07:24:18 +04:00
|
|
|
/**
|
|
|
|
* Transform aRect relative to aFrame up to the coordinate system of
|
|
|
|
* aAncestor. Computes the bounding-box of the true quadrilateral.
|
|
|
|
*/
|
|
|
|
static nsRect TransformFrameRectToAncestor(nsIFrame* aFrame,
|
|
|
|
const nsRect& aRect,
|
|
|
|
nsIFrame* aAncestor);
|
2011-05-09 12:40:09 +04:00
|
|
|
|
2012-01-18 19:41:35 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the transform for aFrame relative to aAncestor. Pass null for aAncestor
|
|
|
|
* to go up to the root frame.
|
|
|
|
*/
|
|
|
|
static gfx3DMatrix GetTransformToAncestor(nsIFrame *aFrame, nsIFrame *aAncestor);
|
|
|
|
|
2008-09-13 13:42:11 +04:00
|
|
|
/**
|
|
|
|
* Given a point in the global coordinate space, returns that point expressed
|
|
|
|
* in the coordinate system of aFrame. This effectively inverts all transforms
|
|
|
|
* between this point and the root frame.
|
|
|
|
*
|
|
|
|
* @param aFrame The frame that acts as the coordinate space container.
|
|
|
|
* @param aPoint The point, in the global space, to get in the frame-local space.
|
|
|
|
* @return aPoint, expressed in aFrame's canonical coordinate space.
|
|
|
|
*/
|
2011-12-28 07:24:18 +04:00
|
|
|
static nsPoint TransformRootPointToFrame(nsIFrame* aFrame,
|
|
|
|
const nsPoint &aPt);
|
2008-09-13 13:42:11 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper function that, given a rectangle and a matrix, returns the smallest
|
|
|
|
* rectangle containing the image of the source rectangle.
|
|
|
|
*
|
|
|
|
* @param aBounds The rectangle to transform.
|
|
|
|
* @param aMatrix The matrix to transform it with.
|
|
|
|
* @param aFactor The number of app units per graphics unit.
|
|
|
|
* @return The smallest rect that contains the image of aBounds.
|
|
|
|
*/
|
|
|
|
static nsRect MatrixTransformRect(const nsRect &aBounds,
|
2011-07-23 02:28:51 +04:00
|
|
|
const gfx3DMatrix &aMatrix, float aFactor);
|
2008-09-13 13:42:11 +04:00
|
|
|
|
2011-02-25 01:55:23 +03:00
|
|
|
/**
|
|
|
|
* Helper function that, given a rectangle and a matrix, returns the smallest
|
|
|
|
* rectangle containing the image of the source rectangle rounded out to the nearest
|
|
|
|
* pixel value.
|
|
|
|
*
|
|
|
|
* @param aBounds The rectangle to transform.
|
|
|
|
* @param aMatrix The matrix to transform it with.
|
|
|
|
* @param aFactor The number of app units per graphics unit.
|
|
|
|
* @return The smallest rect that contains the image of aBounds.
|
|
|
|
*/
|
|
|
|
static nsRect MatrixTransformRectOut(const nsRect &aBounds,
|
2011-07-23 02:28:51 +04:00
|
|
|
const gfx3DMatrix &aMatrix, float aFactor);
|
2008-09-13 13:42:11 +04:00
|
|
|
/**
|
|
|
|
* Helper function that, given a point and a matrix, returns the image
|
|
|
|
* of that point under the matrix transform.
|
|
|
|
*
|
|
|
|
* @param aPoint The point to transform.
|
|
|
|
* @param aMatrix The matrix to transform it with.
|
|
|
|
* @param aFactor The number of app units per graphics unit.
|
|
|
|
* @return The image of the point under the transform.
|
|
|
|
*/
|
|
|
|
static nsPoint MatrixTransformPoint(const nsPoint &aPoint,
|
2011-07-23 02:28:51 +04:00
|
|
|
const gfx3DMatrix &aMatrix, float aFactor);
|
2008-09-13 13:42:11 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Given a graphics rectangle in graphics space, return a rectangle in
|
|
|
|
* app space that contains the graphics rectangle, rounding out as necessary.
|
|
|
|
*
|
|
|
|
* @param aRect The graphics rect to round outward.
|
|
|
|
* @param aFactor The number of app units per graphics unit.
|
|
|
|
* @return The smallest rectangle in app space that contains aRect.
|
|
|
|
*/
|
|
|
|
static nsRect RoundGfxRectToAppRect(const gfxRect &aRect, float aFactor);
|
|
|
|
|
2011-01-03 04:48:09 +03:00
|
|
|
/**
|
|
|
|
* Returns a subrectangle of aContainedRect that is entirely inside the rounded
|
|
|
|
* rect. Complex cases are handled conservatively by returning a smaller
|
|
|
|
* rect than necessary.
|
|
|
|
*/
|
|
|
|
static nsRegion RoundedRectIntersectRect(const nsRect& aRoundedRect,
|
|
|
|
const nscoord aRadii[8],
|
|
|
|
const nsRect& aContainedRect);
|
|
|
|
|
2009-09-13 02:44:18 +04:00
|
|
|
enum {
|
|
|
|
PAINT_IN_TRANSFORM = 0x01,
|
2010-03-01 11:03:49 +03:00
|
|
|
PAINT_SYNC_DECODE_IMAGES = 0x02,
|
2010-07-16 01:07:52 +04:00
|
|
|
PAINT_WIDGET_LAYERS = 0x04,
|
|
|
|
PAINT_IGNORE_SUPPRESSION = 0x08,
|
2010-09-04 00:10:46 +04:00
|
|
|
PAINT_DOCUMENT_RELATIVE = 0x10,
|
2010-08-13 17:32:04 +04:00
|
|
|
PAINT_HIDE_CARET = 0x20,
|
2010-10-15 05:03:45 +04:00
|
|
|
PAINT_ALL_CONTINUATIONS = 0x40,
|
2011-01-19 11:27:54 +03:00
|
|
|
PAINT_TO_WINDOW = 0x80,
|
|
|
|
PAINT_EXISTING_TRANSACTION = 0x100
|
2009-09-13 02:44:18 +04:00
|
|
|
};
|
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
/**
|
|
|
|
* Given aFrame, the root frame of a stacking context, paint it and its
|
2010-04-27 20:15:01 +04:00
|
|
|
* descendants to aRenderingContext.
|
2006-01-26 05:29:17 +03:00
|
|
|
* @param aRenderingContext a rendering context translated so that (0,0)
|
2008-02-25 04:39:34 +03:00
|
|
|
* is the origin of aFrame; for best results, (0,0) should transform
|
2010-03-01 11:03:49 +03:00
|
|
|
* to pixel-aligned coordinates. This can be null, in which case
|
|
|
|
* aFrame must be a "display root" (root frame for a root document,
|
|
|
|
* or the root of a popup) with an associated widget and we draw using
|
|
|
|
* the layer manager for the frame's widget.
|
2006-01-26 05:29:17 +03:00
|
|
|
* @param aDirtyRegion the region that must be painted, in the coordinates
|
|
|
|
* of aFrame
|
2009-07-04 13:30:59 +04:00
|
|
|
* @param aBackstop paint the dirty area with this color before drawing
|
2006-02-06 23:38:47 +03:00
|
|
|
* the actual content; pass NS_RGBA(0,0,0,0) to draw no background
|
2009-07-22 04:45:14 +04:00
|
|
|
* @param aFlags if PAINT_IN_TRANSFORM is set, then we assume
|
2009-09-13 02:44:18 +04:00
|
|
|
* this is inside a transform or SVG foreignObject. If
|
2010-03-01 11:03:49 +03:00
|
|
|
* PAINT_SYNC_DECODE_IMAGES is set, we force synchronous decode on all
|
|
|
|
* images. If PAINT_WIDGET_LAYERS is set, aFrame must be a display root,
|
|
|
|
* and we will use the frame's widget's layer manager to paint
|
|
|
|
* even if aRenderingContext is non-null. This is useful if you want
|
|
|
|
* to force rendering to use the widget's layer manager for testing
|
|
|
|
* or speed. PAINT_WIDGET_LAYERS must be set if aRenderingContext is null.
|
2010-09-04 00:10:46 +04:00
|
|
|
* If PAINT_DOCUMENT_RELATIVE is used, the visible region is interpreted
|
|
|
|
* as being relative to the document. (Normally it's relative to the CSS
|
2010-10-15 05:03:45 +04:00
|
|
|
* viewport.) PAINT_TO_WINDOW sets painting to window to true on the display
|
|
|
|
* list builder even if we can't tell that we are painting to the window.
|
2011-01-19 11:27:54 +03:00
|
|
|
* If PAINT_EXISTING_TRANSACTION is set, then BeginTransaction() has already
|
|
|
|
* been called on aFrame's widget's layer manager and should not be
|
|
|
|
* called again.
|
2010-04-27 20:15:01 +04:00
|
|
|
*
|
2010-03-01 11:03:49 +03:00
|
|
|
* So there are three possible behaviours:
|
|
|
|
* 1) PAINT_WIDGET_LAYERS is set and aRenderingContext is null; we paint
|
|
|
|
* by calling BeginTransaction on the widget's layer manager
|
|
|
|
* 2) PAINT_WIDGET_LAYERS is set and aRenderingContext is non-null; we
|
|
|
|
* paint by calling BeginTransactionWithTarget on the widget's layer
|
|
|
|
* maanger
|
|
|
|
* 3) PAINT_WIDGET_LAYERS is not set and aRenderingContext is non-null;
|
|
|
|
* we paint by construct a BasicLayerManager and calling
|
|
|
|
* BeginTransactionWithTarget on it. This is desirable if we're doing
|
|
|
|
* something like drawWindow in a mode where what gets rendered doesn't
|
|
|
|
* necessarily correspond to what's visible in the window; we don't
|
|
|
|
* want to mess up the widget's layer tree.
|
2006-01-26 05:29:17 +03:00
|
|
|
*/
|
2011-04-08 05:04:40 +04:00
|
|
|
static nsresult PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
|
2009-07-22 04:45:14 +04:00
|
|
|
const nsRegion& aDirtyRegion, nscolor aBackstop,
|
|
|
|
PRUint32 aFlags = 0);
|
2006-01-26 05:29:17 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2005-12-06 03:32:52 +03:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*
|
2010-04-27 20:15:01 +04:00
|
|
|
* @param "aBaseWidth" contains the width in twips of the portion
|
2005-12-06 03:32:52 +03:00
|
|
|
* 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
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool
|
2011-04-08 05:04:40 +04:00
|
|
|
BinarySearchForPosition(nsRenderingContext* acx,
|
2005-12-06 03:32:52 +03:00
|
|
|
const PRUnichar* aText,
|
|
|
|
PRInt32 aBaseWidth,
|
|
|
|
PRInt32 aBaseInx,
|
2010-04-27 20:15:01 +04:00
|
|
|
PRInt32 aStartInx,
|
|
|
|
PRInt32 aEndInx,
|
|
|
|
PRInt32 aCursorPos,
|
2005-12-06 03:32:52 +03:00
|
|
|
PRInt32& aIndex,
|
|
|
|
PRInt32& aTextWidth);
|
2005-12-13 02:53:06 +03:00
|
|
|
|
2008-09-11 04:24:16 +04:00
|
|
|
class BoxCallback {
|
|
|
|
public:
|
|
|
|
virtual void AddBox(nsIFrame* aFrame) = 0;
|
|
|
|
};
|
|
|
|
/**
|
|
|
|
* Collect all CSS boxes associated with aFrame and its
|
|
|
|
* continuations, "drilling down" through outer table frames and
|
|
|
|
* some anonymous blocks since they're not real CSS boxes.
|
|
|
|
* If aFrame is null, no boxes are returned.
|
|
|
|
* SVG frames return a single box, themselves.
|
|
|
|
*/
|
|
|
|
static void GetAllInFlowBoxes(nsIFrame* aFrame, BoxCallback* aCallback);
|
|
|
|
|
2008-02-27 12:26:15 +03:00
|
|
|
class RectCallback {
|
|
|
|
public:
|
|
|
|
virtual void AddRect(const nsRect& aRect) = 0;
|
|
|
|
};
|
2009-09-25 01:01:48 +04:00
|
|
|
|
|
|
|
struct RectAccumulator : public RectCallback {
|
2011-12-28 07:24:29 +04:00
|
|
|
nsRect mResultRect;
|
|
|
|
nsRect mFirstRect;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mSeenFirstRect;
|
2009-09-25 01:01:48 +04:00
|
|
|
|
|
|
|
RectAccumulator();
|
|
|
|
|
|
|
|
virtual void AddRect(const nsRect& aRect);
|
|
|
|
};
|
|
|
|
|
|
|
|
struct RectListBuilder : public RectCallback {
|
|
|
|
nsClientRectList* mRectList;
|
|
|
|
nsresult mRV;
|
|
|
|
|
|
|
|
RectListBuilder(nsClientRectList* aList);
|
|
|
|
virtual void AddRect(const nsRect& aRect);
|
|
|
|
};
|
|
|
|
|
|
|
|
static nsIFrame* GetContainingBlockForClientRect(nsIFrame* aFrame);
|
|
|
|
|
2011-12-28 07:24:29 +04:00
|
|
|
enum {
|
|
|
|
RECTS_ACCOUNT_FOR_TRANSFORMS = 0x01
|
|
|
|
};
|
2006-06-16 06:40:29 +04:00
|
|
|
/**
|
2008-02-27 12:26:15 +03:00
|
|
|
* Collect all CSS border-boxes associated with aFrame and its
|
|
|
|
* continuations, "drilling down" through outer table frames and
|
|
|
|
* some anonymous blocks since they're not real CSS boxes.
|
|
|
|
* The boxes are positioned relative to aRelativeTo (taking scrolling
|
|
|
|
* into account) and passed to the callback in frame-tree order.
|
|
|
|
* If aFrame is null, no boxes are returned.
|
|
|
|
* For SVG frames, returns one rectangle, the bounding box.
|
2011-12-28 07:24:29 +04:00
|
|
|
* If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting
|
|
|
|
* the boxes into aRelativeTo coordinates, transforms (including CSS
|
|
|
|
* and SVG transforms) are taken into account.
|
2006-06-16 06:40:29 +04:00
|
|
|
*/
|
2008-02-27 12:26:15 +03:00
|
|
|
static void GetAllInFlowRects(nsIFrame* aFrame, nsIFrame* aRelativeTo,
|
2011-12-28 07:24:29 +04:00
|
|
|
RectCallback* aCallback, PRUint32 aFlags = 0);
|
2008-02-27 12:26:15 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Computes the union of all rects returned by GetAllInFlowRects. If
|
|
|
|
* the union is empty, returns the first rect.
|
2011-12-28 07:24:29 +04:00
|
|
|
* If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting
|
|
|
|
* the boxes into aRelativeTo coordinates, transforms (including CSS
|
|
|
|
* and SVG transforms) are taken into account.
|
2008-02-27 12:26:15 +03:00
|
|
|
*/
|
2011-12-28 07:24:29 +04:00
|
|
|
static nsRect GetAllInFlowRectsUnion(nsIFrame* aFrame, nsIFrame* aRelativeTo,
|
|
|
|
PRUint32 aFlags = 0);
|
2006-07-06 14:43:51 +04:00
|
|
|
|
2011-01-03 04:48:09 +03:00
|
|
|
enum {
|
|
|
|
EXCLUDE_BLUR_SHADOWS = 0x01
|
|
|
|
};
|
2008-06-13 02:02:32 +04:00
|
|
|
/**
|
|
|
|
* Takes a text-shadow array from the style properties of a given nsIFrame and
|
|
|
|
* computes the union of those shadows along with the given initial rect.
|
|
|
|
* If there are no shadows, the initial rect is returned.
|
|
|
|
*/
|
|
|
|
static nsRect GetTextShadowRectsUnion(const nsRect& aTextAndDecorationsRect,
|
2011-01-03 04:48:09 +03:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
PRUint32 aFlags = 0);
|
2008-06-13 02:02:32 +04:00
|
|
|
|
2006-07-06 14:43:51 +04:00
|
|
|
/**
|
|
|
|
* Get the font metrics corresponding to the frame's style data.
|
|
|
|
* @param aFrame the frame
|
|
|
|
* @param aFontMetrics the font metrics result
|
2011-11-24 06:48:23 +04:00
|
|
|
* @param aSizeInflation number to multiply font size by
|
2006-07-06 14:43:51 +04:00
|
|
|
* @return success or failure code
|
|
|
|
*/
|
2010-08-31 22:54:44 +04:00
|
|
|
static nsresult GetFontMetricsForFrame(const nsIFrame* aFrame,
|
2011-11-24 06:48:23 +04:00
|
|
|
nsFontMetrics** aFontMetrics,
|
|
|
|
float aSizeInflation = 1.0f);
|
2006-10-19 05:47:47 +04:00
|
|
|
|
2007-08-07 23:07:43 +04:00
|
|
|
/**
|
|
|
|
* Get the font metrics corresponding to the given style data.
|
|
|
|
* @param aStyleContext the style data
|
|
|
|
* @param aFontMetrics the font metrics result
|
2011-11-24 06:48:23 +04:00
|
|
|
* @param aSizeInflation number to multiply font size by
|
2007-08-07 23:07:43 +04:00
|
|
|
* @return success or failure code
|
|
|
|
*/
|
|
|
|
static nsresult GetFontMetricsForStyleContext(nsStyleContext* aStyleContext,
|
2011-11-24 06:48:23 +04:00
|
|
|
nsFontMetrics** aFontMetrics,
|
|
|
|
float aSizeInflation = 1.0f);
|
2007-08-07 23:07:43 +04:00
|
|
|
|
2007-01-17 05:37:19 +03:00
|
|
|
/**
|
|
|
|
* Find the immediate child of aParent whose frame subtree contains
|
|
|
|
* aDescendantFrame. Returns null if aDescendantFrame is not a descendant
|
|
|
|
* of aParent.
|
|
|
|
*/
|
|
|
|
static nsIFrame* FindChildContainingDescendant(nsIFrame* aParent, nsIFrame* aDescendantFrame);
|
2010-04-27 20:15:01 +04:00
|
|
|
|
2007-01-17 05:37:19 +03:00
|
|
|
/**
|
|
|
|
* Find the nearest ancestor that's a block
|
|
|
|
*/
|
|
|
|
static nsBlockFrame* FindNearestBlockAncestor(nsIFrame* aFrame);
|
2007-12-21 06:28:18 +03:00
|
|
|
|
2008-11-26 01:15:41 +03:00
|
|
|
/**
|
|
|
|
* Find the nearest ancestor that's not for generated content. Will return
|
|
|
|
* aFrame if aFrame is not for generated content.
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetNonGeneratedAncestor(nsIFrame* aFrame);
|
|
|
|
|
2007-12-21 06:28:18 +03:00
|
|
|
/**
|
|
|
|
* Cast aFrame to an nsBlockFrame* or return null if it's not
|
|
|
|
* an nsBlockFrame.
|
|
|
|
*/
|
|
|
|
static nsBlockFrame* GetAsBlock(nsIFrame* aFrame);
|
2010-04-27 20:15:01 +04:00
|
|
|
|
2011-05-12 08:04:30 +04:00
|
|
|
/*
|
|
|
|
* Whether the frame is an nsBlockFrame which is not a wrapper block.
|
|
|
|
*/
|
|
|
|
static bool IsNonWrapperBlock(nsIFrame* aFrame) {
|
|
|
|
return GetAsBlock(aFrame) && !aFrame->IsBlockWrapper();
|
|
|
|
}
|
|
|
|
|
2006-10-19 05:47:47 +04:00
|
|
|
/**
|
|
|
|
* If aFrame is an out of flow frame, return its placeholder, otherwise
|
|
|
|
* return its parent.
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetParentOrPlaceholderFor(nsFrameManager* aFrameManager,
|
|
|
|
nsIFrame* aFrame);
|
|
|
|
|
2007-03-26 07:27:53 +04:00
|
|
|
/**
|
|
|
|
* Get a frame's next-in-flow, or, if it doesn't have one, its special sibling.
|
|
|
|
*/
|
|
|
|
static nsIFrame*
|
|
|
|
GetNextContinuationOrSpecialSibling(nsIFrame *aFrame);
|
|
|
|
|
2008-09-11 04:24:16 +04:00
|
|
|
/**
|
|
|
|
* Get the first frame in the continuation-plus-special-sibling chain
|
|
|
|
* containing aFrame.
|
|
|
|
*/
|
|
|
|
static nsIFrame*
|
|
|
|
GetFirstContinuationOrSpecialSibling(nsIFrame *aFrame);
|
2010-04-27 20:15:01 +04:00
|
|
|
|
2006-11-01 16:56:48 +03:00
|
|
|
/**
|
|
|
|
* Check whether aFrame is a part of the scrollbar or scrollcorner of
|
|
|
|
* the root content.
|
|
|
|
* @param aFrame the checking frame
|
|
|
|
* @return if TRUE, the frame is a part of the scrollbar or scrollcorner of
|
|
|
|
* the root content.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsViewportScrollbarFrame(nsIFrame* aFrame);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the contribution of aFrame to its containing block's intrinsic
|
|
|
|
* width. This considers the child's intrinsic width, its 'width',
|
|
|
|
* 'min-width', and 'max-width' properties, and its padding, border,
|
|
|
|
* and margin.
|
|
|
|
*/
|
|
|
|
enum IntrinsicWidthType { MIN_WIDTH, PREF_WIDTH };
|
2011-04-08 05:04:40 +04:00
|
|
|
static nscoord IntrinsicForContainer(nsRenderingContext* aRenderingContext,
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
IntrinsicWidthType aType);
|
|
|
|
|
2007-05-04 03:11:00 +04:00
|
|
|
/*
|
|
|
|
* Convert nsStyleCoord to nscoord when percentages depend on the
|
|
|
|
* containing block width.
|
|
|
|
*/
|
2006-12-18 16:20:18 +03:00
|
|
|
static nscoord ComputeWidthDependentValue(
|
|
|
|
nscoord aContainingBlockWidth,
|
|
|
|
const nsStyleCoord& aCoord);
|
|
|
|
|
2007-05-04 03:11:00 +04:00
|
|
|
/*
|
|
|
|
* Convert nsStyleCoord to nscoord when percentages depend on the
|
|
|
|
* containing block width, and enumerated values are for width,
|
|
|
|
* min-width, or max-width. Returns the content-box width value based
|
|
|
|
* on aContentEdgeToBoxSizing and aBoxSizingToMarginEdge (which are
|
|
|
|
* also used for the enumerated values for width. This function does
|
|
|
|
* not handle 'auto'. It ensures that the result is nonnegative.
|
|
|
|
*
|
|
|
|
* @param aRenderingContext Rendering context for font measurement/metrics.
|
|
|
|
* @param aFrame Frame whose (min-/max-/)width is being computed
|
|
|
|
* @param aContainingBlockWidth Width of aFrame's containing block.
|
|
|
|
* @param aContentEdgeToBoxSizing The sum of any left/right padding and
|
|
|
|
* border that goes inside the rect chosen by -moz-box-sizing.
|
|
|
|
* @param aBoxSizingToMarginEdge The sum of any left/right padding, border,
|
|
|
|
* and margin that goes outside the rect chosen by -moz-box-sizing.
|
|
|
|
* @param aCoord The width value to compute.
|
|
|
|
*/
|
|
|
|
static nscoord ComputeWidthValue(
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext* aRenderingContext,
|
2007-05-04 03:11:00 +04:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
nscoord aContainingBlockWidth,
|
|
|
|
nscoord aContentEdgeToBoxSizing,
|
|
|
|
nscoord aBoxSizingToMarginEdge,
|
|
|
|
const nsStyleCoord& aCoord);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert nsStyleCoord to nscoord when percentages depend on the
|
|
|
|
* containing block height.
|
|
|
|
*/
|
2006-12-18 16:20:18 +03:00
|
|
|
static nscoord ComputeHeightDependentValue(
|
|
|
|
nscoord aContainingBlockHeight,
|
|
|
|
const nsStyleCoord& aCoord);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
|
2010-08-25 14:17:55 +04:00
|
|
|
/*
|
|
|
|
* Likewise, but for 'height', 'min-height', or 'max-height'.
|
|
|
|
*/
|
|
|
|
static nscoord ComputeHeightValue(nscoord aContainingBlockHeight,
|
|
|
|
const nsStyleCoord& aCoord)
|
|
|
|
{
|
|
|
|
nscoord result =
|
|
|
|
ComputeHeightDependentValue(aContainingBlockHeight, aCoord);
|
|
|
|
if (result < 0)
|
|
|
|
result = 0; // clamp calc()
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsAutoHeight(const nsStyleCoord &aCoord, nscoord aCBHeight)
|
2010-08-25 14:17:56 +04:00
|
|
|
{
|
|
|
|
nsStyleUnit unit = aCoord.GetUnit();
|
|
|
|
return unit == eStyleUnit_Auto || // only for 'height'
|
|
|
|
unit == eStyleUnit_None || // only for 'max-height'
|
|
|
|
(aCBHeight == NS_AUTOHEIGHT && aCoord.HasPercent());
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsPaddingZero(const nsStyleCoord &aCoord)
|
2010-09-09 19:21:46 +04:00
|
|
|
{
|
|
|
|
return (aCoord.GetUnit() == eStyleUnit_Coord &&
|
|
|
|
aCoord.GetCoordValue() == 0) ||
|
|
|
|
(aCoord.GetUnit() == eStyleUnit_Percent &&
|
2011-04-08 21:59:52 +04:00
|
|
|
aCoord.GetPercentValue() == 0.0f) ||
|
2010-09-09 19:21:46 +04:00
|
|
|
(aCoord.IsCalcUnit() &&
|
|
|
|
// clamp negative calc() to 0
|
|
|
|
nsRuleNode::ComputeCoordPercentCalc(aCoord, nscoord_MAX) <= 0 &&
|
|
|
|
nsRuleNode::ComputeCoordPercentCalc(aCoord, 0) <= 0);
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsMarginZero(const nsStyleCoord &aCoord)
|
2010-08-31 20:05:12 +04:00
|
|
|
{
|
|
|
|
return (aCoord.GetUnit() == eStyleUnit_Coord &&
|
|
|
|
aCoord.GetCoordValue() == 0) ||
|
|
|
|
(aCoord.GetUnit() == eStyleUnit_Percent &&
|
2011-04-08 21:59:52 +04:00
|
|
|
aCoord.GetPercentValue() == 0.0f) ||
|
2010-08-31 20:05:12 +04:00
|
|
|
(aCoord.IsCalcUnit() &&
|
|
|
|
nsRuleNode::ComputeCoordPercentCalc(aCoord, nscoord_MAX) == 0 &&
|
|
|
|
nsRuleNode::ComputeCoordPercentCalc(aCoord, 0) == 0);
|
|
|
|
}
|
|
|
|
|
2007-11-18 15:09:03 +03:00
|
|
|
/*
|
|
|
|
* Calculate the used values for 'width' and 'height' for a replaced element.
|
|
|
|
*
|
|
|
|
* http://www.w3.org/TR/CSS21/visudet.html#min-max-widths
|
|
|
|
*/
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
static nsSize ComputeSizeWithIntrinsicDimensions(
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
|
2007-11-18 17:22:55 +03:00
|
|
|
const nsIFrame::IntrinsicSize& aIntrinsicSize,
|
2007-11-18 15:09:03 +03:00
|
|
|
nsSize aIntrinsicRatio, nsSize aCBSize,
|
2007-05-04 03:11:00 +04:00
|
|
|
nsSize aMargin, nsSize aBorder, nsSize aPadding);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
|
2011-08-05 23:24:24 +04:00
|
|
|
/*
|
|
|
|
* Calculate the used values for 'width' and 'height' when width
|
|
|
|
* and height are 'auto'. The tentWidth and tentHeight arguments should be
|
|
|
|
* the result of applying the rules for computing intrinsic sizes and ratios.
|
|
|
|
* as specified by CSS 2.1 sections 10.3.2 and 10.6.2
|
|
|
|
*/
|
|
|
|
static nsSize ComputeAutoSizeWithIntrinsicDimensions(nscoord minWidth, nscoord minHeight,
|
|
|
|
nscoord maxWidth, nscoord maxHeight,
|
|
|
|
nscoord tentWidth, nscoord tentHeight);
|
|
|
|
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
// Implement nsIFrame::GetPrefWidth in terms of nsIFrame::AddInlinePrefWidth
|
|
|
|
static nscoord PrefWidthFromInline(nsIFrame* aFrame,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext* aRenderingContext);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
|
|
|
|
// Implement nsIFrame::GetMinWidth in terms of nsIFrame::AddInlineMinWidth
|
|
|
|
static nscoord MinWidthFromInline(nsIFrame* aFrame,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext* aRenderingContext);
|
2007-01-23 05:58:55 +03:00
|
|
|
|
2011-08-09 19:14:36 +04:00
|
|
|
// Get a suitable foreground color for painting aProperty for aFrame.
|
|
|
|
static nscolor GetColor(nsIFrame* aFrame, nsCSSProperty aProperty);
|
2011-06-22 22:11:48 +04:00
|
|
|
|
2011-07-04 09:47:59 +04:00
|
|
|
// Get a baseline y position in app units that is snapped to device pixels.
|
|
|
|
static gfxFloat GetSnappedBaselineY(nsIFrame* aFrame, gfxContext* aContext,
|
|
|
|
nscoord aY, nscoord aAscent);
|
|
|
|
|
2007-01-23 05:58:55 +03:00
|
|
|
static void DrawString(const nsIFrame* aFrame,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext* aContext,
|
2007-01-23 05:58:55 +03:00
|
|
|
const PRUnichar* aString,
|
|
|
|
PRInt32 aLength,
|
2009-02-15 10:21:40 +03:00
|
|
|
nsPoint aPoint,
|
|
|
|
PRUint8 aDirection = NS_STYLE_DIRECTION_INHERIT);
|
2007-01-23 05:58:55 +03:00
|
|
|
|
|
|
|
static nscoord GetStringWidth(const nsIFrame* aFrame,
|
2011-04-08 05:04:40 +04:00
|
|
|
nsRenderingContext* aContext,
|
2007-01-23 05:58:55 +03:00
|
|
|
const PRUnichar* aString,
|
|
|
|
PRInt32 aLength);
|
2007-01-23 07:06:56 +03:00
|
|
|
|
2011-07-01 10:43:11 +04:00
|
|
|
/**
|
|
|
|
* Helper function for drawing text-shadow. The callback's job
|
|
|
|
* is to draw whatever needs to be blurred onto the given context.
|
|
|
|
*/
|
|
|
|
typedef void (* TextShadowCallback)(nsRenderingContext* aCtx,
|
|
|
|
nsPoint aShadowOffset,
|
|
|
|
const nscolor& aShadowColor,
|
|
|
|
void* aData);
|
|
|
|
|
|
|
|
static void PaintTextShadow(const nsIFrame* aFrame,
|
|
|
|
nsRenderingContext* aContext,
|
|
|
|
const nsRect& aTextRect,
|
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
const nscolor& aForegroundColor,
|
|
|
|
TextShadowCallback aCallback,
|
|
|
|
void* aCallbackData);
|
|
|
|
|
2009-05-19 02:13:12 +04:00
|
|
|
/**
|
|
|
|
* Gets the baseline to vertically center text from a font within a
|
|
|
|
* line of specified height.
|
|
|
|
*
|
|
|
|
* Returns the baseline position relative to the top of the line.
|
|
|
|
*/
|
2011-04-08 05:05:49 +04:00
|
|
|
static nscoord GetCenteredFontBaseline(nsFontMetrics* aFontMetrics,
|
2009-05-19 02:13:12 +04:00
|
|
|
nscoord aLineHeight);
|
|
|
|
|
2007-01-23 07:06:56 +03:00
|
|
|
/**
|
|
|
|
* Derive a baseline of |aFrame| (measured from its top border edge)
|
|
|
|
* from its first in-flow line box (not descending into anything with
|
|
|
|
* 'overflow' not 'visible', potentially including aFrame itself).
|
|
|
|
*
|
|
|
|
* Returns true if a baseline was found (and fills in aResult).
|
|
|
|
* Otherwise returns false.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool GetFirstLineBaseline(const nsIFrame* aFrame, nscoord* aResult);
|
2007-01-23 07:06:56 +03:00
|
|
|
|
2009-04-09 00:52:36 +04:00
|
|
|
/**
|
|
|
|
* Just like GetFirstLineBaseline, except also returns the top and
|
|
|
|
* bottom of the line with the baseline.
|
|
|
|
*
|
|
|
|
* Returns true if a line was found (and fills in aResult).
|
|
|
|
* Otherwise returns false.
|
|
|
|
*/
|
|
|
|
struct LinePosition {
|
|
|
|
nscoord mTop, mBaseline, mBottom;
|
|
|
|
|
|
|
|
LinePosition operator+(nscoord aOffset) const {
|
|
|
|
LinePosition result;
|
|
|
|
result.mTop = mTop + aOffset;
|
|
|
|
result.mBaseline = mBaseline + aOffset;
|
|
|
|
result.mBottom = mBottom + aOffset;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
};
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool GetFirstLinePosition(const nsIFrame* aFrame,
|
2009-04-09 00:52:36 +04:00
|
|
|
LinePosition* aResult);
|
|
|
|
|
|
|
|
|
2007-01-23 07:06:56 +03:00
|
|
|
/**
|
|
|
|
* Derive a baseline of |aFrame| (measured from its top border edge)
|
|
|
|
* from its last in-flow line box (not descending into anything with
|
|
|
|
* 'overflow' not 'visible', potentially including aFrame itself).
|
|
|
|
*
|
|
|
|
* Returns true if a baseline was found (and fills in aResult).
|
|
|
|
* Otherwise returns false.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool GetLastLineBaseline(const nsIFrame* aFrame, nscoord* aResult);
|
2007-02-18 13:43:12 +03:00
|
|
|
|
2008-04-18 11:40:35 +04:00
|
|
|
/**
|
|
|
|
* Returns a y coordinate relative to this frame's origin that represents
|
|
|
|
* the logical bottom of the frame or its visible content, whichever is lower.
|
|
|
|
* Relative positioning is ignored and margins and glyph bounds are not
|
|
|
|
* considered.
|
|
|
|
* This value will be >= mRect.height() and <= overflowRect.YMost() unless
|
|
|
|
* relative positioning is applied.
|
|
|
|
*/
|
|
|
|
static nscoord CalculateContentBottom(nsIFrame* aFrame);
|
|
|
|
|
2007-02-18 13:43:12 +03:00
|
|
|
/**
|
|
|
|
* Gets the closest frame (the frame passed in or one of its parents) that
|
|
|
|
* qualifies as a "layer"; used in DOM0 methods that depends upon that
|
|
|
|
* definition. This is the nearest frame that is either positioned or scrolled
|
2010-06-06 00:29:49 +04:00
|
|
|
* (the child of a scroll frame).
|
2007-02-18 13:43:12 +03:00
|
|
|
*/
|
|
|
|
static nsIFrame* GetClosestLayer(nsIFrame* aFrame);
|
2007-03-20 03:58:20 +03:00
|
|
|
|
2009-04-05 13:52:14 +04:00
|
|
|
/**
|
|
|
|
* Gets the graphics filter for the frame
|
|
|
|
*/
|
2010-10-12 00:07:59 +04:00
|
|
|
static GraphicsFilter GetGraphicsFilterForFrame(nsIFrame* aFrame);
|
2009-04-05 13:52:14 +04:00
|
|
|
|
2009-01-30 10:33:57 +03:00
|
|
|
/* N.B. The only difference between variants of the Draw*Image
|
|
|
|
* functions below is the type of the aImage argument.
|
|
|
|
*/
|
|
|
|
|
2011-01-13 13:40:12 +03:00
|
|
|
/**
|
|
|
|
* Draw a background image. The image's dimensions are as specified in aDest;
|
|
|
|
* the image itself is not consulted to determine a size.
|
|
|
|
* See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
|
|
|
|
* @param aRenderingContext Where to draw the image, set up with an
|
|
|
|
* appropriate scale and transform for drawing in
|
|
|
|
* app units.
|
|
|
|
* @param aImage The image.
|
|
|
|
* @param aImageSize The unscaled size of the image being drawn.
|
|
|
|
* (This might be the image's size if no scaling
|
|
|
|
* occurs, or it might be the image's size if
|
|
|
|
* the image is a vector image being rendered at
|
|
|
|
* that size.)
|
|
|
|
* @param aDest The position and scaled area where one copy of
|
|
|
|
* the image should be drawn.
|
|
|
|
* @param aFill The area to be filled with copies of the
|
|
|
|
* image.
|
|
|
|
* @param aAnchor A point in aFill which we will ensure is
|
|
|
|
* pixel-aligned in the output.
|
|
|
|
* @param aDirty Pixels outside this area may be skipped.
|
|
|
|
* @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
|
|
|
|
*/
|
|
|
|
static nsresult DrawBackgroundImage(nsRenderingContext* aRenderingContext,
|
|
|
|
imgIContainer* aImage,
|
|
|
|
const nsIntSize& aImageSize,
|
|
|
|
GraphicsFilter aGraphicsFilter,
|
|
|
|
const nsRect& aDest,
|
|
|
|
const nsRect& aFill,
|
|
|
|
const nsPoint& aAnchor,
|
|
|
|
const nsRect& aDirty,
|
|
|
|
PRUint32 aImageFlags);
|
|
|
|
|
2007-03-20 03:58:20 +03:00
|
|
|
/**
|
2008-11-05 01:01:21 +03:00
|
|
|
* Draw an image.
|
|
|
|
* See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
|
2007-03-20 03:58:20 +03:00
|
|
|
* @param aRenderingContext Where to draw the image, set up with an
|
|
|
|
* appropriate scale and transform for drawing in
|
2008-11-05 01:01:21 +03:00
|
|
|
* app units.
|
2007-08-22 15:13:46 +04:00
|
|
|
* @param aImage The image.
|
2008-11-05 01:01:21 +03:00
|
|
|
* @param aDest Where one copy of the image should mapped to.
|
|
|
|
* @param aFill The area to be filled with copies of the
|
|
|
|
* image.
|
|
|
|
* @param aAnchor A point in aFill which we will ensure is
|
|
|
|
* pixel-aligned in the output.
|
|
|
|
* @param aDirty Pixels outside this area may be skipped.
|
2009-09-13 02:44:18 +04:00
|
|
|
* @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
|
2007-03-20 03:58:20 +03:00
|
|
|
*/
|
2011-04-08 05:04:40 +04:00
|
|
|
static nsresult DrawImage(nsRenderingContext* aRenderingContext,
|
2008-11-05 01:01:21 +03:00
|
|
|
imgIContainer* aImage,
|
2010-10-12 00:07:59 +04:00
|
|
|
GraphicsFilter aGraphicsFilter,
|
2008-11-05 01:01:21 +03:00
|
|
|
const nsRect& aDest,
|
|
|
|
const nsRect& aFill,
|
|
|
|
const nsPoint& aAnchor,
|
2009-09-13 02:44:18 +04:00
|
|
|
const nsRect& aDirty,
|
|
|
|
PRUint32 aImageFlags);
|
2008-11-05 01:01:21 +03:00
|
|
|
|
2010-09-08 02:20:35 +04:00
|
|
|
/**
|
|
|
|
* Convert an nsRect to a gfxRect.
|
|
|
|
*/
|
|
|
|
static gfxRect RectToGfxRect(const nsRect& aRect,
|
|
|
|
PRInt32 aAppUnitsPerDevPixel);
|
|
|
|
|
2010-08-13 17:30:37 +04:00
|
|
|
/**
|
|
|
|
* Draw a drawable using the pixel snapping algorithm.
|
|
|
|
* See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
|
|
|
|
* @param aRenderingContext Where to draw the image, set up with an
|
|
|
|
* appropriate scale and transform for drawing in
|
|
|
|
* app units.
|
|
|
|
* @param aDrawable The drawable we want to draw.
|
|
|
|
* @param aFilter The graphics filter we should draw with.
|
|
|
|
* @param aDest Where one copy of the image should mapped to.
|
|
|
|
* @param aFill The area to be filled with copies of the
|
|
|
|
* image.
|
|
|
|
* @param aAnchor A point in aFill which we will ensure is
|
|
|
|
* pixel-aligned in the output.
|
|
|
|
* @param aDirty Pixels outside this area may be skipped.
|
|
|
|
*/
|
2011-04-08 05:04:40 +04:00
|
|
|
static void DrawPixelSnapped(nsRenderingContext* aRenderingContext,
|
2010-08-13 17:30:37 +04:00
|
|
|
gfxDrawable* aDrawable,
|
2010-10-12 00:07:59 +04:00
|
|
|
GraphicsFilter aFilter,
|
2010-08-13 17:30:37 +04:00
|
|
|
const nsRect& aDest,
|
|
|
|
const nsRect& aFill,
|
|
|
|
const nsPoint& aAnchor,
|
|
|
|
const nsRect& aDirty);
|
|
|
|
|
2008-11-05 01:01:21 +03:00
|
|
|
/**
|
|
|
|
* Draw a whole image without scaling or tiling.
|
|
|
|
*
|
|
|
|
* @param aRenderingContext Where to draw the image, set up with an
|
|
|
|
* appropriate scale and transform for drawing in
|
|
|
|
* app units.
|
|
|
|
* @param aImage The image.
|
|
|
|
* @param aDest The top-left where the image should be drawn
|
2010-10-12 00:08:07 +04:00
|
|
|
* @param aDirty If non-null, then pixels outside this area may
|
|
|
|
* be skipped.
|
2009-09-13 02:44:18 +04:00
|
|
|
* @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
|
2008-11-05 01:01:21 +03:00
|
|
|
* @param aSourceArea If non-null, this area is extracted from
|
|
|
|
* the image and drawn at aDest. It's
|
|
|
|
* in appunits. For best results it should
|
|
|
|
* be aligned with image pixels.
|
|
|
|
*/
|
2011-04-08 05:04:40 +04:00
|
|
|
static nsresult DrawSingleUnscaledImage(nsRenderingContext* aRenderingContext,
|
2008-11-05 01:01:21 +03:00
|
|
|
imgIContainer* aImage,
|
2010-10-12 00:08:07 +04:00
|
|
|
GraphicsFilter aGraphicsFilter,
|
2008-11-05 01:01:21 +03:00
|
|
|
const nsPoint& aDest,
|
2010-10-12 00:08:07 +04:00
|
|
|
const nsRect* aDirty,
|
2009-09-13 02:44:18 +04:00
|
|
|
PRUint32 aImageFlags,
|
2008-11-05 01:01:21 +03:00
|
|
|
const nsRect* aSourceArea = nsnull);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Draw a whole image without tiling.
|
|
|
|
*
|
|
|
|
* @param aRenderingContext Where to draw the image, set up with an
|
|
|
|
* appropriate scale and transform for drawing in
|
|
|
|
* app units.
|
|
|
|
* @param aImage The image.
|
|
|
|
* @param aDest The area that the image should fill
|
|
|
|
* @param aDirty Pixels outside this area may be skipped.
|
|
|
|
* @param aSourceArea If non-null, this area is extracted from
|
|
|
|
* the image and drawn in aDest. It's
|
|
|
|
* in appunits. For best results it should
|
|
|
|
* be aligned with image pixels.
|
2009-09-13 02:44:18 +04:00
|
|
|
* @param aImageFlags Image flags of the imgIContainer::FLAG_* variety
|
2008-11-05 01:01:21 +03:00
|
|
|
*/
|
2011-04-08 05:04:40 +04:00
|
|
|
static nsresult DrawSingleImage(nsRenderingContext* aRenderingContext,
|
2008-11-05 01:01:21 +03:00
|
|
|
imgIContainer* aImage,
|
2010-10-12 00:07:59 +04:00
|
|
|
GraphicsFilter aGraphicsFilter,
|
2008-11-05 01:01:21 +03:00
|
|
|
const nsRect& aDest,
|
|
|
|
const nsRect& aDirty,
|
2009-09-13 02:44:18 +04:00
|
|
|
PRUint32 aImageFlags,
|
2008-11-05 01:01:21 +03:00
|
|
|
const nsRect* aSourceArea = nsnull);
|
|
|
|
|
2010-09-09 00:40:39 +04:00
|
|
|
/**
|
|
|
|
* Given an imgIContainer, this method attempts to obtain an intrinsic
|
|
|
|
* px-valued height & width for it. If the imgIContainer has a non-pixel
|
|
|
|
* value for either height or width, this method tries to generate a pixel
|
2011-01-13 13:40:12 +03:00
|
|
|
* value for that dimension using the intrinsic ratio (if available). The
|
|
|
|
* intrinsic ratio will be assigned to aIntrinsicRatio; if there's no
|
|
|
|
* intrinsic ratio then (0, 0) will be assigned.
|
2010-09-09 00:40:39 +04:00
|
|
|
*
|
|
|
|
* This method will always set aGotWidth and aGotHeight to indicate whether
|
|
|
|
* we were able to successfully obtain (or compute) a value for each
|
|
|
|
* dimension.
|
|
|
|
*
|
|
|
|
* NOTE: This method is similar to ComputeSizeWithIntrinsicDimensions. The
|
|
|
|
* difference is that this one is simpler and is suited to places where we
|
|
|
|
* have less information about the frame tree.
|
|
|
|
*/
|
|
|
|
static void ComputeSizeForDrawing(imgIContainer* aImage,
|
|
|
|
nsIntSize& aImageSize,
|
2011-01-13 13:40:12 +03:00
|
|
|
nsSize& aIntrinsicRatio,
|
|
|
|
bool& aGotWidth,
|
|
|
|
bool& aGotHeight);
|
2010-09-09 00:40:39 +04:00
|
|
|
|
2008-11-05 01:01:21 +03:00
|
|
|
/**
|
|
|
|
* Given a source area of an image (in appunits) and a destination area
|
|
|
|
* that we want to map that source area too, computes the area that
|
|
|
|
* would be covered by the whole image. This is useful for passing to
|
|
|
|
* the aDest parameter of DrawImage, when we want to draw a subimage
|
|
|
|
* of an overall image.
|
|
|
|
*/
|
|
|
|
static nsRect GetWholeImageDestination(const nsIntSize& aWholeImageSize,
|
|
|
|
const nsRect& aImageSourceArea,
|
|
|
|
const nsRect& aDestArea);
|
2007-05-05 10:09:50 +04:00
|
|
|
|
|
|
|
/**
|
2008-10-01 09:50:52 +04:00
|
|
|
* Determine if any corner radius is of nonzero size
|
|
|
|
* @param aCorners the |nsStyleCorners| object to check
|
2011-10-17 18:59:28 +04:00
|
|
|
* @return true unless all the coordinates are 0%, 0 or null.
|
2008-10-01 09:50:52 +04:00
|
|
|
*
|
|
|
|
* A corner radius with one dimension zero and one nonzero is
|
|
|
|
* treated as a nonzero-radius corner, even though it will end up
|
|
|
|
* being rendered like a zero-radius corner. This is because such
|
|
|
|
* corners are not expected to appear outside of test cases, and it's
|
|
|
|
* simpler to implement the test this way.
|
2007-05-10 19:46:42 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool HasNonZeroCorner(const nsStyleCorners& aCorners);
|
2007-05-10 19:46:42 +04:00
|
|
|
|
2009-05-08 05:52:22 +04:00
|
|
|
/**
|
|
|
|
* Determine if there is any corner radius on corners adjacent to the
|
|
|
|
* given side.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
|
2010-04-27 20:15:02 +04:00
|
|
|
mozilla::css::Side aSide);
|
2009-05-08 05:52:22 +04:00
|
|
|
|
2007-05-10 19:46:42 +04:00
|
|
|
/**
|
|
|
|
* Determine if a widget is likely to require transparency or translucency.
|
2009-08-14 02:08:13 +04:00
|
|
|
* @param aBackgroundFrame The frame that the background is set on. For
|
|
|
|
* <window>s, this will be the canvas frame.
|
|
|
|
* @param aCSSRootFrame The frame that holds CSS properties affecting
|
|
|
|
* the widget's transparency. For menupopups,
|
|
|
|
* aBackgroundFrame and aCSSRootFrame will be the
|
|
|
|
* same.
|
2007-05-10 19:46:42 +04:00
|
|
|
* @return a value suitable for passing to SetWindowTranslucency
|
|
|
|
*/
|
2009-08-14 02:08:13 +04:00
|
|
|
static nsTransparencyMode GetFrameTransparency(nsIFrame* aBackgroundFrame,
|
|
|
|
nsIFrame* aCSSRootFrame);
|
2007-07-26 13:47:43 +04:00
|
|
|
|
2010-01-12 00:45:18 +03:00
|
|
|
/**
|
|
|
|
* A frame is a popup if it has its own floating window. Menus, panels
|
|
|
|
* and combobox dropdowns are popups.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsPopup(nsIFrame* aFrame);
|
2010-01-12 00:45:18 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Find the nearest "display root". This is the nearest enclosing
|
|
|
|
* popup frame or the root prescontext's root frame.
|
|
|
|
*/
|
|
|
|
static nsIFrame* GetDisplayRootFrame(nsIFrame* aFrame);
|
|
|
|
|
2007-07-26 13:47:43 +04:00
|
|
|
/**
|
|
|
|
* Get textrun construction flags determined by a given style; in particular
|
|
|
|
* some combination of:
|
|
|
|
* -- TEXT_DISABLE_OPTIONAL_LIGATURES if letter-spacing is in use
|
|
|
|
* -- TEXT_OPTIMIZE_SPEED if the text-rendering CSS property and font size
|
|
|
|
* and prefs indicate we should be optimizing for speed over quality
|
|
|
|
*/
|
|
|
|
static PRUint32 GetTextRunFlagsForStyle(nsStyleContext* aStyleContext,
|
|
|
|
const nsStyleText* aStyleText,
|
|
|
|
const nsStyleFont* aStyleFont);
|
2008-01-30 07:53:46 +03:00
|
|
|
|
2008-02-08 12:36:32 +03:00
|
|
|
/**
|
|
|
|
* Takes two rectangles whose origins must be the same, and computes
|
|
|
|
* the difference between their union and their intersection as two
|
|
|
|
* rectangles. (This difference is a superset of the difference
|
|
|
|
* between the two rectangles.)
|
|
|
|
*/
|
|
|
|
static void GetRectDifferenceStrips(const nsRect& aR1, const nsRect& aR2,
|
|
|
|
nsRect* aHStrip, nsRect* aVStrip);
|
|
|
|
|
2008-07-26 20:14:49 +04:00
|
|
|
/**
|
|
|
|
* Get a device context that can be used to get up-to-date device
|
2012-03-14 22:14:53 +04:00
|
|
|
* dimensions for the given window. For some reason, this is more
|
2008-07-26 20:14:49 +04:00
|
|
|
* complicated than it ought to be in multi-monitor situations.
|
|
|
|
*/
|
2011-04-17 05:22:44 +04:00
|
|
|
static nsDeviceContext*
|
2012-03-14 22:14:53 +04:00
|
|
|
GetDeviceContextForScreenInfo(nsPIDOMWindow* aWindow);
|
2008-07-26 20:14:49 +04:00
|
|
|
|
2008-11-26 00:27:54 +03:00
|
|
|
/**
|
|
|
|
* Some frames with 'position: fixed' (nsStylePosition::mDisplay ==
|
|
|
|
* NS_STYLE_POSITION_FIXED) are not really fixed positioned, since
|
|
|
|
* they're inside an element with -moz-transform. This function says
|
|
|
|
* whether such an element is a real fixed-pos element.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool IsReallyFixedPos(nsIFrame* aFrame);
|
2008-11-26 00:27:54 +03:00
|
|
|
|
2009-05-12 06:04:58 +04:00
|
|
|
/**
|
2009-09-18 22:00:21 +04:00
|
|
|
* Return true if aFrame is in an {ib} split and is NOT one of the
|
|
|
|
* continuations of the first inline in it.
|
2009-05-12 06:04:58 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool FrameIsNonFirstInIBSplit(const nsIFrame* aFrame) {
|
2009-05-12 06:04:58 +04:00
|
|
|
return (aFrame->GetStateBits() & NS_FRAME_IS_SPECIAL) &&
|
2009-09-18 22:00:21 +04:00
|
|
|
aFrame->GetFirstContinuation()->
|
2010-03-29 05:46:55 +04:00
|
|
|
Properties().Get(nsIFrame::IBSplitSpecialPrevSibling());
|
2009-05-12 06:04:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-09-18 22:00:21 +04:00
|
|
|
* Return true if aFrame is in an {ib} split and is NOT one of the
|
|
|
|
* continuations of the last inline in it.
|
2009-05-12 06:04:58 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool FrameIsNonLastInIBSplit(const nsIFrame* aFrame) {
|
2009-05-12 06:04:58 +04:00
|
|
|
return (aFrame->GetStateBits() & NS_FRAME_IS_SPECIAL) &&
|
2009-09-18 22:00:21 +04:00
|
|
|
aFrame->GetFirstContinuation()->
|
2010-03-29 05:46:55 +04:00
|
|
|
Properties().Get(nsIFrame::IBSplitSpecialSibling());
|
2009-05-12 06:04:58 +04:00
|
|
|
}
|
2009-06-26 00:30:56 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain a gfxASurface from the given DOM element, if possible.
|
|
|
|
* This obtains the most natural surface from the element; that
|
|
|
|
* is, the one that can be obtained with the fewest conversions.
|
|
|
|
*
|
|
|
|
* The flags below can modify the behaviour of this function. The
|
|
|
|
* result is returned as a SurfaceFromElementResult struct, also
|
|
|
|
* defined below.
|
|
|
|
*
|
|
|
|
* Currently, this will do:
|
|
|
|
* - HTML Canvas elements: will return the underlying canvas surface
|
|
|
|
* - HTML Video elements: will return the current video frame
|
|
|
|
* - Image elements: will return the image
|
|
|
|
*
|
|
|
|
* The above results are modified by the below flags (copying,
|
|
|
|
* forcing image surface, etc.).
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum {
|
|
|
|
/* Always create a new surface for the result */
|
|
|
|
SFE_WANT_NEW_SURFACE = 1 << 0,
|
|
|
|
/* When creating a new surface, create an image surface */
|
2009-09-13 02:44:18 +04:00
|
|
|
SFE_WANT_IMAGE_SURFACE = 1 << 1,
|
|
|
|
/* Whether to extract the first frame (as opposed to the
|
|
|
|
current frame) in the case that the element is an image. */
|
2011-01-13 04:45:13 +03:00
|
|
|
SFE_WANT_FIRST_FRAME = 1 << 2,
|
|
|
|
/* Whether we should skip colorspace/gamma conversion */
|
|
|
|
SFE_NO_COLORSPACE_CONVERSION = 1 << 3,
|
|
|
|
/* Whether we should skip premultiplication -- the resulting
|
|
|
|
image will always be an image surface, and must not be given to
|
|
|
|
Thebes for compositing! */
|
|
|
|
SFE_NO_PREMULTIPLY_ALPHA = 1 << 4
|
2009-06-26 00:30:56 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct SurfaceFromElementResult {
|
2011-09-10 01:58:35 +04:00
|
|
|
SurfaceFromElementResult() :
|
|
|
|
// Use safe default values here
|
2011-10-17 18:59:28 +04:00
|
|
|
mIsWriteOnly(true), mIsStillLoading(false), mCORSUsed(false) {}
|
2010-06-18 20:23:05 +04:00
|
|
|
|
2009-06-26 00:30:56 +04:00
|
|
|
/* mSurface will contain the resulting surface, or will be NULL on error */
|
|
|
|
nsRefPtr<gfxASurface> mSurface;
|
|
|
|
/* The size of the surface */
|
|
|
|
gfxIntSize mSize;
|
2011-09-21 01:00:42 +04:00
|
|
|
/* The principal associated with the element whose surface was returned.
|
|
|
|
If there is a surface, this will never be null. */
|
2009-06-26 00:30:56 +04:00
|
|
|
nsCOMPtr<nsIPrincipal> mPrincipal;
|
2011-03-24 06:13:56 +03:00
|
|
|
/* The image request, if the element is an nsIImageLoadingContent */
|
|
|
|
nsCOMPtr<imgIRequest> mImageRequest;
|
2009-06-26 00:30:56 +04:00
|
|
|
/* Whether the element was "write only", that is, the bits should not be exposed to content */
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mIsWriteOnly;
|
2010-06-18 20:23:05 +04:00
|
|
|
/* Whether the element was still loading. Some consumers need to handle
|
|
|
|
this case specially. */
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mIsStillLoading;
|
2011-09-10 01:58:35 +04:00
|
|
|
/* Whether the element used CORS when loading. */
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mCORSUsed;
|
2009-06-26 00:30:56 +04:00
|
|
|
};
|
|
|
|
|
2011-12-04 01:50:16 +04:00
|
|
|
static SurfaceFromElementResult SurfaceFromElement(mozilla::dom::Element *aElement,
|
2009-06-26 00:30:56 +04:00
|
|
|
PRUint32 aSurfaceFlags = 0);
|
2010-04-21 17:13:08 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* When the document is editable by contenteditable attribute of its root
|
|
|
|
* content or body content.
|
|
|
|
*
|
|
|
|
* Be aware, this returns NULL if it's in designMode.
|
|
|
|
*
|
|
|
|
* For example:
|
|
|
|
*
|
|
|
|
* <html contenteditable="true"><body></body></html>
|
|
|
|
* returns the <html>.
|
|
|
|
*
|
|
|
|
* <html><body contenteditable="true"></body></html>
|
|
|
|
* <body contenteditable="true"></body>
|
|
|
|
* With these cases, this returns the <body>.
|
|
|
|
* NOTE: The latter case isn't created normally, however, it can be
|
|
|
|
* created by script with XHTML.
|
|
|
|
*
|
|
|
|
* <body><p contenteditable="true"></p></body>
|
|
|
|
* returns NULL because <body> isn't editable.
|
|
|
|
*/
|
|
|
|
static nsIContent*
|
|
|
|
GetEditableRootContentByContentEditable(nsIDocument* aDocument);
|
2010-08-08 22:49:07 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns true if the passed in prescontext needs the dark grey background
|
|
|
|
* that goes behind the page of a print preview presentation.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool NeedsPrintPreviewBackground(nsPresContext* aPresContext) {
|
2010-08-08 22:49:07 +04:00
|
|
|
return aPresContext->IsRootPaginatedDocument() &&
|
|
|
|
(aPresContext->Type() == nsPresContext::eContext_PrintPreview ||
|
|
|
|
aPresContext->Type() == nsPresContext::eContext_PageLayout);
|
|
|
|
}
|
2011-01-12 04:09:21 +03:00
|
|
|
|
2011-06-16 10:31:36 +04:00
|
|
|
/**
|
|
|
|
* Adds all font faces used in the frame tree starting from aFrame
|
|
|
|
* to the list aFontFaceList.
|
|
|
|
*/
|
|
|
|
static nsresult GetFontFacesForFrames(nsIFrame* aFrame,
|
|
|
|
nsFontFaceList* aFontFaceList);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds all font faces used within the specified range of text in aFrame,
|
|
|
|
* and optionally its continuations, to the list in aFontFaceList.
|
|
|
|
* Pass 0 and PR_INT32_MAX for aStartOffset and aEndOffset to specify the
|
|
|
|
* entire text is to be considered.
|
|
|
|
*/
|
|
|
|
static nsresult GetFontFacesForText(nsIFrame* aFrame,
|
|
|
|
PRInt32 aStartOffset,
|
|
|
|
PRInt32 aEndOffset,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aFollowContinuations,
|
2011-06-16 10:31:36 +04:00
|
|
|
nsFontFaceList* aFontFaceList);
|
|
|
|
|
2011-10-14 11:06:35 +04:00
|
|
|
/**
|
|
|
|
* Walks the frame tree starting at aFrame looking for textRuns.
|
2011-11-28 07:03:14 +04:00
|
|
|
* If |clear| is true, just clears the TEXT_RUN_MEMORY_ACCOUNTED flag
|
|
|
|
* on each textRun found (and |aMallocSizeOf| is not used).
|
|
|
|
* If |clear| is false, adds the storage used for each textRun to the
|
2011-10-14 11:06:35 +04:00
|
|
|
* total, and sets the TEXT_RUN_MEMORY_ACCOUNTED flag to avoid double-
|
|
|
|
* accounting. (Runs with this flag already set will be skipped.)
|
|
|
|
* Expected usage pattern is therefore to call twice:
|
2011-11-28 07:03:14 +04:00
|
|
|
* (void)SizeOfTextRunsForFrames(rootFrame, nsnull, true);
|
|
|
|
* total = SizeOfTextRunsForFrames(rootFrame, mallocSizeOf, false);
|
2011-10-14 11:06:35 +04:00
|
|
|
*/
|
2011-11-28 07:03:14 +04:00
|
|
|
static size_t SizeOfTextRunsForFrames(nsIFrame* aFrame,
|
|
|
|
nsMallocSizeOfFun aMallocSizeOf,
|
|
|
|
bool clear);
|
2011-10-14 11:06:35 +04:00
|
|
|
|
2011-08-03 07:04:19 +04:00
|
|
|
/**
|
|
|
|
* Checks if CSS 3D transforms are currently enabled.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool Are3DTransformsEnabled();
|
2011-08-03 07:04:19 +04:00
|
|
|
|
2012-04-24 18:28:46 +04:00
|
|
|
/**
|
|
|
|
* Checks if we should forcibly use nearest pixel filtering for the
|
|
|
|
* background.
|
|
|
|
*/
|
|
|
|
static bool UseBackgroundNearestFiltering();
|
|
|
|
|
2012-05-03 18:05:55 +04:00
|
|
|
/**
|
|
|
|
* Checks whether we want to use the GPU to scale images when
|
|
|
|
* possible.
|
|
|
|
*/
|
|
|
|
static bool GPUImageScalingEnabled();
|
|
|
|
|
2011-06-16 01:03:49 +04:00
|
|
|
/**
|
|
|
|
* Unions the overflow areas of all non-popup children of aFrame with
|
|
|
|
* aOverflowAreas.
|
|
|
|
*/
|
|
|
|
static void UnionChildOverflow(nsIFrame* aFrame,
|
|
|
|
nsOverflowAreas& aOverflowAreas);
|
|
|
|
|
2011-11-24 06:48:23 +04:00
|
|
|
/**
|
|
|
|
* Return whether this is a frame whose width is used when computing
|
|
|
|
* the font size inflation of its descendants.
|
|
|
|
*/
|
2012-01-25 05:21:28 +04:00
|
|
|
static bool IsContainerForFontSizeInflation(const nsIFrame *aFrame)
|
|
|
|
{
|
|
|
|
return aFrame->GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER;
|
|
|
|
}
|
2011-11-24 06:48:23 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the font size inflation *ratio* for a given frame. This is
|
|
|
|
* the factor by which font sizes should be inflated; it is never
|
|
|
|
* smaller than 1.
|
|
|
|
*
|
2012-01-25 05:21:29 +04:00
|
|
|
* The WidthDetermination parameter says how we determine the width of
|
|
|
|
* the nearest inflation container: when not in reflow we look at the
|
|
|
|
* frame tree; when in reflow we look at state stored on the pres
|
|
|
|
* context.
|
2011-11-24 06:48:23 +04:00
|
|
|
*/
|
2012-01-25 05:21:29 +04:00
|
|
|
enum WidthDetermination { eNotInReflow, eInReflow };
|
2011-11-24 06:48:23 +04:00
|
|
|
static float FontSizeInflationFor(const nsIFrame *aFrame,
|
2012-01-25 05:21:29 +04:00
|
|
|
WidthDetermination aWidthDetermination);
|
2011-11-24 06:48:23 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Perform the first half of the computation of FontSizeInflationFor
|
|
|
|
* (see above).
|
|
|
|
* This includes determining whether inflation should be performed
|
|
|
|
* within this container and returning 0 if it should not be.
|
|
|
|
*
|
|
|
|
* The result is guaranteed not to vary between line participants
|
|
|
|
* (inlines, text frames) within a line.
|
|
|
|
*
|
|
|
|
* The result should not be used directly since font sizes slightly
|
|
|
|
* above the minimum should always be adjusted as done by
|
|
|
|
* FontSizeInflationInner.
|
|
|
|
*/
|
|
|
|
static nscoord InflationMinFontSizeFor(const nsIFrame *aFrame,
|
2012-01-25 05:21:29 +04:00
|
|
|
WidthDetermination
|
|
|
|
aWidthDetermination);
|
2011-11-24 06:48:23 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Perform the second half of the computation done by
|
|
|
|
* FontSizeInflationFor (see above).
|
|
|
|
*
|
|
|
|
* aMinFontSize must be the result of one of the
|
|
|
|
* InflationMinFontSizeFor methods above.
|
|
|
|
*/
|
|
|
|
static float FontSizeInflationInner(const nsIFrame *aFrame,
|
|
|
|
nscoord aMinFontSize);
|
|
|
|
|
|
|
|
static bool FontSizeInflationEnabled(nsPresContext *aPresContext);
|
|
|
|
|
2012-05-05 17:28:06 +04:00
|
|
|
/**
|
|
|
|
* See comment above "font.size.inflation.emPerLine" in
|
|
|
|
* modules/libpref/src/init/all.js .
|
|
|
|
*/
|
|
|
|
static PRUint32 FontSizeInflationEmPerLine() {
|
|
|
|
return sFontSizeInflationEmPerLine;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* See comment above "font.size.inflation.minTwips" in
|
|
|
|
* modules/libpref/src/init/all.js .
|
|
|
|
*/
|
|
|
|
static PRUint32 FontSizeInflationMinTwips() {
|
|
|
|
return sFontSizeInflationMinTwips;
|
|
|
|
}
|
|
|
|
|
2012-04-17 02:32:11 +04:00
|
|
|
/**
|
|
|
|
* See comment above "font.size.inflation.lineThreshold" in
|
|
|
|
* modules/libpref/src/init/all.js .
|
|
|
|
*/
|
|
|
|
static PRUint32 FontSizeInflationLineThreshold() {
|
|
|
|
return sFontSizeInflationLineThreshold;
|
|
|
|
}
|
|
|
|
|
2011-11-24 06:48:23 +04:00
|
|
|
static void Initialize();
|
2011-01-13 20:45:14 +03:00
|
|
|
static void Shutdown();
|
|
|
|
|
2011-11-10 01:39:16 +04:00
|
|
|
/**
|
|
|
|
* Register an imgIRequest object with a refresh driver.
|
|
|
|
*
|
|
|
|
* @param aPresContext The nsPresContext whose refresh driver we want to
|
|
|
|
* register with.
|
|
|
|
* @param aRequest A pointer to the imgIRequest object which the client wants
|
|
|
|
* to register with the refresh driver.
|
|
|
|
* @param aRequestRegistered A pointer to a boolean value which indicates
|
|
|
|
* whether the given image request is registered. If
|
|
|
|
* *aRequestRegistered is true, then this request will not be
|
|
|
|
* registered again. If the request is registered by this function,
|
|
|
|
* then *aRequestRegistered will be set to true upon the completion of
|
|
|
|
* this function.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void RegisterImageRequest(nsPresContext* aPresContext,
|
|
|
|
imgIRequest* aRequest,
|
|
|
|
bool* aRequestRegistered);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Register an imgIRequest object with a refresh driver, but only if the
|
|
|
|
* request is for an image that is animated.
|
|
|
|
*
|
|
|
|
* @param aPresContext The nsPresContext whose refresh driver we want to
|
|
|
|
* register with.
|
|
|
|
* @param aRequest A pointer to the imgIRequest object which the client wants
|
|
|
|
* to register with the refresh driver.
|
|
|
|
* @param aRequestRegistered A pointer to a boolean value which indicates
|
|
|
|
* whether the given image request is registered. If
|
|
|
|
* *aRequestRegistered is true, then this request will not be
|
|
|
|
* registered again. If the request is registered by this function,
|
|
|
|
* then *aRequestRegistered will be set to true upon the completion of
|
|
|
|
* this function.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void RegisterImageRequestIfAnimated(nsPresContext* aPresContext,
|
|
|
|
imgIRequest* aRequest,
|
|
|
|
bool* aRequestRegistered);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Deregister an imgIRequest object from a refresh driver.
|
|
|
|
*
|
|
|
|
* @param aPresContext The nsPresContext whose refresh driver we want to
|
|
|
|
* deregister from.
|
|
|
|
* @param aRequest A pointer to the imgIRequest object with which the client
|
|
|
|
* previously registered and now wants to deregister from the refresh
|
|
|
|
* driver.
|
|
|
|
* @param aRequestRegistered A pointer to a boolean value which indicates
|
|
|
|
* whether the given image request is registered. If
|
|
|
|
* *aRequestRegistered is false, then this request will not be
|
|
|
|
* deregistered. If the request is deregistered by this function,
|
|
|
|
* then *aRequestRegistered will be set to false upon the completion of
|
|
|
|
* this function.
|
|
|
|
*/
|
|
|
|
static void DeregisterImageRequest(nsPresContext* aPresContext,
|
|
|
|
imgIRequest* aRequest,
|
|
|
|
bool* aRequestRegistered);
|
|
|
|
|
2011-01-12 04:09:21 +03:00
|
|
|
#ifdef DEBUG
|
|
|
|
/**
|
|
|
|
* Assert that there are no duplicate continuations of the same frame
|
|
|
|
* within aFrameList. Optimize the tests by assuming that all frames
|
|
|
|
* in aFrameList have parent aContainer.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
AssertNoDuplicateContinuations(nsIFrame* aContainer,
|
|
|
|
const nsFrameList& aFrameList);
|
2011-01-12 04:09:22 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Assert that the frame tree rooted at |aSubtreeRoot| is empty, i.e.,
|
|
|
|
* that it contains no first-in-flows.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
AssertTreeOnlyEmptyNextInFlows(nsIFrame *aSubtreeRoot);
|
2011-01-12 04:09:21 +03:00
|
|
|
#endif
|
2012-04-17 02:32:11 +04:00
|
|
|
|
|
|
|
private:
|
2012-05-05 17:28:06 +04:00
|
|
|
static PRUint32 sFontSizeInflationEmPerLine;
|
|
|
|
static PRUint32 sFontSizeInflationMinTwips;
|
2012-04-17 02:32:11 +04:00
|
|
|
static PRUint32 sFontSizeInflationLineThreshold;
|
2008-01-30 07:53:46 +03:00
|
|
|
};
|
|
|
|
|
2012-01-25 05:21:29 +04:00
|
|
|
namespace mozilla {
|
|
|
|
namespace layout {
|
|
|
|
|
|
|
|
/**
|
|
|
|
* An RAII class which will, for the duration of its lifetime,
|
|
|
|
* **if** the frame given is a container for font size inflation,
|
|
|
|
* set the current inflation container on the pres context to null
|
|
|
|
* (and then, in its destructor, restore the old value).
|
|
|
|
*/
|
|
|
|
class AutoMaybeNullInflationContainer {
|
|
|
|
public:
|
|
|
|
AutoMaybeNullInflationContainer(nsIFrame *aFrame)
|
|
|
|
{
|
|
|
|
if (nsLayoutUtils::IsContainerForFontSizeInflation(aFrame)) {
|
|
|
|
mPresContext = aFrame->PresContext();
|
|
|
|
mOldValue = mPresContext->mCurrentInflationContainer;
|
|
|
|
mPresContext->mCurrentInflationContainer = nsnull;
|
|
|
|
} else {
|
|
|
|
// indicate we have nothing to restore
|
|
|
|
mPresContext = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
~AutoMaybeNullInflationContainer()
|
|
|
|
{
|
|
|
|
if (mPresContext) {
|
|
|
|
mPresContext->mCurrentInflationContainer = mOldValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
nsPresContext *mPresContext;
|
|
|
|
nsIFrame *mOldValue;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-15 03:59:21 +04:00
|
|
|
class nsSetAttrRunnable : public nsRunnable
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,
|
|
|
|
const nsAString& aValue);
|
2010-05-03 17:23:36 +04:00
|
|
|
nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,
|
|
|
|
PRInt32 aValue);
|
2008-04-15 03:59:21 +04:00
|
|
|
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> mContent;
|
|
|
|
nsCOMPtr<nsIAtom> mAttrName;
|
|
|
|
nsAutoString mValue;
|
|
|
|
};
|
|
|
|
|
|
|
|
class nsUnsetAttrRunnable : public nsRunnable
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsUnsetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName);
|
|
|
|
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> mContent;
|
|
|
|
nsCOMPtr<nsIAtom> mAttrName;
|
|
|
|
};
|
|
|
|
|
2009-01-19 12:29:48 +03:00
|
|
|
class nsReflowFrameRunnable : public nsRunnable
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsReflowFrameRunnable(nsIFrame* aFrame,
|
|
|
|
nsIPresShell::IntrinsicDirty aIntrinsicDirty,
|
|
|
|
nsFrameState aBitToAdd);
|
|
|
|
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
|
|
|
|
nsWeakFrame mWeakFrame;
|
|
|
|
nsIPresShell::IntrinsicDirty mIntrinsicDirty;
|
|
|
|
nsFrameState mBitToAdd;
|
|
|
|
};
|
|
|
|
|
2003-01-05 08:05:17 +03:00
|
|
|
#endif // nsLayoutUtils_h__
|