Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-31 22:25:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
95370d69a3
gecko-dev/layout/base/nsLayoutUtils.cpp
Phil Ringnalda a52a0f5571 Backed out 8 changesets (bug 1311244) for OOM failures in Win7 debug R1 
Backed out changeset d5411799a28f (bug 1311244)
Backed out changeset ff9c71e1dbc8 (bug 1311244)
Backed out changeset 96988ec5b81c (bug 1311244)
Backed out changeset 9d257713833a (bug 1311244)
Backed out changeset 2c33905ccb04 (bug 1311244)
Backed out changeset 20148e33d523 (bug 1311244)
Backed out changeset f36cd1532fdb (bug 1311244)
Backed out changeset 2ee4ea83a6b4 (bug 1311244)
2017-01-08 21:11:25 -08:00

9343 lines
334 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 sw=2 et tw=78: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsLayoutUtils.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/EffectCompositor.h"
#include "mozilla/EffectSet.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/gfx/gfxVars.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/layers/PAPZ.h"
#include "mozilla/Likely.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/Unused.h"
#include "nsCharTraits.h"
#include "nsDocument.h"
#include "nsFontMetrics.h"
#include "nsPresContext.h"
#include "nsIContent.h"
#include "nsIDOMHTMLDocument.h"
#include "nsIDOMHTMLElement.h"
#include "nsFrameList.h"
#include "nsGkAtoms.h"
#include "nsHtml5Atoms.h"
#include "nsIAtom.h"
#include "nsCaret.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSAnonBoxes.h"
#include "nsCSSColorUtils.h"
#include "nsView.h"
#include "nsViewManager.h"
#include "nsPlaceholderFrame.h"
#include "nsIScrollableFrame.h"
#include "nsIDOMEvent.h"
#include "nsDisplayList.h"
#include "nsRegion.h"
#include "nsFrameManager.h"
#include "nsBlockFrame.h"
#include "nsBidiPresUtils.h"
#include "imgIContainer.h"
#include "ImageOps.h"
#include "ImageRegion.h"
#include "gfxRect.h"
#include "gfxContext.h"
#include "nsRenderingContext.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsCSSRendering.h"
#include "nsTextFragment.h"
#include "nsThemeConstants.h"
#include "nsPIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIWidget.h"
#include "gfxMatrix.h"
#include "gfxPrefs.h"
#include "gfxTypes.h"
#include "nsTArray.h"
#include "mozilla/dom/HTMLCanvasElement.h"
#include "nsICanvasRenderingContextInternal.h"
#include "gfxPlatform.h"
#include <algorithm>
#include <limits>
#include "mozilla/dom/HTMLVideoElement.h"
#include "mozilla/dom/HTMLImageElement.h"
#include "mozilla/dom/DOMRect.h"
#include "mozilla/dom/DOMStringList.h"
#include "mozilla/dom/KeyframeEffectReadOnly.h"
#include "mozilla/layers/APZCCallbackHelper.h"
#include "imgIRequest.h"
#include "nsIImageLoadingContent.h"
#include "nsCOMPtr.h"
#include "nsCSSProps.h"
#include "nsListControlFrame.h"
#include "mozilla/dom/Element.h"
#include "nsCanvasFrame.h"
#include "gfxDrawable.h"
#include "gfxEnv.h"
#include "gfxUtils.h"
#include "nsDataHashtable.h"
#include "nsTableWrapperFrame.h"
#include "nsTextFrame.h"
#include "nsFontFaceList.h"
#include "nsFontInflationData.h"
#include "nsSVGUtils.h"
#include "SVGImageContext.h"
#include "SVGTextFrame.h"
#include "nsStyleStructInlines.h"
#include "nsStyleTransformMatrix.h"
#include "nsIFrameInlines.h"
#include "ImageContainer.h"
#include "nsComputedDOMStyle.h"
#include "ActiveLayerTracker.h"
#include "mozilla/gfx/2D.h"
#include "gfx2DGlue.h"
#include "mozilla/LookAndFeel.h"
#include "UnitTransforms.h"
#include "TiledLayerBuffer.h" // For TILEDLAYERBUFFER_TILE_SIZE
#include "ClientLayerManager.h"
#include "nsRefreshDriver.h"
#include "nsIContentViewer.h"
#include "LayersLogging.h"
#include "mozilla/Preferences.h"
#include "nsFrameSelection.h"
#include "FrameLayerBuilder.h"
#include "mozilla/layers/APZCTreeManager.h"
#include "mozilla/layers/CompositorBridgeChild.h"
#include "mozilla/Telemetry.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/EventStateManager.h"
#include "mozilla/RuleNodeCacheConditions.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
#include "RegionBuilder.h"
#include "SVGSVGElement.h"
#ifdef MOZ_XUL
#include "nsXULPopupManager.h"
#endif
#include "GeckoProfiler.h"
#include "nsAnimationManager.h"
#include "nsTransitionManager.h"
#include "mozilla/RestyleManagerHandle.h"
#include "mozilla/RestyleManagerHandleInlines.h"
#include "LayoutLogging.h"
// Make sure getpid() works.
#ifdef XP_WIN
#include <process.h>
#define getpid _getpid
#else
#include <unistd.h>
#endif
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::image;
using namespace mozilla::layers;
using namespace mozilla::layout;
using namespace mozilla::gfx;
#define GRID_ENABLED_PREF_NAME "layout.css.grid.enabled"
#define GRID_TEMPLATE_SUBGRID_ENABLED_PREF_NAME "layout.css.grid-template-subgrid-value.enabled"
#define WEBKIT_PREFIXES_ENABLED_PREF_NAME "layout.css.prefixes.webkit"
#define DISPLAY_FLOW_ROOT_ENABLED_PREF_NAME "layout.css.display-flow-root.enabled"
#define TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME "layout.css.text-align-unsafe-value.enabled"
#define FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME "layout.css.float-logical-values.enabled"
#define BG_CLIP_TEXT_ENABLED_PREF_NAME "layout.css.background-clip-text.enabled"
// The time in number of frames that we estimate for a refresh driver
// to be quiescent
#define DEFAULT_QUIESCENT_FRAMES 2
// The time (milliseconds) we estimate is needed between the end of an
// idle time and the next Tick.
#define DEFAULT_IDLE_PERIOD_TIME_LIMIT 1.0f
#ifdef DEBUG
// TODO: remove, see bug 598468.
bool nsLayoutUtils::gPreventAssertInCompareTreePosition = false;
#endif // DEBUG
typedef FrameMetrics::ViewID ViewID;
typedef nsStyleTransformMatrix::TransformReferenceBox TransformReferenceBox;
/* static */ uint32_t nsLayoutUtils::sFontSizeInflationEmPerLine;
/* static */ uint32_t nsLayoutUtils::sFontSizeInflationMinTwips;
/* static */ uint32_t nsLayoutUtils::sFontSizeInflationLineThreshold;
/* static */ int32_t nsLayoutUtils::sFontSizeInflationMappingIntercept;
/* static */ uint32_t nsLayoutUtils::sFontSizeInflationMaxRatio;
/* static */ bool nsLayoutUtils::sFontSizeInflationForceEnabled;
/* static */ bool nsLayoutUtils::sFontSizeInflationDisabledInMasterProcess;
/* static */ bool nsLayoutUtils::sInvalidationDebuggingIsEnabled;
/* static */ bool nsLayoutUtils::sCSSVariablesEnabled;
/* static */ bool nsLayoutUtils::sInterruptibleReflowEnabled;
/* static */ bool nsLayoutUtils::sSVGTransformBoxEnabled;
/* static */ bool nsLayoutUtils::sTextCombineUprightDigitsEnabled;
#ifdef MOZ_STYLO
/* static */ bool nsLayoutUtils::sStyloEnabled;
#endif
/* static */ uint32_t nsLayoutUtils::sIdlePeriodDeadlineLimit;
/* static */ uint32_t nsLayoutUtils::sQuiescentFramesBeforeIdlePeriod;
static ViewID sScrollIdCounter = FrameMetrics::START_SCROLL_ID;
typedef nsDataHashtable<nsUint64HashKey, nsIContent*> ContentMap;
static ContentMap* sContentMap = nullptr;
static ContentMap& GetContentMap() {
if (!sContentMap) {
sContentMap = new ContentMap();
}
return *sContentMap;
}
// When the pref "layout.css.grid.enabled" changes, this function is invoked
// to let us update kDisplayKTable, to selectively disable or restore the
// entries for "grid" and "inline-grid" in that table.
static void
GridEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
{
MOZ_ASSERT(strncmp(aPrefName, GRID_ENABLED_PREF_NAME,
ArrayLength(GRID_ENABLED_PREF_NAME)) == 0,
"We only registered this callback for a single pref, so it "
"should only be called for that pref");
static int32_t sIndexOfGridInDisplayTable;
static int32_t sIndexOfInlineGridInDisplayTable;
static bool sAreGridKeywordIndicesInitialized; // initialized to false
bool isGridEnabled =
Preferences::GetBool(GRID_ENABLED_PREF_NAME, false);
if (!sAreGridKeywordIndicesInitialized) {
// First run: find the position of "grid" and "inline-grid" in
// kDisplayKTable.
sIndexOfGridInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_grid,
nsCSSProps::kDisplayKTable);
MOZ_ASSERT(sIndexOfGridInDisplayTable >= 0,
"Couldn't find grid in kDisplayKTable");
sIndexOfInlineGridInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_grid,
nsCSSProps::kDisplayKTable);
MOZ_ASSERT(sIndexOfInlineGridInDisplayTable >= 0,
"Couldn't find inline-grid in kDisplayKTable");
sAreGridKeywordIndicesInitialized = true;
}
// OK -- now, stomp on or restore the "grid" entries in kDisplayKTable,
// depending on whether the grid pref is enabled vs. disabled.
if (sIndexOfGridInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfGridInDisplayTable].mKeyword =
isGridEnabled ? eCSSKeyword_grid : eCSSKeyword_UNKNOWN;
}
if (sIndexOfInlineGridInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfInlineGridInDisplayTable].mKeyword =
isGridEnabled ? eCSSKeyword_inline_grid : eCSSKeyword_UNKNOWN;
}
}
// When the pref "layout.css.prefixes.webkit" changes, this function is invoked
// to let us update kDisplayKTable, to selectively disable or restore the
// entries for "-webkit-box" and "-webkit-inline-box" in that table.
static void
WebkitPrefixEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
{
MOZ_ASSERT(strncmp(aPrefName, WEBKIT_PREFIXES_ENABLED_PREF_NAME,
ArrayLength(WEBKIT_PREFIXES_ENABLED_PREF_NAME)) == 0,
"We only registered this callback for a single pref, so it "
"should only be called for that pref");
static int32_t sIndexOfWebkitBoxInDisplayTable;
static int32_t sIndexOfWebkitInlineBoxInDisplayTable;
static int32_t sIndexOfWebkitFlexInDisplayTable;
static int32_t sIndexOfWebkitInlineFlexInDisplayTable;
static bool sAreKeywordIndicesInitialized; // initialized to false
bool isWebkitPrefixSupportEnabled =
Preferences::GetBool(WEBKIT_PREFIXES_ENABLED_PREF_NAME, false);
if (!sAreKeywordIndicesInitialized) {
// First run: find the position of the keywords in kDisplayKTable.
sIndexOfWebkitBoxInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_box,
nsCSSProps::kDisplayKTable);
MOZ_ASSERT(sIndexOfWebkitBoxInDisplayTable >= 0,
"Couldn't find -webkit-box in kDisplayKTable");
sIndexOfWebkitInlineBoxInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_inline_box,
nsCSSProps::kDisplayKTable);
MOZ_ASSERT(sIndexOfWebkitInlineBoxInDisplayTable >= 0,
"Couldn't find -webkit-inline-box in kDisplayKTable");
sIndexOfWebkitFlexInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_flex,
nsCSSProps::kDisplayKTable);
MOZ_ASSERT(sIndexOfWebkitFlexInDisplayTable >= 0,
"Couldn't find -webkit-flex in kDisplayKTable");
sIndexOfWebkitInlineFlexInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_inline_flex,
nsCSSProps::kDisplayKTable);
MOZ_ASSERT(sIndexOfWebkitInlineFlexInDisplayTable >= 0,
"Couldn't find -webkit-inline-flex in kDisplayKTable");
sAreKeywordIndicesInitialized = true;
}
// OK -- now, stomp on or restore the "-webkit-{box|flex}" entries in
// kDisplayKTable, depending on whether the webkit prefix pref is enabled
// vs. disabled.
if (sIndexOfWebkitBoxInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfWebkitBoxInDisplayTable].mKeyword =
isWebkitPrefixSupportEnabled ?
eCSSKeyword__webkit_box : eCSSKeyword_UNKNOWN;
}
if (sIndexOfWebkitInlineBoxInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfWebkitInlineBoxInDisplayTable].mKeyword =
isWebkitPrefixSupportEnabled ?
eCSSKeyword__webkit_inline_box : eCSSKeyword_UNKNOWN;
}
if (sIndexOfWebkitFlexInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfWebkitFlexInDisplayTable].mKeyword =
isWebkitPrefixSupportEnabled ?
eCSSKeyword__webkit_flex : eCSSKeyword_UNKNOWN;
}
if (sIndexOfWebkitInlineFlexInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfWebkitInlineFlexInDisplayTable].mKeyword =
isWebkitPrefixSupportEnabled ?
eCSSKeyword__webkit_inline_flex : eCSSKeyword_UNKNOWN;
}
}
// When the pref "layout.css.display-flow-root.enabled" changes, this function is
// invoked to let us update kDisplayKTable, to selectively disable or restore
// the entries for "flow-root" in that table.
static void
DisplayFlowRootEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
{
NS_ASSERTION(strcmp(aPrefName, DISPLAY_FLOW_ROOT_ENABLED_PREF_NAME) == 0,
"Did you misspell " DISPLAY_FLOW_ROOT_ENABLED_PREF_NAME " ?");
static bool sIsDisplayFlowRootKeywordIndexInitialized;
static int32_t sIndexOfFlowRootInDisplayTable;
bool isDisplayFlowRootEnabled =
Preferences::GetBool(DISPLAY_FLOW_ROOT_ENABLED_PREF_NAME, false);
if (!sIsDisplayFlowRootKeywordIndexInitialized) {
// First run: find the position of "flow-root" in kDisplayKTable.
sIndexOfFlowRootInDisplayTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_flow_root,
nsCSSProps::kDisplayKTable);
sIsDisplayFlowRootKeywordIndexInitialized = true;
}
// OK -- now, stomp on or restore the "flow-root" entry in kDisplayKTable,
// depending on whether the pref is enabled vs. disabled.
if (sIndexOfFlowRootInDisplayTable >= 0) {
nsCSSProps::kDisplayKTable[sIndexOfFlowRootInDisplayTable].mKeyword =
isDisplayFlowRootEnabled ? eCSSKeyword_flow_root : eCSSKeyword_UNKNOWN;
}
}
// When the pref "layout.css.text-align-unsafe-value.enabled" changes, this
// function is called to let us update kTextAlignKTable & kTextAlignLastKTable,
// to selectively disable or restore the entries for "unsafe" in those tables.
static void
TextAlignUnsafeEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
{
NS_ASSERTION(strcmp(aPrefName, TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME) == 0,
"Did you misspell " TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME " ?");
static bool sIsInitialized;
static int32_t sIndexOfUnsafeInTextAlignTable;
static int32_t sIndexOfUnsafeInTextAlignLastTable;
bool isTextAlignUnsafeEnabled =
Preferences::GetBool(TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME, false);
if (!sIsInitialized) {
// First run: find the position of "unsafe" in kTextAlignKTable.
sIndexOfUnsafeInTextAlignTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_unsafe,
nsCSSProps::kTextAlignKTable);
// First run: find the position of "unsafe" in kTextAlignLastKTable.
sIndexOfUnsafeInTextAlignLastTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_unsafe,
nsCSSProps::kTextAlignLastKTable);
sIsInitialized = true;
}
// OK -- now, stomp on or restore the "unsafe" entry in the keyword tables,
// depending on whether the pref is enabled vs. disabled.
MOZ_ASSERT(sIndexOfUnsafeInTextAlignTable >= 0);
nsCSSProps::kTextAlignKTable[sIndexOfUnsafeInTextAlignTable].mKeyword =
isTextAlignUnsafeEnabled ? eCSSKeyword_unsafe : eCSSKeyword_UNKNOWN;
MOZ_ASSERT(sIndexOfUnsafeInTextAlignLastTable >= 0);
nsCSSProps::kTextAlignLastKTable[sIndexOfUnsafeInTextAlignLastTable].mKeyword =
isTextAlignUnsafeEnabled ? eCSSKeyword_unsafe : eCSSKeyword_UNKNOWN;
}
// When the pref "layout.css.float-logical-values.enabled" changes, this
// function is called to let us update kFloatKTable & kClearKTable,
// to selectively disable or restore the entries for logical values
// (inline-start and inline-end) in those tables.
static void
FloatLogicalValuesEnabledPrefChangeCallback(const char* aPrefName,
void* aClosure)
{
NS_ASSERTION(strcmp(aPrefName, FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME) == 0,
"Did you misspell " FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME " ?");
static bool sIsInitialized;
static int32_t sIndexOfInlineStartInFloatTable;
static int32_t sIndexOfInlineEndInFloatTable;
static int32_t sIndexOfInlineStartInClearTable;
static int32_t sIndexOfInlineEndInClearTable;
bool isFloatLogicalValuesEnabled =
Preferences::GetBool(FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME, false);
if (!sIsInitialized) {
// First run: find the position of "inline-start" in kFloatKTable.
sIndexOfInlineStartInFloatTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_start,
nsCSSProps::kFloatKTable);
// First run: find the position of "inline-end" in kFloatKTable.
sIndexOfInlineEndInFloatTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_end,
nsCSSProps::kFloatKTable);
// First run: find the position of "inline-start" in kClearKTable.
sIndexOfInlineStartInClearTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_start,
nsCSSProps::kClearKTable);
// First run: find the position of "inline-end" in kClearKTable.
sIndexOfInlineEndInClearTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_end,
nsCSSProps::kClearKTable);
sIsInitialized = true;
}
// OK -- now, stomp on or restore the logical entries in the keyword tables,
// depending on whether the pref is enabled vs. disabled.
MOZ_ASSERT(sIndexOfInlineStartInFloatTable >= 0);
nsCSSProps::kFloatKTable[sIndexOfInlineStartInFloatTable].mKeyword =
isFloatLogicalValuesEnabled ? eCSSKeyword_inline_start : eCSSKeyword_UNKNOWN;
MOZ_ASSERT(sIndexOfInlineEndInFloatTable >= 0);
nsCSSProps::kFloatKTable[sIndexOfInlineEndInFloatTable].mKeyword =
isFloatLogicalValuesEnabled ? eCSSKeyword_inline_end : eCSSKeyword_UNKNOWN;
MOZ_ASSERT(sIndexOfInlineStartInClearTable >= 0);
nsCSSProps::kClearKTable[sIndexOfInlineStartInClearTable].mKeyword =
isFloatLogicalValuesEnabled ? eCSSKeyword_inline_start : eCSSKeyword_UNKNOWN;
MOZ_ASSERT(sIndexOfInlineEndInClearTable >= 0);
nsCSSProps::kClearKTable[sIndexOfInlineEndInClearTable].mKeyword =
isFloatLogicalValuesEnabled ? eCSSKeyword_inline_end : eCSSKeyword_UNKNOWN;
}
// When the pref "layout.css.background-clip-text.enabled" changes, this
// function is invoked to let us update kBackgroundClipKTable, to selectively
// disable or restore the entries for "text" in that table.
static void
BackgroundClipTextEnabledPrefChangeCallback(const char* aPrefName,
void* aClosure)
{
NS_ASSERTION(strcmp(aPrefName, BG_CLIP_TEXT_ENABLED_PREF_NAME) == 0,
"Did you misspell " BG_CLIP_TEXT_ENABLED_PREF_NAME " ?");
static bool sIsBGClipKeywordIndexInitialized;
static int32_t sIndexOfTextInBGClipTable;
bool isBGClipTextEnabled =
Preferences::GetBool(BG_CLIP_TEXT_ENABLED_PREF_NAME, false);
if (!sIsBGClipKeywordIndexInitialized) {
// First run: find the position of "text" in kBackgroundClipKTable.
sIndexOfTextInBGClipTable =
nsCSSProps::FindIndexOfKeyword(eCSSKeyword_text,
nsCSSProps::kBackgroundClipKTable);
sIsBGClipKeywordIndexInitialized = true;
}
// OK -- now, stomp on or restore the "text" entry in kBackgroundClipKTable,
// depending on whether the pref is enabled vs. disabled.
if (sIndexOfTextInBGClipTable >= 0) {
nsCSSProps::kBackgroundClipKTable[sIndexOfTextInBGClipTable].mKeyword =
isBGClipTextEnabled ? eCSSKeyword_text : eCSSKeyword_UNKNOWN;
}
}
template<typename TestType>
static bool
HasMatchingAnimations(const nsIFrame* aFrame, TestType&& aTest)
{
EffectSet* effects = EffectSet::GetEffectSet(aFrame);
if (!effects) {
return false;
}
for (KeyframeEffectReadOnly* effect : *effects) {
if (aTest(*effect)) {
return true;
}
}
return false;
}
bool
nsLayoutUtils::HasCurrentTransitions(const nsIFrame* aFrame)
{
return HasMatchingAnimations(aFrame,
[](KeyframeEffectReadOnly& aEffect)
{
// Since |aEffect| is current, it must have an associated Animation
// so we don't need to null-check the result of GetAnimation().
return aEffect.IsCurrent() && aEffect.GetAnimation()->AsCSSTransition();
}
);
}
bool
nsLayoutUtils::HasAnimationOfProperty(const nsIFrame* aFrame,
nsCSSPropertyID aProperty)
{
return HasMatchingAnimations(aFrame,
[&aProperty](KeyframeEffectReadOnly& aEffect)
{
return (aEffect.IsInEffect() || aEffect.IsCurrent()) &&
aEffect.HasAnimationOfProperty(aProperty);
}
);
}
bool
nsLayoutUtils::HasEffectiveAnimation(const nsIFrame* aFrame,
nsCSSPropertyID aProperty)
{
return HasMatchingAnimations(aFrame,
[&aProperty](KeyframeEffectReadOnly& aEffect)
{
return (aEffect.IsInEffect() || aEffect.IsCurrent()) &&
aEffect.HasEffectiveAnimationOfProperty(aProperty);
}
);
}
static float
GetSuitableScale(float aMaxScale, float aMinScale,
nscoord aVisibleDimension, nscoord aDisplayDimension)
{
float displayVisibleRatio = float(aDisplayDimension) /
float(aVisibleDimension);
// We want to rasterize based on the largest scale used during the
// transform animation, unless that would make us rasterize something
// larger than the screen. But we never want to go smaller than the
// minimum scale over the animation.
if (FuzzyEqualsMultiplicative(displayVisibleRatio, aMaxScale, .01f)) {
// Using aMaxScale may make us rasterize something a fraction larger than
// the screen. However, if aMaxScale happens to be the final scale of a
// transform animation it is better to use aMaxScale so that for the
// fraction of a second before we delayerize the composited texture it has
// a better chance of being pixel aligned and composited without resampling
// (avoiding visually clunky delayerization).
return aMaxScale;
}
return std::max(std::min(aMaxScale, displayVisibleRatio), aMinScale);
}
static inline void
UpdateMinMaxScale(const nsIFrame* aFrame,
const StyleAnimationValue& aValue,
gfxSize& aMinScale,
gfxSize& aMaxScale)
{
gfxSize size = aValue.GetScaleValue(aFrame);
aMaxScale.width = std::max<float>(aMaxScale.width, size.width);
aMaxScale.height = std::max<float>(aMaxScale.height, size.height);
aMinScale.width = std::min<float>(aMinScale.width, size.width);
aMinScale.height = std::min<float>(aMinScale.height, size.height);
}
static void
GetMinAndMaxScaleForAnimationProperty(const nsIFrame* aFrame,
nsTArray<RefPtr<dom::Animation>>&
aAnimations,
gfxSize& aMaxScale,
gfxSize& aMinScale)
{
for (dom::Animation* anim : aAnimations) {
// This method is only expected to be passed animations that are running on
// the compositor and we only pass playing animations to the compositor,
// which are, by definition, "relevant" animations (animations that are
// not yet finished or which are filling forwards).
MOZ_ASSERT(anim->IsRelevant());
dom::KeyframeEffectReadOnly* effect =
anim->GetEffect() ? anim->GetEffect()->AsKeyframeEffect() : nullptr;
MOZ_ASSERT(effect, "A playing animation should have a keyframe effect");
for (size_t propIdx = effect->Properties().Length(); propIdx-- != 0; ) {
const AnimationProperty& prop = effect->Properties()[propIdx];
if (prop.mProperty != eCSSProperty_transform) {
continue;
}
// We need to factor in the scale of the base style if the base style
// will be used on the compositor.
if (effect->NeedsBaseStyle(prop.mProperty)) {
StyleAnimationValue baseStyle =
EffectCompositor::GetBaseStyle(prop.mProperty, aFrame);
MOZ_ASSERT(!baseStyle.IsNull(), "The base value should be set");
UpdateMinMaxScale(aFrame, baseStyle, aMinScale, aMaxScale);
}
for (const AnimationPropertySegment& segment : prop.mSegments) {
// In case of add or accumulate composite, StyleAnimationValue does
// not have a valid value.
if (segment.mFromComposite == dom::CompositeOperation::Replace) {
UpdateMinMaxScale(aFrame, segment.mFromValue, aMinScale, aMaxScale);
}
if (segment.mToComposite == dom::CompositeOperation::Replace) {
UpdateMinMaxScale(aFrame, segment.mToValue, aMinScale, aMaxScale);
}
}
}
}
}
gfxSize
nsLayoutUtils::ComputeSuitableScaleForAnimation(const nsIFrame* aFrame,
const nsSize& aVisibleSize,
const nsSize& aDisplaySize)
{
gfxSize maxScale(std::numeric_limits<gfxFloat>::min(),
std::numeric_limits<gfxFloat>::min());
gfxSize minScale(std::numeric_limits<gfxFloat>::max(),
std::numeric_limits<gfxFloat>::max());
nsTArray<RefPtr<dom::Animation>> compositorAnimations =
EffectCompositor::GetAnimationsForCompositor(aFrame,
eCSSProperty_transform);
GetMinAndMaxScaleForAnimationProperty(aFrame, compositorAnimations,
maxScale, minScale);
if (maxScale.width == std::numeric_limits<gfxFloat>::min()) {
// We didn't encounter a transform
return gfxSize(1.0, 1.0);
}
return gfxSize(GetSuitableScale(maxScale.width, minScale.width,
aVisibleSize.width, aDisplaySize.width),
GetSuitableScale(maxScale.height, minScale.height,
aVisibleSize.height, aDisplaySize.height));
}
bool
nsLayoutUtils::AreAsyncAnimationsEnabled()
{
static bool sAreAsyncAnimationsEnabled;
static bool sAsyncPrefCached = false;
if (!sAsyncPrefCached) {
sAsyncPrefCached = true;
Preferences::AddBoolVarCache(&sAreAsyncAnimationsEnabled,
"layers.offmainthreadcomposition.async-animations");
}
return sAreAsyncAnimationsEnabled &&
gfxPlatform::OffMainThreadCompositingEnabled();
}
bool
nsLayoutUtils::IsAnimationLoggingEnabled()
{
static bool sShouldLog;
static bool sShouldLogPrefCached;
if (!sShouldLogPrefCached) {
sShouldLogPrefCached = true;
Preferences::AddBoolVarCache(&sShouldLog,
"layers.offmainthreadcomposition.log-animations");
}
return sShouldLog;
}
bool
nsLayoutUtils::GPUImageScalingEnabled()
{
static bool sGPUImageScalingEnabled;
static bool sGPUImageScalingPrefInitialised = false;
if (!sGPUImageScalingPrefInitialised) {
sGPUImageScalingPrefInitialised = true;
sGPUImageScalingEnabled =
Preferences::GetBool("layout.gpu-image-scaling.enabled", false);
}
return sGPUImageScalingEnabled;
}
bool
nsLayoutUtils::AnimatedImageLayersEnabled()
{
static bool sAnimatedImageLayersEnabled;
static bool sAnimatedImageLayersPrefCached = false;
if (!sAnimatedImageLayersPrefCached) {
sAnimatedImageLayersPrefCached = true;
Preferences::AddBoolVarCache(&sAnimatedImageLayersEnabled,
"layout.animated-image-layers.enabled",
false);
}
return sAnimatedImageLayersEnabled;
}
bool
nsLayoutUtils::CSSFiltersEnabled()
{
static bool sCSSFiltersEnabled;
static bool sCSSFiltersPrefCached = false;
if (!sCSSFiltersPrefCached) {
sCSSFiltersPrefCached = true;
Preferences::AddBoolVarCache(&sCSSFiltersEnabled,
"layout.css.filters.enabled",
false);
}
return sCSSFiltersEnabled;
}
bool
nsLayoutUtils::CSSClipPathShapesEnabled()
{
static bool sCSSClipPathShapesEnabled;
static bool sCSSClipPathShapesPrefCached = false;
if (!sCSSClipPathShapesPrefCached) {
sCSSClipPathShapesPrefCached = true;
Preferences::AddBoolVarCache(&sCSSClipPathShapesEnabled,
"layout.css.clip-path-shapes.enabled",
false);
}
return sCSSClipPathShapesEnabled;
}
bool
nsLayoutUtils::UnsetValueEnabled()
{
static bool sUnsetValueEnabled;
static bool sUnsetValuePrefCached = false;
if (!sUnsetValuePrefCached) {
sUnsetValuePrefCached = true;
Preferences::AddBoolVarCache(&sUnsetValueEnabled,
"layout.css.unset-value.enabled",
false);
}
return sUnsetValueEnabled;
}
bool
nsLayoutUtils::IsGridTemplateSubgridValueEnabled()
{
static bool sGridTemplateSubgridValueEnabled;
static bool sGridTemplateSubgridValueEnabledPrefCached = false;
if (!sGridTemplateSubgridValueEnabledPrefCached) {
sGridTemplateSubgridValueEnabledPrefCached = true;
Preferences::AddBoolVarCache(&sGridTemplateSubgridValueEnabled,
GRID_TEMPLATE_SUBGRID_ENABLED_PREF_NAME,
false);
}
return sGridTemplateSubgridValueEnabled;
}
bool
nsLayoutUtils::IsTextAlignUnsafeValueEnabled()
{
static bool sTextAlignUnsafeValueEnabled;
static bool sTextAlignUnsafeValueEnabledPrefCached = false;
if (!sTextAlignUnsafeValueEnabledPrefCached) {
sTextAlignUnsafeValueEnabledPrefCached = true;
Preferences::AddBoolVarCache(&sTextAlignUnsafeValueEnabled,
TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME,
false);
}
return sTextAlignUnsafeValueEnabled;
}
void
nsLayoutUtils::UnionChildOverflow(nsIFrame* aFrame,
nsOverflowAreas& aOverflowAreas,
FrameChildListIDs aSkipChildLists)
{
// Iterate over all children except pop-ups.
FrameChildListIDs skip = aSkipChildLists |
nsIFrame::kSelectPopupList | nsIFrame::kPopupList;
for (nsIFrame::ChildListIterator childLists(aFrame);
!childLists.IsDone(); childLists.Next()) {
if (skip.Contains(childLists.CurrentID())) {
continue;
}
nsFrameList children = childLists.CurrentList();
for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
nsIFrame* child = e.get();
nsOverflowAreas childOverflow =
child->GetOverflowAreas() + child->GetPosition();
aOverflowAreas.UnionWith(childOverflow);
}
}
}
static void DestroyViewID(void* aObject, nsIAtom* aPropertyName,
void* aPropertyValue, void* aData)
{
ViewID* id = static_cast<ViewID*>(aPropertyValue);
GetContentMap().Remove(*id);
delete id;
}
/**
* A namespace class for static layout utilities.
*/
bool
nsLayoutUtils::FindIDFor(const nsIContent* aContent, ViewID* aOutViewId)
{
void* scrollIdProperty = aContent->GetProperty(nsGkAtoms::RemoteId);
if (scrollIdProperty) {
*aOutViewId = *static_cast<ViewID*>(scrollIdProperty);
return true;
}
return false;
}
ViewID
nsLayoutUtils::FindOrCreateIDFor(nsIContent* aContent)
{
ViewID scrollId;
if (!FindIDFor(aContent, &scrollId)) {
scrollId = sScrollIdCounter++;
aContent->SetProperty(nsGkAtoms::RemoteId, new ViewID(scrollId),
DestroyViewID);
GetContentMap().Put(scrollId, aContent);
}
return scrollId;
}
nsIContent*
nsLayoutUtils::FindContentFor(ViewID aId)
{
MOZ_ASSERT(aId != FrameMetrics::NULL_SCROLL_ID,
"Cannot find a content element in map for null IDs.");
nsIContent* content;
bool exists = GetContentMap().Get(aId, &content);
if (exists) {
return content;
} else {
return nullptr;
}
}
nsIFrame*
GetScrollFrameFromContent(nsIContent* aContent)
{
nsIFrame* frame = aContent->GetPrimaryFrame();
if (aContent->OwnerDoc()->GetRootElement() == aContent) {
nsIPresShell* presShell = frame ? frame->PresContext()->PresShell() : nullptr;
if (!presShell) {
presShell = aContent->OwnerDoc()->GetShell();
}
// We want the scroll frame, the root scroll frame differs from all
// others in that the primary frame is not the scroll frame.
nsIFrame* rootScrollFrame = presShell ? presShell->GetRootScrollFrame() : nullptr;
if (rootScrollFrame) {
frame = rootScrollFrame;
}
}
return frame;
}
nsIScrollableFrame*
nsLayoutUtils::FindScrollableFrameFor(ViewID aId)
{
nsIContent* content = FindContentFor(aId);
if (!content) {
return nullptr;
}
nsIFrame* scrollFrame = GetScrollFrameFromContent(content);
return scrollFrame ? scrollFrame->GetScrollTargetFrame() : nullptr;
}
static nsRect
ApplyRectMultiplier(nsRect aRect, float aMultiplier)
{
if (aMultiplier == 1.0f) {
return aRect;
}
float newWidth = aRect.width * aMultiplier;
float newHeight = aRect.height * aMultiplier;
float newX = aRect.x - ((newWidth - aRect.width) / 2.0f);
float newY = aRect.y - ((newHeight - aRect.height) / 2.0f);
// Rounding doesn't matter too much here, do a round-in
return nsRect(ceil(newX), ceil(newY), floor(newWidth), floor(newHeight));
}
bool
nsLayoutUtils::UsesAsyncScrolling(nsIFrame* aFrame)
{
#ifdef MOZ_WIDGET_ANDROID
// We always have async scrolling for android
return true;
#endif
return AsyncPanZoomEnabled(aFrame);
}
bool
nsLayoutUtils::AsyncPanZoomEnabled(nsIFrame* aFrame)
{
// We use this as a shortcut, since if the compositor will never use APZ,
// no widget will either.
if (!gfxPlatform::AsyncPanZoomEnabled()) {
return false;
}
nsIFrame *frame = nsLayoutUtils::GetDisplayRootFrame(aFrame);
nsIWidget* widget = frame->GetNearestWidget();
if (!widget) {
return false;
}
return widget->AsyncPanZoomEnabled();
}
float
nsLayoutUtils::GetCurrentAPZResolutionScale(nsIPresShell* aShell) {
return aShell ? aShell->GetCumulativeNonRootScaleResolution() : 1.0;
}
// Return the maximum displayport size, based on the LayerManager's maximum
// supported texture size. The result is in app units.
static nscoord
GetMaxDisplayPortSize(nsIContent* aContent)
{
MOZ_ASSERT(!gfxPrefs::LayersTilesEnabled(), "Do not clamp displayports if tiling is enabled");
nsIFrame* frame = aContent->GetPrimaryFrame();
if (!frame) {
return nscoord_MAX;
}
frame = nsLayoutUtils::GetDisplayRootFrame(frame);
nsIWidget* widget = frame->GetNearestWidget();
if (!widget) {
return nscoord_MAX;
}
LayerManager* lm = widget->GetLayerManager();
if (!lm) {
return nscoord_MAX;
}
nsPresContext* presContext = frame->PresContext();
int32_t maxSizeInDevPixels = lm->GetMaxTextureSize();
if (maxSizeInDevPixels < 0 || maxSizeInDevPixels == INT_MAX) {
return nscoord_MAX;
}
return presContext->DevPixelsToAppUnits(maxSizeInDevPixels);
}
static nsRect
GetDisplayPortFromRectData(nsIContent* aContent,
DisplayPortPropertyData* aRectData,
float aMultiplier)
{
// In the case where the displayport is set as a rect, we assume it is
// already aligned and clamped as necessary. The burden to do that is
// on the setter of the displayport. In practice very few places set the
// displayport directly as a rect (mostly tests). We still do need to
// expand it by the multiplier though.
return ApplyRectMultiplier(aRectData->mRect, aMultiplier);
}
static nsRect
GetDisplayPortFromMarginsData(nsIContent* aContent,
DisplayPortMarginsPropertyData* aMarginsData,
float aMultiplier)
{
// In the case where the displayport is set via margins, we apply the margins
// to a base rect. Then we align the expanded rect based on the alignment
// requested, further expand the rect by the multiplier, and finally, clamp it
// to the size of the scrollable rect.
nsRect base;
if (nsRect* baseData = static_cast<nsRect*>(aContent->GetProperty(nsGkAtoms::DisplayPortBase))) {
base = *baseData;
} else {
// In theory we shouldn't get here, but we do sometimes (see bug 1212136).
// Fall through for graceful handling.
}
nsIFrame* frame = GetScrollFrameFromContent(aContent);
if (!frame) {
// Turns out we can't really compute it. Oops. We still should return
// something sane. Note that since we can't clamp the rect without a
// frame, we don't apply the multiplier either as it can cause the result
// to leak outside the scrollable area.
NS_WARNING("Attempting to get a displayport from a content with no primary frame!");
return base;
}
bool isRoot = false;
if (aContent->OwnerDoc()->GetRootElement() == aContent) {
isRoot = true;
}
nsPoint scrollPos;
if (nsIScrollableFrame* scrollableFrame = frame->GetScrollTargetFrame()) {
scrollPos = scrollableFrame->GetScrollPosition();
}
nsPresContext* presContext = frame->PresContext();
int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
LayoutDeviceToScreenScale2D res(presContext->PresShell()->GetCumulativeResolution()
* nsLayoutUtils::GetTransformToAncestorScale(frame));
// Calculate the expanded scrollable rect, which we'll be clamping the
// displayport to.
nsRect expandedScrollableRect =
nsLayoutUtils::CalculateExpandedScrollableRect(frame);
// GetTransformToAncestorScale() can return 0. In this case, just return the
// base rect (clamped to the expanded scrollable rect), as other calculations
// would run into divisions by zero.
if (res == LayoutDeviceToScreenScale2D(0, 0)) {
// Make sure the displayport remains within the scrollable rect.
return base.MoveInsideAndClamp(expandedScrollableRect - scrollPos);
}
// First convert the base rect to screen pixels
LayoutDeviceToScreenScale2D parentRes = res;
if (isRoot) {
// the base rect for root scroll frames is specified in the parent document
// coordinate space, so it doesn't include the local resolution.
float localRes = presContext->PresShell()->GetResolution();
parentRes.xScale /= localRes;
parentRes.yScale /= localRes;
}
ScreenRect screenRect = LayoutDeviceRect::FromAppUnits(base, auPerDevPixel)
* parentRes;
// Note on the correctness of applying the alignment in Screen space:
// The correct space to apply the alignment in would be Layer space, but
// we don't necessarily know the scale to convert to Layer space at this
// point because Layout may not yet have chosen the resolution at which to
// render (it chooses that in FrameLayerBuilder, but this can be called
// during display list building). Therefore, we perform the alignment in
// Screen space, which basically assumes that Layout chose to render at
// screen resolution; since this is what Layout does most of the time,
// this is a good approximation. A proper solution would involve moving
// the choosing of the resolution to display-list building time.
ScreenSize alignment;
if (APZCCallbackHelper::IsDisplayportSuppressed()) {
alignment = ScreenSize(1, 1);
} else if (gfxPrefs::LayersTilesEnabled()) {
// Don't align to tiles if they are too large, because we could expand
// the displayport by a lot which can take more paint time. It's a tradeoff
// though because if we don't align to tiles we have more waste on upload.
IntSize tileSize = gfxVars::TileSize();
alignment = ScreenSize(std::min(256, tileSize.width), std::min(256, tileSize.height));
} else {
// If we're not drawing with tiles then we need to be careful about not
// hitting the max texture size and we only need 1 draw call per layer
// so we can align to a smaller multiple.
alignment = ScreenSize(128, 128);
}
// Avoid division by zero.
if (alignment.width == 0) {
alignment.width = 128;
}
if (alignment.height == 0) {
alignment.height = 128;
}
if (gfxPrefs::LayersTilesEnabled()) {
// Expand the rect by the margins
screenRect.Inflate(aMarginsData->mMargins);
} else {
// Calculate the displayport to make sure we fit within the max texture size
// when not tiling.
nscoord maxSizeAppUnits = GetMaxDisplayPortSize(aContent);
if (maxSizeAppUnits == nscoord_MAX) {
// Pick a safe maximum displayport size for sanity purposes. This is the
// lowest maximum texture size on tileless-platforms (Windows, D3D10).
maxSizeAppUnits = presContext->DevPixelsToAppUnits(8192);
}
// The alignment code can round up to 3 tiles, we want to make sure
// that the displayport can grow by up to 3 tiles without going
// over the max texture size.
const int MAX_ALIGN_ROUNDING = 3;
// Find the maximum size in screen pixels.
int32_t maxSizeDevPx = presContext->AppUnitsToDevPixels(maxSizeAppUnits);
int32_t maxWidthScreenPx = floor(double(maxSizeDevPx) * res.xScale) -
MAX_ALIGN_ROUNDING * alignment.width;
int32_t maxHeightScreenPx = floor(double(maxSizeDevPx) * res.yScale) -
MAX_ALIGN_ROUNDING * alignment.height;
// For each axis, inflate the margins up to the maximum size.
const ScreenMargin& margins = aMarginsData->mMargins;
if (screenRect.height < maxHeightScreenPx) {
int32_t budget = maxHeightScreenPx - screenRect.height;
// Scale the margins down to fit into the budget if necessary, maintaining
// their relative ratio.
float scale = std::min(1.0f, float(budget) / margins.TopBottom());
float top = margins.top * scale;
float bottom = margins.bottom * scale;
screenRect.y -= top;
screenRect.height += top + bottom;
}
if (screenRect.width < maxWidthScreenPx) {
int32_t budget = maxWidthScreenPx - screenRect.width;
float scale = std::min(1.0f, float(budget) / margins.LeftRight());
float left = margins.left * scale;
float right = margins.right * scale;
screenRect.x -= left;
screenRect.width += left + right;
}
}
ScreenPoint scrollPosScreen = LayoutDevicePoint::FromAppUnits(scrollPos, auPerDevPixel)
* res;
// Round-out the display port to the nearest alignment (tiles)
screenRect += scrollPosScreen;
float x = alignment.width * floor(screenRect.x / alignment.width);
float y = alignment.height * floor(screenRect.y / alignment.height);
float w = alignment.width * ceil(screenRect.width / alignment.width + 1);
float h = alignment.height * ceil(screenRect.height / alignment.height + 1);
screenRect = ScreenRect(x, y, w, h);
screenRect -= scrollPosScreen;
// Convert the aligned rect back into app units.
nsRect result = LayoutDeviceRect::ToAppUnits(screenRect / res, auPerDevPixel);
// If we have non-zero margins, expand the displayport for the low-res buffer
// if that's what we're drawing. If we have zero margins, we want the
// displayport to reflect the scrollport.
if (aMarginsData->mMargins != ScreenMargin()) {
result = ApplyRectMultiplier(result, aMultiplier);
}
// Make sure the displayport remains within the scrollable rect.
result = result.MoveInsideAndClamp(expandedScrollableRect - scrollPos);
return result;
}
static bool
ShouldDisableApzForElement(nsIContent* aContent)
{
if (gfxPrefs::APZDisableForScrollLinkedEffects() && aContent) {
nsIDocument* doc = aContent->GetComposedDoc();
return (doc && doc->HasScrollLinkedEffect());
}
return false;
}
static bool
GetDisplayPortImpl(nsIContent* aContent, nsRect *aResult, float aMultiplier)
{
DisplayPortPropertyData* rectData =
static_cast<DisplayPortPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPort));
DisplayPortMarginsPropertyData* marginsData =
static_cast<DisplayPortMarginsPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
if (!rectData && !marginsData) {
// This content element has no displayport data at all
return false;
}
if (!aResult) {
// We have displayport data, but the caller doesn't want the actual
// rect, so we don't need to actually compute it.
return true;
}
if (rectData && marginsData) {
// choose margins if equal priority
if (rectData->mPriority > marginsData->mPriority) {
marginsData = nullptr;
} else {
rectData = nullptr;
}
}
NS_ASSERTION((rectData == nullptr) != (marginsData == nullptr),
"Only one of rectData or marginsData should be set!");
nsRect result;
if (rectData) {
result = GetDisplayPortFromRectData(aContent, rectData, aMultiplier);
} else if (APZCCallbackHelper::IsDisplayportSuppressed() || ShouldDisableApzForElement(aContent)) {
DisplayPortMarginsPropertyData noMargins(ScreenMargin(), 1);
result = GetDisplayPortFromMarginsData(aContent, &noMargins, aMultiplier);
} else {
result = GetDisplayPortFromMarginsData(aContent, marginsData, aMultiplier);
}
if (!gfxPrefs::LayersTilesEnabled()) {
// Either we should have gotten a valid rect directly from the displayport
// base, or we should have computed a valid rect from the margins.
NS_ASSERTION(result.width <= GetMaxDisplayPortSize(aContent),
"Displayport must be a valid texture size");
NS_ASSERTION(result.height <= GetMaxDisplayPortSize(aContent),
"Displayport must be a valid texture size");
}
*aResult = result;
return true;
}
void
TranslateFromScrollPortToScrollFrame(nsIContent* aContent, nsRect* aRect)
{
MOZ_ASSERT(aRect);
nsIFrame* frame = GetScrollFrameFromContent(aContent);
nsIScrollableFrame* scrollableFrame = frame ? frame->GetScrollTargetFrame() : nullptr;
if (scrollableFrame) {
*aRect += scrollableFrame->GetScrollPortRect().TopLeft();
}
}
bool
nsLayoutUtils::GetDisplayPort(nsIContent* aContent, nsRect *aResult,
RelativeTo aRelativeTo /* = RelativeTo::ScrollPort */)
{
float multiplier =
gfxPrefs::UseLowPrecisionBuffer() ? 1.0f / gfxPrefs::LowPrecisionResolution() : 1.0f;
bool usingDisplayPort = GetDisplayPortImpl(aContent, aResult, multiplier);
if (aResult && usingDisplayPort && aRelativeTo == RelativeTo::ScrollFrame) {
TranslateFromScrollPortToScrollFrame(aContent, aResult);
}
return usingDisplayPort;
}
bool
nsLayoutUtils::HasDisplayPort(nsIContent* aContent) {
return GetDisplayPort(aContent, nullptr);
}
/* static */ bool
nsLayoutUtils::GetDisplayPortForVisibilityTesting(
nsIContent* aContent,
nsRect* aResult,
RelativeTo aRelativeTo /* = RelativeTo::ScrollPort */)
{
MOZ_ASSERT(aResult);
bool usingDisplayPort = GetDisplayPortImpl(aContent, aResult, 1.0f);
if (usingDisplayPort && aRelativeTo == RelativeTo::ScrollFrame) {
TranslateFromScrollPortToScrollFrame(aContent, aResult);
}
return usingDisplayPort;
}
bool
nsLayoutUtils::SetDisplayPortMargins(nsIContent* aContent,
nsIPresShell* aPresShell,
const ScreenMargin& aMargins,
uint32_t aPriority,
RepaintMode aRepaintMode)
{
MOZ_ASSERT(aContent);
MOZ_ASSERT(aContent->GetComposedDoc() == aPresShell->GetDocument());
DisplayPortMarginsPropertyData* currentData =
static_cast<DisplayPortMarginsPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
if (currentData && currentData->mPriority > aPriority) {
return false;
}
nsRect oldDisplayPort;
bool hadDisplayPort = GetHighResolutionDisplayPort(aContent, &oldDisplayPort);
aContent->SetProperty(nsGkAtoms::DisplayPortMargins,
new DisplayPortMarginsPropertyData(
aMargins, aPriority),
nsINode::DeleteProperty<DisplayPortMarginsPropertyData>);
nsRect newDisplayPort;
DebugOnly<bool> hasDisplayPort = GetHighResolutionDisplayPort(aContent, &newDisplayPort);
MOZ_ASSERT(hasDisplayPort);
bool changed = !hadDisplayPort ||
!oldDisplayPort.IsEqualEdges(newDisplayPort);
if (gfxPrefs::LayoutUseContainersForRootFrames()) {
nsIFrame* rootScrollFrame = aPresShell->GetRootScrollFrame();
if (rootScrollFrame &&
aContent == rootScrollFrame->GetContent() &&
nsLayoutUtils::UsesAsyncScrolling(rootScrollFrame))
{
// We are setting a root displayport for a document.
// If we have APZ, then set a special flag on the pres shell so
// that we don't get scrollbars drawn.
aPresShell->SetIgnoreViewportScrolling(true);
}
}
if (changed && aRepaintMode == RepaintMode::Repaint) {
nsIFrame* frame = aContent->GetPrimaryFrame();
if (frame) {
frame->SchedulePaint();
}
}
nsIFrame* frame = GetScrollFrameFromContent(aContent);
nsIScrollableFrame* scrollableFrame = frame ? frame->GetScrollTargetFrame() : nullptr;
if (!scrollableFrame) {
return true;
}
scrollableFrame->TriggerDisplayPortExpiration();
// Display port margins changing means that the set of visible frames may
// have drastically changed. Check if we should schedule an update.
hadDisplayPort =
scrollableFrame->GetDisplayPortAtLastApproximateFrameVisibilityUpdate(&oldDisplayPort);
bool needVisibilityUpdate = !hadDisplayPort;
// Check if the total size has changed by a large factor.
if (!needVisibilityUpdate) {
if ((newDisplayPort.width > 2 * oldDisplayPort.width) ||
(oldDisplayPort.width > 2 * newDisplayPort.width) ||
(newDisplayPort.height > 2 * oldDisplayPort.height) ||
(oldDisplayPort.height > 2 * newDisplayPort.height)) {
needVisibilityUpdate = true;
}
}
// Check if it's moved by a significant amount.
if (!needVisibilityUpdate) {
if (nsRect* baseData = static_cast<nsRect*>(aContent->GetProperty(nsGkAtoms::DisplayPortBase))) {
nsRect base = *baseData;
if ((std::abs(newDisplayPort.X() - oldDisplayPort.X()) > base.width) ||
(std::abs(newDisplayPort.XMost() - oldDisplayPort.XMost()) > base.width) ||
(std::abs(newDisplayPort.Y() - oldDisplayPort.Y()) > base.height) ||
(std::abs(newDisplayPort.YMost() - oldDisplayPort.YMost()) > base.height)) {
needVisibilityUpdate = true;
}
}
}
if (needVisibilityUpdate) {
aPresShell->ScheduleApproximateFrameVisibilityUpdateNow();
}
return true;
}
void
nsLayoutUtils::SetDisplayPortBase(nsIContent* aContent, const nsRect& aBase)
{
aContent->SetProperty(nsGkAtoms::DisplayPortBase, new nsRect(aBase),
nsINode::DeleteProperty<nsRect>);
}
void
nsLayoutUtils::SetDisplayPortBaseIfNotSet(nsIContent* aContent, const nsRect& aBase)
{
if (!aContent->GetProperty(nsGkAtoms::DisplayPortBase)) {
SetDisplayPortBase(aContent, aBase);
}
}
bool
nsLayoutUtils::GetCriticalDisplayPort(nsIContent* aContent, nsRect* aResult)
{
if (gfxPrefs::UseLowPrecisionBuffer()) {
return GetDisplayPortImpl(aContent, aResult, 1.0f);
}
return false;
}
bool
nsLayoutUtils::HasCriticalDisplayPort(nsIContent* aContent)
{
return GetCriticalDisplayPort(aContent, nullptr);
}
bool
nsLayoutUtils::GetHighResolutionDisplayPort(nsIContent* aContent, nsRect* aResult)
{
if (gfxPrefs::UseLowPrecisionBuffer()) {
return GetCriticalDisplayPort(aContent, aResult);
}
return GetDisplayPort(aContent, aResult);
}
void
nsLayoutUtils::RemoveDisplayPort(nsIContent* aContent)
{
aContent->DeleteProperty(nsGkAtoms::DisplayPort);
aContent->DeleteProperty(nsGkAtoms::DisplayPortMargins);
}
nsContainerFrame*
nsLayoutUtils::LastContinuationWithChild(nsContainerFrame* aFrame)
{
NS_PRECONDITION(aFrame, "NULL frame pointer");
nsIFrame* f = aFrame->LastContinuation();
while (!f->PrincipalChildList().FirstChild() && f->GetPrevContinuation()) {
f = f->GetPrevContinuation();
}
return static_cast<nsContainerFrame*>(f);
}
//static
FrameChildListID
nsLayoutUtils::GetChildListNameFor(nsIFrame* aChildFrame)
{
nsIFrame::ChildListID id = nsIFrame::kPrincipalList;
if (aChildFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER) {
nsIFrame* pif = aChildFrame->GetPrevInFlow();
if (pif->GetParent() == aChildFrame->GetParent()) {
id = nsIFrame::kExcessOverflowContainersList;
}
else {
id = nsIFrame::kOverflowContainersList;
}
}
// See if the frame is moved out of the flow
else if (aChildFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
// Look at the style information to tell
const nsStyleDisplay* disp = aChildFrame->StyleDisplay();
if (NS_STYLE_POSITION_ABSOLUTE == disp->mPosition) {
id = nsIFrame::kAbsoluteList;
} else if (NS_STYLE_POSITION_FIXED == disp->mPosition) {
if (nsLayoutUtils::IsReallyFixedPos(aChildFrame)) {
id = nsIFrame::kFixedList;
} else {
id = nsIFrame::kAbsoluteList;
}
#ifdef MOZ_XUL
} else if (StyleDisplay::MozPopup == disp->mDisplay) {
// Out-of-flows that are DISPLAY_POPUP must be kids of the root popup set
#ifdef DEBUG
nsIFrame* parent = aChildFrame->GetParent();
NS_ASSERTION(parent && parent->GetType() == nsGkAtoms::popupSetFrame,
"Unexpected parent");
#endif // DEBUG
id = nsIFrame::kPopupList;
#endif // MOZ_XUL
} else {
NS_ASSERTION(aChildFrame->IsFloating(), "not a floated frame");
id = nsIFrame::kFloatList;
}
} else {
nsIAtom* childType = aChildFrame->GetType();
if (nsGkAtoms::menuPopupFrame == childType) {
nsIFrame* parent = aChildFrame->GetParent();
MOZ_ASSERT(parent, "nsMenuPopupFrame can't be the root frame");
if (parent) {
if (parent->GetType() == nsGkAtoms::popupSetFrame) {
id = nsIFrame::kPopupList;
} else {
nsIFrame* firstPopup = parent->GetChildList(nsIFrame::kPopupList).FirstChild();
MOZ_ASSERT(!firstPopup || !firstPopup->GetNextSibling(),
"We assume popupList only has one child, but it has more.");
id = firstPopup == aChildFrame
? nsIFrame::kPopupList
: nsIFrame::kPrincipalList;
}
} else {
id = nsIFrame::kPrincipalList;
}
} else if (nsGkAtoms::tableColGroupFrame == childType) {
id = nsIFrame::kColGroupList;
} else if (aChildFrame->IsTableCaption()) {
id = nsIFrame::kCaptionList;
} else {
id = nsIFrame::kPrincipalList;
}
}
#ifdef DEBUG
// Verify that the frame is actually in that child list or in the
// corresponding overflow list.
nsContainerFrame* parent = aChildFrame->GetParent();
bool found = parent->GetChildList(id).ContainsFrame(aChildFrame);
if (!found) {
if (!(aChildFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
found = parent->GetChildList(nsIFrame::kOverflowList)
.ContainsFrame(aChildFrame);
}
else if (aChildFrame->IsFloating()) {
found = parent->GetChildList(nsIFrame::kOverflowOutOfFlowList)
.ContainsFrame(aChildFrame);
if (!found) {
found = parent->GetChildList(nsIFrame::kPushedFloatsList)
.ContainsFrame(aChildFrame);
}
}
// else it's positioned and should have been on the 'id' child list.
NS_POSTCONDITION(found, "not in child list");
}
#endif
return id;
}
/*static*/ nsIFrame*
nsLayoutUtils::GetBeforeFrameForContent(nsIFrame* aFrame,
const nsIContent* aContent)
{
// We need to call GetGenConPseudos() on the first continuation/ib-split.
// Find it, for symmetry with GetAfterFrameForContent.
nsContainerFrame* genConParentFrame =
FirstContinuationOrIBSplitSibling(aFrame)->GetContentInsertionFrame();
if (!genConParentFrame) {
return nullptr;
}
nsTArray<nsIContent*>* prop = genConParentFrame->GetGenConPseudos();
if (prop) {
const nsTArray<nsIContent*>& pseudos(*prop);
for (uint32_t i = 0; i < pseudos.Length(); ++i) {
if (pseudos[i]->GetParent() == aContent &&
pseudos[i]->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore) {
return pseudos[i]->GetPrimaryFrame();
}
}
}
// If the first child frame is a pseudo-frame, then try that.
// Note that the frame we create for the generated content is also a
// pseudo-frame and so don't drill down in that case.
nsIFrame* childFrame = genConParentFrame->PrincipalChildList().FirstChild();
if (childFrame &&
childFrame->IsPseudoFrame(aContent) &&
!childFrame->IsGeneratedContentFrame()) {
return GetBeforeFrameForContent(childFrame, aContent);
}
return nullptr;
}
/*static*/ nsIFrame*
nsLayoutUtils::GetBeforeFrame(nsIFrame* aFrame)
{
return GetBeforeFrameForContent(aFrame, aFrame->GetContent());
}
/*static*/ nsIFrame*
nsLayoutUtils::GetAfterFrameForContent(nsIFrame* aFrame,
const nsIContent* aContent)
{
// We need to call GetGenConPseudos() on the first continuation,
// but callers are likely to pass the last.
nsContainerFrame* genConParentFrame =
FirstContinuationOrIBSplitSibling(aFrame)->GetContentInsertionFrame();
if (!genConParentFrame) {
return nullptr;
}
nsTArray<nsIContent*>* prop = genConParentFrame->GetGenConPseudos();
if (prop) {
const nsTArray<nsIContent*>& pseudos(*prop);
for (uint32_t i = 0; i < pseudos.Length(); ++i) {
if (pseudos[i]->GetParent() == aContent &&
pseudos[i]->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentafter) {
return pseudos[i]->GetPrimaryFrame();
}
}
}
// If the last child frame is a pseudo-frame, then try that.
// Note that the frame we create for the generated content is also a
// pseudo-frame and so don't drill down in that case.
genConParentFrame = aFrame->GetContentInsertionFrame();
if (!genConParentFrame) {
return nullptr;
}
nsIFrame* lastParentContinuation =
LastContinuationWithChild(static_cast<nsContainerFrame*>(
LastContinuationOrIBSplitSibling(genConParentFrame)));
nsIFrame* childFrame =
lastParentContinuation->GetChildList(nsIFrame::kPrincipalList).LastChild();
if (childFrame &&
childFrame->IsPseudoFrame(aContent) &&
!childFrame->IsGeneratedContentFrame()) {
return GetAfterFrameForContent(childFrame->FirstContinuation(), aContent);
}
return nullptr;
}
/*static*/ nsIFrame*
nsLayoutUtils::GetAfterFrame(nsIFrame* aFrame)
{
return GetAfterFrameForContent(aFrame, aFrame->GetContent());
}
// static
nsIFrame*
nsLayoutUtils::GetClosestFrameOfType(nsIFrame* aFrame,
nsIAtom* aFrameType,
nsIFrame* aStopAt)
{
for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
if (frame->GetType() == aFrameType) {
return frame;
}
if (frame == aStopAt) {
break;
}
}
return nullptr;
}
// static
nsIFrame*
nsLayoutUtils::GetStyleFrame(nsIFrame* aFrame)
{
if (aFrame->GetType() == nsGkAtoms::tableWrapperFrame) {
nsIFrame* inner = aFrame->PrincipalChildList().FirstChild();
// inner may be null, if aFrame is mid-destruction
return inner;
}
return aFrame;
}
nsIFrame*
nsLayoutUtils::GetStyleFrame(const nsIContent* aContent)
{
nsIFrame *frame = aContent->GetPrimaryFrame();
if (!frame) {
return nullptr;
}
return nsLayoutUtils::GetStyleFrame(frame);
}
/* static */ nsIFrame*
nsLayoutUtils::GetRealPrimaryFrameFor(const nsIContent* aContent)
{
nsIFrame *frame = aContent->GetPrimaryFrame();
if (!frame) {
return nullptr;
}
return nsPlaceholderFrame::GetRealFrameFor(frame);
}
nsIFrame*
nsLayoutUtils::GetFloatFromPlaceholder(nsIFrame* aFrame) {
NS_ASSERTION(nsGkAtoms::placeholderFrame == aFrame->GetType(),
"Must have a placeholder here");
if (aFrame->GetStateBits() & PLACEHOLDER_FOR_FLOAT) {
nsIFrame *outOfFlowFrame =
nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame);
NS_ASSERTION(outOfFlowFrame->IsFloating(),
"How did that happen?");
return outOfFlowFrame;
}
return nullptr;
}
// static
bool
nsLayoutUtils::IsGeneratedContentFor(nsIContent* aContent,
nsIFrame* aFrame,
nsIAtom* aPseudoElement)
{
NS_PRECONDITION(aFrame, "Must have a frame");
NS_PRECONDITION(aPseudoElement, "Must have a pseudo name");
if (!aFrame->IsGeneratedContentFrame()) {
return false;
}
nsIFrame* parent = aFrame->GetParent();
NS_ASSERTION(parent, "Generated content can't be root frame");
if (parent->IsGeneratedContentFrame()) {
// Not the root of the generated content
return false;
}
if (aContent && parent->GetContent() != aContent) {
return false;
}
return (aFrame->GetContent()->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore) ==
(aPseudoElement == nsCSSPseudoElements::before);
}
// static
nsIFrame*
nsLayoutUtils::GetCrossDocParentFrame(const nsIFrame* aFrame,
nsPoint* aExtraOffset)
{
nsIFrame* p = aFrame->GetParent();
if (p)
return p;
nsView* v = aFrame->GetView();
if (!v)
return nullptr;
v = v->GetParent(); // anonymous inner view
if (!v)
return nullptr;
if (aExtraOffset) {
*aExtraOffset += v->GetPosition();
}
v = v->GetParent(); // subdocumentframe's view
return v ? v->GetFrame() : nullptr;
}
// static
bool
nsLayoutUtils::IsProperAncestorFrameCrossDoc(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
nsIFrame* aCommonAncestor)
{
if (aFrame == aAncestorFrame)
return false;
return IsAncestorFrameCrossDoc(aAncestorFrame, aFrame, aCommonAncestor);
}
// static
bool
nsLayoutUtils::IsAncestorFrameCrossDoc(const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
const nsIFrame* aCommonAncestor)
{
for (const nsIFrame* f = aFrame; f != aCommonAncestor;
f = GetCrossDocParentFrame(f)) {
if (f == aAncestorFrame)
return true;
}
return aCommonAncestor == aAncestorFrame;
}
// static
bool
nsLayoutUtils::IsProperAncestorFrame(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
nsIFrame* aCommonAncestor)
{
if (aFrame == aAncestorFrame)
return false;
for (nsIFrame* f = aFrame; f != aCommonAncestor; f = f->GetParent()) {
if (f == aAncestorFrame)
return true;
}
return aCommonAncestor == aAncestorFrame;
}
// static
int32_t
nsLayoutUtils::DoCompareTreePosition(nsIContent* aContent1,
nsIContent* aContent2,
int32_t aIf1Ancestor,
int32_t aIf2Ancestor,
const nsIContent* aCommonAncestor)
{
NS_PRECONDITION(aContent1, "aContent1 must not be null");
NS_PRECONDITION(aContent2, "aContent2 must not be null");
AutoTArray<nsINode*, 32> content1Ancestors;
nsINode* c1;
for (c1 = aContent1; c1 && c1 != aCommonAncestor; c1 = c1->GetParentNode()) {
content1Ancestors.AppendElement(c1);
}
if (!c1 && aCommonAncestor) {
// So, it turns out aCommonAncestor was not an ancestor of c1. Oops.
// Never mind. We can continue as if aCommonAncestor was null.
aCommonAncestor = nullptr;
}
AutoTArray<nsINode*, 32> content2Ancestors;
nsINode* c2;
for (c2 = aContent2; c2 && c2 != aCommonAncestor; c2 = c2->GetParentNode()) {
content2Ancestors.AppendElement(c2);
}
if (!c2 && aCommonAncestor) {
// So, it turns out aCommonAncestor was not an ancestor of c2.
// We need to retry with no common ancestor hint.
return DoCompareTreePosition(aContent1, aContent2,
aIf1Ancestor, aIf2Ancestor, nullptr);
}
int last1 = content1Ancestors.Length() - 1;
int last2 = content2Ancestors.Length() - 1;
nsINode* content1Ancestor = nullptr;
nsINode* content2Ancestor = nullptr;
while (last1 >= 0 && last2 >= 0
&& ((content1Ancestor = content1Ancestors.ElementAt(last1)) ==
(content2Ancestor = content2Ancestors.ElementAt(last2)))) {
last1--;
last2--;
}
if (last1 < 0) {
if (last2 < 0) {
NS_ASSERTION(aContent1 == aContent2, "internal error?");
return 0;
}
// aContent1 is an ancestor of aContent2
return aIf1Ancestor;
}
if (last2 < 0) {
// aContent2 is an ancestor of aContent1
return aIf2Ancestor;
}
// content1Ancestor != content2Ancestor, so they must be siblings with the same parent
nsINode* parent = content1Ancestor->GetParentNode();
#ifdef DEBUG
// TODO: remove the uglyness, see bug 598468.
NS_ASSERTION(gPreventAssertInCompareTreePosition || parent,
"no common ancestor at all???");
#endif // DEBUG
if (!parent) { // different documents??
return 0;
}
int32_t index1 = parent->IndexOf(content1Ancestor);
int32_t index2 = parent->IndexOf(content2Ancestor);
if (index1 < 0 || index2 < 0) {
// one of them must be anonymous; we can't determine the order
return 0;
}
return index1 - index2;
}
// static
nsIFrame*
nsLayoutUtils::FillAncestors(nsIFrame* aFrame,
nsIFrame* aStopAtAncestor,
nsTArray<nsIFrame*>* aAncestors)
{
while (aFrame && aFrame != aStopAtAncestor) {
aAncestors->AppendElement(aFrame);
aFrame = nsLayoutUtils::GetParentOrPlaceholderFor(aFrame);
}
return aFrame;
}
// Return true if aFrame1 is after aFrame2
static bool IsFrameAfter(nsIFrame* aFrame1, nsIFrame* aFrame2)
{
nsIFrame* f = aFrame2;
do {
f = f->GetNextSibling();
if (f == aFrame1)
return true;
} while (f);
return false;
}
// static
int32_t
nsLayoutUtils::DoCompareTreePosition(nsIFrame* aFrame1,
nsIFrame* aFrame2,
int32_t aIf1Ancestor,
int32_t aIf2Ancestor,
nsIFrame* aCommonAncestor)
{
NS_PRECONDITION(aFrame1, "aFrame1 must not be null");
NS_PRECONDITION(aFrame2, "aFrame2 must not be null");
AutoTArray<nsIFrame*,20> frame2Ancestors;
nsIFrame* nonCommonAncestor =
FillAncestors(aFrame2, aCommonAncestor, &frame2Ancestors);
return DoCompareTreePosition(aFrame1, aFrame2, frame2Ancestors,
aIf1Ancestor, aIf2Ancestor,
nonCommonAncestor ? aCommonAncestor : nullptr);
}
// static
int32_t
nsLayoutUtils::DoCompareTreePosition(nsIFrame* aFrame1,
nsIFrame* aFrame2,
nsTArray<nsIFrame*>& aFrame2Ancestors,
int32_t aIf1Ancestor,
int32_t aIf2Ancestor,
nsIFrame* aCommonAncestor)
{
NS_PRECONDITION(aFrame1, "aFrame1 must not be null");
NS_PRECONDITION(aFrame2, "aFrame2 must not be null");
nsPresContext* presContext = aFrame1->PresContext();
if (presContext != aFrame2->PresContext()) {
NS_ERROR("no common ancestor at all, different documents");
return 0;
}
AutoTArray<nsIFrame*,20> frame1Ancestors;
if (aCommonAncestor &&
!FillAncestors(aFrame1, aCommonAncestor, &frame1Ancestors)) {
// We reached the root of the frame tree ... if aCommonAncestor was set,
// it is wrong
return DoCompareTreePosition(aFrame1, aFrame2,
aIf1Ancestor, aIf2Ancestor, nullptr);
}
int32_t last1 = int32_t(frame1Ancestors.Length()) - 1;
int32_t last2 = int32_t(aFrame2Ancestors.Length()) - 1;
while (last1 >= 0 && last2 >= 0 &&
frame1Ancestors[last1] == aFrame2Ancestors[last2]) {
last1--;
last2--;
}
if (last1 < 0) {
if (last2 < 0) {
NS_ASSERTION(aFrame1 == aFrame2, "internal error?");
return 0;
}
// aFrame1 is an ancestor of aFrame2
return aIf1Ancestor;
}
if (last2 < 0) {
// aFrame2 is an ancestor of aFrame1
return aIf2Ancestor;
}
nsIFrame* ancestor1 = frame1Ancestors[last1];
nsIFrame* ancestor2 = aFrame2Ancestors[last2];
// Now we should be able to walk sibling chains to find which one is first
if (IsFrameAfter(ancestor2, ancestor1))
return -1;
if (IsFrameAfter(ancestor1, ancestor2))
return 1;
NS_WARNING("Frames were in different child lists???");
return 0;
}
// static
nsIFrame* nsLayoutUtils::GetLastSibling(nsIFrame* aFrame) {
if (!aFrame) {
return nullptr;
}
nsIFrame* next;
while ((next = aFrame->GetNextSibling()) != nullptr) {
aFrame = next;
}
return aFrame;
}
// static
nsView*
nsLayoutUtils::FindSiblingViewFor(nsView* aParentView, nsIFrame* aFrame) {
nsIFrame* parentViewFrame = aParentView->GetFrame();
nsIContent* parentViewContent = parentViewFrame ? parentViewFrame->GetContent() : nullptr;
for (nsView* insertBefore = aParentView->GetFirstChild(); insertBefore;
insertBefore = insertBefore->GetNextSibling()) {
nsIFrame* f = insertBefore->GetFrame();
if (!f) {
// this view could be some anonymous view attached to a meaningful parent
for (nsView* searchView = insertBefore->GetParent(); searchView;
searchView = searchView->GetParent()) {
f = searchView->GetFrame();
if (f) {
break;
}
}
NS_ASSERTION(f, "Can't find a frame anywhere!");
}
if (!f || !aFrame->GetContent() || !f->GetContent() ||
CompareTreePosition(aFrame->GetContent(), f->GetContent(), parentViewContent) > 0) {
// aFrame's content is after f's content (or we just don't know),
// so put our view before f's view
return insertBefore;
}
}
return nullptr;
}
//static
nsIScrollableFrame*
nsLayoutUtils::GetScrollableFrameFor(const nsIFrame *aScrolledFrame)
{
nsIFrame *frame = aScrolledFrame->GetParent();
nsIScrollableFrame *sf = do_QueryFrame(frame);
return (sf && sf->GetScrolledFrame() == aScrolledFrame) ? sf : nullptr;
}
/* static */ void
nsLayoutUtils::SetFixedPositionLayerData(Layer* aLayer,
const nsIFrame* aViewportFrame,
const nsRect& aAnchorRect,
const nsIFrame* aFixedPosFrame,
nsPresContext* aPresContext,
const ContainerLayerParameters& aContainerParameters) {
// Find out the rect of the viewport frame relative to the reference frame.
// This, in conjunction with the container scale, will correspond to the
// coordinate-space of the built layer.
float factor = aPresContext->AppUnitsPerDevPixel();
Rect anchorRect(NSAppUnitsToFloatPixels(aAnchorRect.x, factor) *
aContainerParameters.mXScale,
NSAppUnitsToFloatPixels(aAnchorRect.y, factor) *
aContainerParameters.mYScale,
NSAppUnitsToFloatPixels(aAnchorRect.width, factor) *
aContainerParameters.mXScale,
NSAppUnitsToFloatPixels(aAnchorRect.height, factor) *
aContainerParameters.mYScale);
// Need to transform anchorRect from the container layer's coordinate system
// into aLayer's coordinate system.
Matrix transform2d;
if (aLayer->GetTransform().Is2D(&transform2d)) {
transform2d.Invert();
anchorRect = transform2d.TransformBounds(anchorRect);
} else {
NS_ERROR("3D transform found between fixedpos content and its viewport (should never happen)");
anchorRect = Rect(0,0,0,0);
}
// Work out the anchor point for this fixed position layer. We assume that
// any positioning set (left/top/right/bottom) indicates that the
// corresponding side of its container should be the anchor point,
// defaulting to top-left.
LayerPoint anchor(anchorRect.x, anchorRect.y);
int32_t sides = eSideBitsNone;
if (aFixedPosFrame != aViewportFrame) {
const nsStylePosition* position = aFixedPosFrame->StylePosition();
if (position->mOffset.GetRightUnit() != eStyleUnit_Auto) {
sides |= eSideBitsRight;
if (position->mOffset.GetLeftUnit() != eStyleUnit_Auto) {
sides |= eSideBitsLeft;
anchor.x = anchorRect.x + anchorRect.width / 2.f;
} else {
anchor.x = anchorRect.XMost();
}
}
if (position->mOffset.GetBottomUnit() != eStyleUnit_Auto) {
sides |= eSideBitsBottom;
if (position->mOffset.GetTopUnit() != eStyleUnit_Auto) {
sides |= eSideBitsTop;
anchor.y = anchorRect.y + anchorRect.height / 2.f;
} else {
anchor.y = anchorRect.YMost();
}
}
}
ViewID id = FrameMetrics::NULL_SCROLL_ID;
if (nsIFrame* rootScrollFrame = aPresContext->PresShell()->GetRootScrollFrame()) {
if (nsIContent* content = rootScrollFrame->GetContent()) {
id = FindOrCreateIDFor(content);
}
}
aLayer->SetFixedPositionData(id, anchor, sides);
}
bool
nsLayoutUtils::ViewportHasDisplayPort(nsPresContext* aPresContext)
{
nsIFrame* rootScrollFrame =
aPresContext->PresShell()->GetRootScrollFrame();
return rootScrollFrame &&
nsLayoutUtils::HasDisplayPort(rootScrollFrame->GetContent());
}
bool
nsLayoutUtils::IsFixedPosFrameInDisplayPort(const nsIFrame* aFrame)
{
// Fixed-pos frames are parented by the viewport frame or the page content frame.
// We'll assume that printing/print preview don't have displayports for their
// pages!
nsIFrame* parent = aFrame->GetParent();
if (!parent || parent->GetParent() ||
aFrame->StyleDisplay()->mPosition != NS_STYLE_POSITION_FIXED) {
return false;
}
return ViewportHasDisplayPort(aFrame->PresContext());
}
NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(ScrollbarThumbLayerized, bool)
/* static */ void
nsLayoutUtils::SetScrollbarThumbLayerization(nsIFrame* aThumbFrame, bool aLayerize)
{
aThumbFrame->Properties().Set(ScrollbarThumbLayerized(), aLayerize);
}
bool
nsLayoutUtils::IsScrollbarThumbLayerized(nsIFrame* aThumbFrame)
{
return aThumbFrame->Properties().Get(ScrollbarThumbLayerized());
}
// static
nsIScrollableFrame*
nsLayoutUtils::GetNearestScrollableFrameForDirection(nsIFrame* aFrame,
Direction aDirection)
{
NS_ASSERTION(aFrame, "GetNearestScrollableFrameForDirection expects a non-null frame");
for (nsIFrame* f = aFrame; f; f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
nsIScrollableFrame* scrollableFrame = do_QueryFrame(f);
if (scrollableFrame) {
ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles();
uint32_t directions = scrollableFrame->GetPerceivedScrollingDirections();
if (aDirection == eVertical ?
(ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN &&
(directions & nsIScrollableFrame::VERTICAL)) :
(ss.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN &&
(directions & nsIScrollableFrame::HORIZONTAL)))
return scrollableFrame;
}
}
return nullptr;
}
// static
nsIScrollableFrame*
nsLayoutUtils::GetNearestScrollableFrame(nsIFrame* aFrame, uint32_t aFlags)
{
NS_ASSERTION(aFrame, "GetNearestScrollableFrame expects a non-null frame");
for (nsIFrame* f = aFrame; f; f = (aFlags & SCROLLABLE_SAME_DOC) ?
f->GetParent() : nsLayoutUtils::GetCrossDocParentFrame(f)) {
nsIScrollableFrame* scrollableFrame = do_QueryFrame(f);
if (scrollableFrame) {
if (aFlags & SCROLLABLE_ONLY_ASYNC_SCROLLABLE) {
if (scrollableFrame->WantAsyncScroll()) {
return scrollableFrame;
}
} else {
ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles();
if ((aFlags & SCROLLABLE_INCLUDE_HIDDEN) ||
ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN ||
ss.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN) {
return scrollableFrame;
}
}
if (aFlags & SCROLLABLE_ALWAYS_MATCH_ROOT) {
nsIPresShell* ps = f->PresContext()->PresShell();
if (ps->GetRootScrollFrame() == f &&
ps->GetDocument() && ps->GetDocument()->IsRootDisplayDocument()) {
return scrollableFrame;
}
}
}
if ((aFlags & SCROLLABLE_FIXEDPOS_FINDS_ROOT) &&
f->StyleDisplay()->mPosition == NS_STYLE_POSITION_FIXED &&
nsLayoutUtils::IsReallyFixedPos(f)) {
return f->PresContext()->PresShell()->GetRootScrollFrameAsScrollable();
}
}
return nullptr;
}
// static
nsRect
nsLayoutUtils::GetScrolledRect(nsIFrame* aScrolledFrame,
const nsRect& aScrolledFrameOverflowArea,
const nsSize& aScrollPortSize,
uint8_t aDirection)
{
WritingMode wm = aScrolledFrame->GetWritingMode();
// Potentially override the frame's direction to use the direction found
// by ScrollFrameHelper::GetScrolledFrameDir()
wm.SetDirectionFromBidiLevel(aDirection == NS_STYLE_DIRECTION_RTL ? 1 : 0);
nscoord x1 = aScrolledFrameOverflowArea.x,
x2 = aScrolledFrameOverflowArea.XMost(),
y1 = aScrolledFrameOverflowArea.y,
y2 = aScrolledFrameOverflowArea.YMost();
bool horizontal = !wm.IsVertical();
// Clamp the horizontal start-edge (x1 or x2, depending whether the logical
// axis that corresponds to horizontal progresses from L-R or R-L).
// In horizontal writing mode, we need to check IsInlineReversed() to see
// which side to clamp; in vertical mode, it depends on the block direction.
if ((horizontal && !wm.IsInlineReversed()) || wm.IsVerticalLR()) {
if (x1 < 0) {
x1 = 0;
}
} else {
if (x2 > aScrollPortSize.width) {
x2 = aScrollPortSize.width;
}
// When the scrolled frame chooses a size larger than its available width
// (because its padding alone is larger than the available width), we need
// to keep the start-edge of the scroll frame anchored to the start-edge of
// the scrollport.
// When the scrolled frame is RTL, this means moving it in our left-based
// coordinate system, so we need to compensate for its extra width here by
// effectively repositioning the frame.
nscoord extraWidth =
std::max(0, aScrolledFrame->GetSize().width - aScrollPortSize.width);
x2 += extraWidth;
}
// Similarly, clamp the vertical start-edge.
// In horizontal writing mode, the block direction is always top-to-bottom;
// in vertical writing mode, we need to check IsInlineReversed().
if (horizontal || !wm.IsInlineReversed()) {
if (y1 < 0) {
y1 = 0;
}
} else {
if (y2 > aScrollPortSize.height) {
y2 = aScrollPortSize.height;
}
nscoord extraHeight =
std::max(0, aScrolledFrame->GetSize().height - aScrollPortSize.height);
y2 += extraHeight;
}
return nsRect(x1, y1, x2 - x1, y2 - y1);
}
//static
bool
nsLayoutUtils::HasPseudoStyle(nsIContent* aContent,
nsStyleContext* aStyleContext,
CSSPseudoElementType aPseudoElement,
nsPresContext* aPresContext)
{
NS_PRECONDITION(aPresContext, "Must have a prescontext");
RefPtr<nsStyleContext> pseudoContext;
if (aContent) {
pseudoContext = aPresContext->StyleSet()->
ProbePseudoElementStyle(aContent->AsElement(), aPseudoElement,
aStyleContext);
}
return pseudoContext != nullptr;
}
nsPoint
nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(nsIDOMEvent* aDOMEvent, nsIFrame* aFrame)
{
if (!aDOMEvent)
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
WidgetEvent* event = aDOMEvent->WidgetEventPtr();
if (!event)
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
return GetEventCoordinatesRelativeTo(event, aFrame);
}
nsPoint
nsLayoutUtils::GetEventCoordinatesRelativeTo(const WidgetEvent* aEvent,
nsIFrame* aFrame)
{
if (!aEvent || (aEvent->mClass != eMouseEventClass &&
aEvent->mClass != eMouseScrollEventClass &&
aEvent->mClass != eWheelEventClass &&
aEvent->mClass != eDragEventClass &&
aEvent->mClass != eSimpleGestureEventClass &&
aEvent->mClass != ePointerEventClass &&
aEvent->mClass != eGestureNotifyEventClass &&
aEvent->mClass != eTouchEventClass &&
aEvent->mClass != eQueryContentEventClass))
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
return GetEventCoordinatesRelativeTo(aEvent,
aEvent->AsGUIEvent()->mRefPoint,
aFrame);
}
nsPoint
nsLayoutUtils::GetEventCoordinatesRelativeTo(const WidgetEvent* aEvent,
const LayoutDeviceIntPoint& aPoint,
nsIFrame* aFrame)
{
if (!aFrame) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
nsIWidget* widget = aEvent->AsGUIEvent()->mWidget;
if (!widget) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
return GetEventCoordinatesRelativeTo(widget, aPoint, aFrame);
}
nsPoint
nsLayoutUtils::GetEventCoordinatesRelativeTo(nsIWidget* aWidget,
const LayoutDeviceIntPoint& aPoint,
nsIFrame* aFrame)
{
if (!aFrame || !aWidget) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
nsView* view = aFrame->GetView();
if (view) {
nsIWidget* frameWidget = view->GetWidget();
if (frameWidget && frameWidget == aWidget) {
// Special case this cause it happens a lot.
// This also fixes bug 664707, events in the extra-special case of select
// dropdown popups that are transformed.
nsPresContext* presContext = aFrame->PresContext();
nsPoint pt(presContext->DevPixelsToAppUnits(aPoint.x),
presContext->DevPixelsToAppUnits(aPoint.y));
pt = pt - view->ViewToWidgetOffset();
pt = pt.RemoveResolution(GetCurrentAPZResolutionScale(presContext->PresShell()));
return pt;
}
}
/* If we walk up the frame tree and discover that any of the frames are
* transformed, we need to do extra work to convert from the global
* space to the local space.
*/
nsIFrame* rootFrame = aFrame;
bool transformFound = false;
for (nsIFrame* f = aFrame; f; f = GetCrossDocParentFrame(f)) {
if (f->IsTransformed()) {
transformFound = true;
}
rootFrame = f;
}
nsView* rootView = rootFrame->GetView();
if (!rootView) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
nsPoint widgetToView = TranslateWidgetToView(rootFrame->PresContext(),
aWidget, aPoint, rootView);
if (widgetToView == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
// Convert from root document app units to app units of the document aFrame
// is in.
int32_t rootAPD = rootFrame->PresContext()->AppUnitsPerDevPixel();
int32_t localAPD = aFrame->PresContext()->AppUnitsPerDevPixel();
widgetToView = widgetToView.ScaleToOtherAppUnits(rootAPD, localAPD);
nsIPresShell* shell = aFrame->PresContext()->PresShell();
// XXX Bug 1224748 - Update nsLayoutUtils functions to correctly handle nsPresShell resolution
widgetToView = widgetToView.RemoveResolution(GetCurrentAPZResolutionScale(shell));
/* If we encountered a transform, we can't do simple arithmetic to figure
* out how to convert back to aFrame's coordinates and must use the CTM.
*/
if (transformFound || aFrame->IsSVGText()) {
return TransformRootPointToFrame(aFrame, widgetToView);
}
/* Otherwise, all coordinate systems are translations of one another,
* so we can just subtract out the difference.
*/
return widgetToView - aFrame->GetOffsetToCrossDoc(rootFrame);
}
nsIFrame*
nsLayoutUtils::GetPopupFrameForEventCoordinates(nsPresContext* aPresContext,
const WidgetEvent* aEvent)
{
#ifdef MOZ_XUL
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
if (!pm) {
return nullptr;
}
nsTArray<nsIFrame*> popups;
pm->GetVisiblePopups(popups);
uint32_t i;
// Search from top to bottom
for (i = 0; i < popups.Length(); i++) {
nsIFrame* popup = popups[i];
if (popup->PresContext()->GetRootPresContext() == aPresContext &&
popup->GetScrollableOverflowRect().Contains(
GetEventCoordinatesRelativeTo(aEvent, popup))) {
return popup;
}
}
#endif
return nullptr;
}
static void ConstrainToCoordValues(float& aStart, float& aSize)
{
MOZ_ASSERT(aSize >= 0);
// Here we try to make sure that the resulting nsRect will continue to cover
// as much of the area that was covered by the original gfx Rect as possible.
// We clamp the bounds of the rect to {nscoord_MIN,nscoord_MAX} since
// nsRect::X/Y() and nsRect::XMost/YMost() can't return values outwith this
// range:
float end = aStart + aSize;
aStart = clamped(aStart, float(nscoord_MIN), float(nscoord_MAX));
end = clamped(end, float(nscoord_MIN), float(nscoord_MAX));
aSize = end - aStart;
// We must also clamp aSize to {0,nscoord_MAX} since nsRect::Width/Height()
// can't return a value greater than nscoord_MAX. If aSize is greater than
// nscoord_MAX then we reduce it to nscoord_MAX while keeping the rect
// centered:
if (aSize > nscoord_MAX) {
float excess = aSize - nscoord_MAX;
excess /= 2;
aStart += excess;
aSize = nscoord_MAX;
}
}
/**
* Given a gfxFloat, constrains its value to be between nscoord_MIN and nscoord_MAX.
*
* @param aVal The value to constrain (in/out)
*/
static void ConstrainToCoordValues(gfxFloat& aVal)
{
if (aVal <= nscoord_MIN)
aVal = nscoord_MIN;
else if (aVal >= nscoord_MAX)
aVal = nscoord_MAX;
}
static void ConstrainToCoordValues(gfxFloat& aStart, gfxFloat& aSize)
{
gfxFloat max = aStart + aSize;
// Clamp the end points to within nscoord range
ConstrainToCoordValues(aStart);
ConstrainToCoordValues(max);
aSize = max - aStart;
// If the width if still greater than the max nscoord, then bring both
// endpoints in by the same amount until it fits.
if (aSize > nscoord_MAX) {
gfxFloat excess = aSize - nscoord_MAX;
excess /= 2;
aStart += excess;
aSize = nscoord_MAX;
} else if (aSize < nscoord_MIN) {
gfxFloat excess = aSize - nscoord_MIN;
excess /= 2;
aStart -= excess;
aSize = nscoord_MIN;
}
}
nsRect
nsLayoutUtils::RoundGfxRectToAppRect(const Rect &aRect, float aFactor)
{
/* Get a new Rect whose units are app units by scaling by the specified factor. */
Rect scaledRect = aRect;
scaledRect.ScaleRoundOut(aFactor);
/* We now need to constrain our results to the max and min values for coords. */
ConstrainToCoordValues(scaledRect.x, scaledRect.width);
ConstrainToCoordValues(scaledRect.y, scaledRect.height);
/* Now typecast everything back. This is guaranteed to be safe. */
return nsRect(nscoord(scaledRect.X()), nscoord(scaledRect.Y()),
nscoord(scaledRect.Width()), nscoord(scaledRect.Height()));
}
nsRect
nsLayoutUtils::RoundGfxRectToAppRect(const gfxRect &aRect, float aFactor)
{
/* Get a new gfxRect whose units are app units by scaling by the specified factor. */
gfxRect scaledRect = aRect;
scaledRect.ScaleRoundOut(aFactor);
/* We now need to constrain our results to the max and min values for coords. */
ConstrainToCoordValues(scaledRect.x, scaledRect.width);
ConstrainToCoordValues(scaledRect.y, scaledRect.height);
/* Now typecast everything back. This is guaranteed to be safe. */
return nsRect(nscoord(scaledRect.X()), nscoord(scaledRect.Y()),
nscoord(scaledRect.Width()), nscoord(scaledRect.Height()));
}
nsRegion
nsLayoutUtils::RoundedRectIntersectRect(const nsRect& aRoundedRect,
const nscoord aRadii[8],
const nsRect& aContainedRect)
{
// rectFullHeight and rectFullWidth together will approximately contain
// the total area of the frame minus the rounded corners.
nsRect rectFullHeight = aRoundedRect;
nscoord xDiff = std::max(aRadii[eCornerTopLeftX], aRadii[eCornerBottomLeftX]);
rectFullHeight.x += xDiff;
rectFullHeight.width -= std::max(aRadii[eCornerTopRightX],
aRadii[eCornerBottomRightX]) + xDiff;
nsRect r1;
r1.IntersectRect(rectFullHeight, aContainedRect);
nsRect rectFullWidth = aRoundedRect;
nscoord yDiff = std::max(aRadii[eCornerTopLeftY], aRadii[eCornerTopRightY]);
rectFullWidth.y += yDiff;
rectFullWidth.height -= std::max(aRadii[eCornerBottomLeftY],
aRadii[eCornerBottomRightY]) + yDiff;
nsRect r2;
r2.IntersectRect(rectFullWidth, aContainedRect);
nsRegion result;
result.Or(r1, r2);
return result;
}
nsIntRegion
nsLayoutUtils::RoundedRectIntersectIntRect(const nsIntRect& aRoundedRect,
const RectCornerRadii& aCornerRadii,
const nsIntRect& aContainedRect)
{
// rectFullHeight and rectFullWidth together will approximately contain
// the total area of the frame minus the rounded corners.
nsIntRect rectFullHeight = aRoundedRect;
uint32_t xDiff = std::max(aCornerRadii.TopLeft().width,
aCornerRadii.BottomLeft().width);
rectFullHeight.x += xDiff;
rectFullHeight.width -= std::max(aCornerRadii.TopRight().width,
aCornerRadii.BottomRight().width) + xDiff;
nsIntRect r1;
r1.IntersectRect(rectFullHeight, aContainedRect);
nsIntRect rectFullWidth = aRoundedRect;
uint32_t yDiff = std::max(aCornerRadii.TopLeft().height,
aCornerRadii.TopRight().height);
rectFullWidth.y += yDiff;
rectFullWidth.height -= std::max(aCornerRadii.BottomLeft().height,
aCornerRadii.BottomRight().height) + yDiff;
nsIntRect r2;
r2.IntersectRect(rectFullWidth, aContainedRect);
nsIntRegion result;
result.Or(r1, r2);
return result;
}
// Helper for RoundedRectIntersectsRect.
static bool
CheckCorner(nscoord aXOffset, nscoord aYOffset,
nscoord aXRadius, nscoord aYRadius)
{
MOZ_ASSERT(aXOffset > 0 && aYOffset > 0,
"must not pass nonpositives to CheckCorner");
MOZ_ASSERT(aXRadius >= 0 && aYRadius >= 0,
"must not pass negatives to CheckCorner");
// Avoid floating point math unless we're either (1) within the
// quarter-ellipse area at the rounded corner or (2) outside the
// rounding.
if (aXOffset >= aXRadius || aYOffset >= aYRadius)
return true;
// Convert coordinates to a unit circle with (0,0) as the center of
// curvature, and see if we're inside the circle or outside.
float scaledX = float(aXRadius - aXOffset) / float(aXRadius);
float scaledY = float(aYRadius - aYOffset) / float(aYRadius);
return scaledX * scaledX + scaledY * scaledY < 1.0f;
}
bool
nsLayoutUtils::RoundedRectIntersectsRect(const nsRect& aRoundedRect,
const nscoord aRadii[8],
const nsRect& aTestRect)
{
if (!aTestRect.Intersects(aRoundedRect))
return false;
// distances from this edge of aRoundedRect to opposite edge of aTestRect,
// which we know are positive due to the Intersects check above.
nsMargin insets;
insets.top = aTestRect.YMost() - aRoundedRect.y;
insets.right = aRoundedRect.XMost() - aTestRect.x;
insets.bottom = aRoundedRect.YMost() - aTestRect.y;
insets.left = aTestRect.XMost() - aRoundedRect.x;
// Check whether the bottom-right corner of aTestRect is inside the
// top left corner of aBounds when rounded by aRadii, etc. If any
// corner is not, then fail; otherwise succeed.
return CheckCorner(insets.left, insets.top,
aRadii[eCornerTopLeftX],
aRadii[eCornerTopLeftY]) &&
CheckCorner(insets.right, insets.top,
aRadii[eCornerTopRightX],
aRadii[eCornerTopRightY]) &&
CheckCorner(insets.right, insets.bottom,
aRadii[eCornerBottomRightX],
aRadii[eCornerBottomRightY]) &&
CheckCorner(insets.left, insets.bottom,
aRadii[eCornerBottomLeftX],
aRadii[eCornerBottomLeftY]);
}
nsRect
nsLayoutUtils::MatrixTransformRect(const nsRect &aBounds,
const Matrix4x4 &aMatrix, float aFactor)
{
RectDouble image = RectDouble(NSAppUnitsToDoublePixels(aBounds.x, aFactor),
NSAppUnitsToDoublePixels(aBounds.y, aFactor),
NSAppUnitsToDoublePixels(aBounds.width, aFactor),
NSAppUnitsToDoublePixels(aBounds.height, aFactor));
RectDouble maxBounds = RectDouble(double(nscoord_MIN) / aFactor * 0.5,
double(nscoord_MIN) / aFactor * 0.5,
double(nscoord_MAX) / aFactor,
double(nscoord_MAX) / aFactor);
image = aMatrix.TransformAndClipBounds(image, maxBounds);
return RoundGfxRectToAppRect(ThebesRect(image), aFactor);
}
nsPoint
nsLayoutUtils::MatrixTransformPoint(const nsPoint &aPoint,
const Matrix4x4 &aMatrix, float aFactor)
{
gfxPoint image = gfxPoint(NSAppUnitsToFloatPixels(aPoint.x, aFactor),
NSAppUnitsToFloatPixels(aPoint.y, aFactor));
image.Transform(aMatrix);
return nsPoint(NSFloatPixelsToAppUnits(float(image.x), aFactor),
NSFloatPixelsToAppUnits(float(image.y), aFactor));
}
void
nsLayoutUtils::PostTranslate(Matrix4x4& aTransform, const nsPoint& aOrigin, float aAppUnitsPerPixel, bool aRounded)
{
Point3D gfxOrigin =
Point3D(NSAppUnitsToFloatPixels(aOrigin.x, aAppUnitsPerPixel),
NSAppUnitsToFloatPixels(aOrigin.y, aAppUnitsPerPixel),
0.0f);
if (aRounded) {
gfxOrigin.x = NS_round(gfxOrigin.x);
gfxOrigin.y = NS_round(gfxOrigin.y);
}
aTransform.PostTranslate(gfxOrigin);
}
Matrix4x4
nsLayoutUtils::GetTransformToAncestor(nsIFrame *aFrame, const nsIFrame *aAncestor)
{
nsIFrame* parent;
Matrix4x4 ctm;
if (aFrame == aAncestor) {
return ctm;
}
ctm = aFrame->GetTransformMatrix(aAncestor, &parent);
while (parent && parent != aAncestor) {
if (!parent->Extend3DContext()) {
ctm.ProjectTo2D();
}
ctm = ctm * parent->GetTransformMatrix(aAncestor, &parent);
}
return ctm;
}
gfxSize
nsLayoutUtils::GetTransformToAncestorScale(nsIFrame* aFrame)
{
Matrix4x4 transform = GetTransformToAncestor(aFrame,
nsLayoutUtils::GetDisplayRootFrame(aFrame));
Matrix transform2D;
if (transform.Is2D(&transform2D)) {
return ThebesMatrix(transform2D).ScaleFactors(true);
}
return gfxSize(1, 1);
}
static Matrix4x4
GetTransformToAncestorExcludingAnimated(nsIFrame* aFrame,
const nsIFrame* aAncestor)
{
nsIFrame* parent;
Matrix4x4 ctm;
if (aFrame == aAncestor) {
return ctm;
}
if (ActiveLayerTracker::IsScaleSubjectToAnimation(aFrame)) {
return ctm;
}
ctm = aFrame->GetTransformMatrix(aAncestor, &parent);
while (parent && parent != aAncestor) {
if (ActiveLayerTracker::IsScaleSubjectToAnimation(parent)) {
return Matrix4x4();
}
if (!parent->Extend3DContext()) {
ctm.ProjectTo2D();
}
ctm = ctm * parent->GetTransformMatrix(aAncestor, &parent);
}
return ctm;
}
gfxSize
nsLayoutUtils::GetTransformToAncestorScaleExcludingAnimated(nsIFrame* aFrame)
{
Matrix4x4 transform = GetTransformToAncestorExcludingAnimated(aFrame,
nsLayoutUtils::GetDisplayRootFrame(aFrame));
Matrix transform2D;
if (transform.Is2D(&transform2D)) {
return ThebesMatrix(transform2D).ScaleFactors(true);
}
return gfxSize(1, 1);
}
nsIFrame*
nsLayoutUtils::FindNearestCommonAncestorFrame(nsIFrame* aFrame1, nsIFrame* aFrame2)
{
AutoTArray<nsIFrame*,100> ancestors1;
AutoTArray<nsIFrame*,100> ancestors2;
nsIFrame* commonAncestor = nullptr;
if (aFrame1->PresContext() == aFrame2->PresContext()) {
commonAncestor = aFrame1->PresContext()->PresShell()->GetRootFrame();
}
for (nsIFrame* f = aFrame1; f != commonAncestor;
f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
ancestors1.AppendElement(f);
}
for (nsIFrame* f = aFrame2; f != commonAncestor;
f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
ancestors2.AppendElement(f);
}
uint32_t minLengths = std::min(ancestors1.Length(), ancestors2.Length());
for (uint32_t i = 1; i <= minLengths; ++i) {
if (ancestors1[ancestors1.Length() - i] == ancestors2[ancestors2.Length() - i]) {
commonAncestor = ancestors1[ancestors1.Length() - i];
} else {
break;
}
}
return commonAncestor;
}
nsLayoutUtils::TransformResult
nsLayoutUtils::TransformPoints(nsIFrame* aFromFrame, nsIFrame* aToFrame,
uint32_t aPointCount, CSSPoint* aPoints)
{
nsIFrame* nearestCommonAncestor = FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
if (!nearestCommonAncestor) {
return NO_COMMON_ANCESTOR;
}
Matrix4x4 downToDest = GetTransformToAncestor(aToFrame, nearestCommonAncestor);
if (downToDest.IsSingular()) {
return NONINVERTIBLE_TRANSFORM;
}
downToDest.Invert();
Matrix4x4 upToAncestor = GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
CSSToLayoutDeviceScale devPixelsPerCSSPixelFromFrame =
aFromFrame->PresContext()->CSSToDevPixelScale();
CSSToLayoutDeviceScale devPixelsPerCSSPixelToFrame =
aToFrame->PresContext()->CSSToDevPixelScale();
for (uint32_t i = 0; i < aPointCount; ++i) {
LayoutDevicePoint devPixels = aPoints[i] * devPixelsPerCSSPixelFromFrame;
// What should the behaviour be if some of the points aren't invertible
// and others are? Just assume all points are for now.
Point toDevPixels = downToDest.ProjectPoint(
(upToAncestor.TransformPoint(Point(devPixels.x, devPixels.y)))).As2DPoint();
// Divide here so that when the devPixelsPerCSSPixels are the same, we get the correct
// answer instead of some inaccuracy multiplying a number by its reciprocal.
aPoints[i] = LayoutDevicePoint(toDevPixels.x, toDevPixels.y) /
devPixelsPerCSSPixelToFrame;
}
return TRANSFORM_SUCCEEDED;
}
nsLayoutUtils::TransformResult
nsLayoutUtils::TransformPoint(nsIFrame* aFromFrame, nsIFrame* aToFrame,
nsPoint& aPoint)
{
nsIFrame* nearestCommonAncestor = FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
if (!nearestCommonAncestor) {
return NO_COMMON_ANCESTOR;
}
Matrix4x4 downToDest = GetTransformToAncestor(aToFrame, nearestCommonAncestor);
if (downToDest.IsSingular()) {
return NONINVERTIBLE_TRANSFORM;
}
downToDest.Invert();
Matrix4x4 upToAncestor = GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
float devPixelsPerAppUnitFromFrame =
1.0f / aFromFrame->PresContext()->AppUnitsPerDevPixel();
float devPixelsPerAppUnitToFrame =
1.0f / aToFrame->PresContext()->AppUnitsPerDevPixel();
Point4D toDevPixels = downToDest.ProjectPoint(
upToAncestor.TransformPoint(Point(aPoint.x * devPixelsPerAppUnitFromFrame,
aPoint.y * devPixelsPerAppUnitFromFrame)));
if (!toDevPixels.HasPositiveWCoord()) {
// Not strictly true, but we failed to get a valid point in this
// coordinate space.
return NONINVERTIBLE_TRANSFORM;
}
aPoint.x = NSToCoordRound(toDevPixels.x / devPixelsPerAppUnitToFrame);
aPoint.y = NSToCoordRound(toDevPixels.y / devPixelsPerAppUnitToFrame);
return TRANSFORM_SUCCEEDED;
}
nsLayoutUtils::TransformResult
nsLayoutUtils::TransformRect(nsIFrame* aFromFrame, nsIFrame* aToFrame,
nsRect& aRect)
{
nsIFrame* nearestCommonAncestor = FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
if (!nearestCommonAncestor) {
return NO_COMMON_ANCESTOR;
}
Matrix4x4 downToDest = GetTransformToAncestor(aToFrame, nearestCommonAncestor);
if (downToDest.IsSingular()) {
return NONINVERTIBLE_TRANSFORM;
}
downToDest.Invert();
Matrix4x4 upToAncestor = GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
float devPixelsPerAppUnitFromFrame =
1.0f / aFromFrame->PresContext()->AppUnitsPerDevPixel();
float devPixelsPerAppUnitToFrame =
1.0f / aToFrame->PresContext()->AppUnitsPerDevPixel();
gfx::Rect toDevPixels = downToDest.ProjectRectBounds(
upToAncestor.ProjectRectBounds(
gfx::Rect(aRect.x * devPixelsPerAppUnitFromFrame,
aRect.y * devPixelsPerAppUnitFromFrame,
aRect.width * devPixelsPerAppUnitFromFrame,
aRect.height * devPixelsPerAppUnitFromFrame),
Rect(-std::numeric_limits<Float>::max() * 0.5f,
-std::numeric_limits<Float>::max() * 0.5f,
std::numeric_limits<Float>::max(),
std::numeric_limits<Float>::max())),
Rect(-std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame * 0.5f,
-std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame * 0.5f,
std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame,
std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame));
aRect.x = toDevPixels.x / devPixelsPerAppUnitToFrame;
aRect.y = toDevPixels.y / devPixelsPerAppUnitToFrame;
aRect.width = toDevPixels.width / devPixelsPerAppUnitToFrame;
aRect.height = toDevPixels.height / devPixelsPerAppUnitToFrame;
return TRANSFORM_SUCCEEDED;
}
nsRect
nsLayoutUtils::GetRectRelativeToFrame(Element* aElement, nsIFrame* aFrame)
{
if (!aElement || !aFrame) {
return nsRect();
}
nsIFrame* frame = aElement->GetPrimaryFrame();
if (!frame) {
return nsRect();
}
nsRect rect = frame->GetRectRelativeToSelf();
nsLayoutUtils::TransformResult rv =
nsLayoutUtils::TransformRect(frame, aFrame, rect);
if (rv != nsLayoutUtils::TRANSFORM_SUCCEEDED) {
return nsRect();
}
return rect;
}
bool
nsLayoutUtils::ContainsPoint(const nsRect& aRect, const nsPoint& aPoint,
nscoord aInflateSize)
{
nsRect rect = aRect;
rect.Inflate(aInflateSize);
return rect.Contains(aPoint);
}
nsRect
nsLayoutUtils::ClampRectToScrollFrames(nsIFrame* aFrame, const nsRect& aRect)
{
nsIFrame* closestScrollFrame =
nsLayoutUtils::GetClosestFrameOfType(aFrame, nsGkAtoms::scrollFrame);
nsRect resultRect = aRect;
while (closestScrollFrame) {
nsIScrollableFrame* sf = do_QueryFrame(closestScrollFrame);
nsRect scrollPortRect = sf->GetScrollPortRect();
nsLayoutUtils::TransformRect(closestScrollFrame, aFrame, scrollPortRect);
resultRect = resultRect.Intersect(scrollPortRect);
// Check whether aRect is visible in the scroll frame or not.
if (resultRect.IsEmpty()) {
break;
}
// Get next ancestor scroll frame.
closestScrollFrame =
nsLayoutUtils::GetClosestFrameOfType(closestScrollFrame->GetParent(),
nsGkAtoms::scrollFrame);
}
return resultRect;
}
bool
nsLayoutUtils::GetLayerTransformForFrame(nsIFrame* aFrame,
Matrix4x4* aTransform)
{
// FIXME/bug 796690: we can sometimes compute a transform in these
// cases, it just increases complexity considerably. Punt for now.
if (aFrame->Extend3DContext() || aFrame->HasTransformGetter()) {
return false;
}
nsIFrame* root = nsLayoutUtils::GetDisplayRootFrame(aFrame);
if (root->HasAnyStateBits(NS_FRAME_UPDATE_LAYER_TREE)) {
// Content may have been invalidated, so we can't reliably compute
// the "layer transform" in general.
return false;
}
// If the caller doesn't care about the value, early-return to skip
// overhead below.
if (!aTransform) {
return true;
}
nsDisplayListBuilder builder(root,
nsDisplayListBuilderMode::TRANSFORM_COMPUTATION,
false/*don't build caret*/);
nsDisplayList list;
nsDisplayTransform* item =
new (&builder) nsDisplayTransform(&builder, aFrame, &list, nsRect());
*aTransform = item->GetTransform();
item->~nsDisplayTransform();
return true;
}
static bool
TransformGfxPointFromAncestor(nsIFrame *aFrame,
const Point &aPoint,
nsIFrame *aAncestor,
Point* aOut)
{
Matrix4x4 ctm = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor);
ctm.Invert();
Point4D point = ctm.ProjectPoint(aPoint);
if (!point.HasPositiveWCoord()) {
return false;
}
*aOut = point.As2DPoint();
return true;
}
static Rect
TransformGfxRectToAncestor(nsIFrame *aFrame,
const Rect &aRect,
const nsIFrame *aAncestor,
bool* aPreservesAxisAlignedRectangles = nullptr,
Maybe<Matrix4x4>* aMatrixCache = nullptr)
{
Matrix4x4 ctm;
if (aMatrixCache && *aMatrixCache) {
// We are given a matrix to use, so use it
ctm = aMatrixCache->value();
} else {
// Else, compute it
ctm = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor);
if (aMatrixCache) {
// and put it in the cache, if provided
*aMatrixCache = Some(ctm);
}
}
// Fill out the axis-alignment flag
if (aPreservesAxisAlignedRectangles) {
Matrix matrix2d;
*aPreservesAxisAlignedRectangles =
ctm.Is2D(&matrix2d) && matrix2d.PreservesAxisAlignedRectangles();
}
Rect maxBounds = Rect(-std::numeric_limits<float>::max() * 0.5,
-std::numeric_limits<float>::max() * 0.5,
std::numeric_limits<float>::max(),
std::numeric_limits<float>::max());
return ctm.TransformAndClipBounds(aRect, maxBounds);
}
static SVGTextFrame*
GetContainingSVGTextFrame(nsIFrame* aFrame)
{
if (!aFrame->IsSVGText()) {
return nullptr;
}
return static_cast<SVGTextFrame*>
(nsLayoutUtils::GetClosestFrameOfType(aFrame->GetParent(),
nsGkAtoms::svgTextFrame));
}
nsPoint
nsLayoutUtils::TransformAncestorPointToFrame(nsIFrame* aFrame,
const nsPoint& aPoint,
nsIFrame* aAncestor)
{
SVGTextFrame* text = GetContainingSVGTextFrame(aFrame);
float factor = aFrame->PresContext()->AppUnitsPerDevPixel();
Point result(NSAppUnitsToFloatPixels(aPoint.x, factor),
NSAppUnitsToFloatPixels(aPoint.y, factor));
if (text) {
if (!TransformGfxPointFromAncestor(text, result, aAncestor, &result)) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
result = text->TransformFramePointToTextChild(result, aFrame);
} else {
if (!TransformGfxPointFromAncestor(aFrame, result, nullptr, &result)) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
}
return nsPoint(NSFloatPixelsToAppUnits(float(result.x), factor),
NSFloatPixelsToAppUnits(float(result.y), factor));
}
nsRect
nsLayoutUtils::TransformFrameRectToAncestor(nsIFrame* aFrame,
const nsRect& aRect,
const nsIFrame* aAncestor,
bool* aPreservesAxisAlignedRectangles /* = nullptr */,
Maybe<Matrix4x4>* aMatrixCache /* = nullptr */)
{
SVGTextFrame* text = GetContainingSVGTextFrame(aFrame);
float srcAppUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
Rect result;
if (text) {
result = ToRect(text->TransformFrameRectFromTextChild(aRect, aFrame));
result = TransformGfxRectToAncestor(text, result, aAncestor, nullptr, aMatrixCache);
// TransformFrameRectFromTextChild could involve any kind of transform, we
// could drill down into it to get an answer out of it but we don't yet.
if (aPreservesAxisAlignedRectangles)
*aPreservesAxisAlignedRectangles = false;
} else {
result = Rect(NSAppUnitsToFloatPixels(aRect.x, srcAppUnitsPerDevPixel),
NSAppUnitsToFloatPixels(aRect.y, srcAppUnitsPerDevPixel),
NSAppUnitsToFloatPixels(aRect.width, srcAppUnitsPerDevPixel),
NSAppUnitsToFloatPixels(aRect.height, srcAppUnitsPerDevPixel));
result = TransformGfxRectToAncestor(aFrame, result, aAncestor, aPreservesAxisAlignedRectangles, aMatrixCache);
}
float destAppUnitsPerDevPixel = aAncestor->PresContext()->AppUnitsPerDevPixel();
return nsRect(NSFloatPixelsToAppUnits(float(result.x), destAppUnitsPerDevPixel),
NSFloatPixelsToAppUnits(float(result.y), destAppUnitsPerDevPixel),
NSFloatPixelsToAppUnits(float(result.width), destAppUnitsPerDevPixel),
NSFloatPixelsToAppUnits(float(result.height), destAppUnitsPerDevPixel));
}
static LayoutDeviceIntPoint GetWidgetOffset(nsIWidget* aWidget, nsIWidget*& aRootWidget) {
LayoutDeviceIntPoint offset(0, 0);
while ((aWidget->WindowType() == eWindowType_child ||
aWidget->IsPlugin())) {
nsIWidget* parent = aWidget->GetParent();
if (!parent) {
break;
}
LayoutDeviceIntRect bounds = aWidget->GetBounds();
offset += bounds.TopLeft();
aWidget = parent;
}
aRootWidget = aWidget;
return offset;
}
static LayoutDeviceIntPoint
WidgetToWidgetOffset(nsIWidget* aFrom, nsIWidget* aTo) {
nsIWidget* fromRoot;
LayoutDeviceIntPoint fromOffset = GetWidgetOffset(aFrom, fromRoot);
nsIWidget* toRoot;
LayoutDeviceIntPoint toOffset = GetWidgetOffset(aTo, toRoot);
if (fromRoot == toRoot) {
return fromOffset - toOffset;
}
return aFrom->WidgetToScreenOffset() - aTo->WidgetToScreenOffset();
}
nsPoint
nsLayoutUtils::TranslateWidgetToView(nsPresContext* aPresContext,
nsIWidget* aWidget, const LayoutDeviceIntPoint& aPt,
nsView* aView)
{
nsPoint viewOffset;
nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
if (!viewWidget) {
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
LayoutDeviceIntPoint widgetPoint = aPt + WidgetToWidgetOffset(aWidget, viewWidget);
nsPoint widgetAppUnits(aPresContext->DevPixelsToAppUnits(widgetPoint.x),
aPresContext->DevPixelsToAppUnits(widgetPoint.y));
return widgetAppUnits - viewOffset;
}
LayoutDeviceIntPoint
nsLayoutUtils::TranslateViewToWidget(nsPresContext* aPresContext,
nsView* aView, nsPoint aPt,
nsIWidget* aWidget)
{
nsPoint viewOffset;
nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
if (!viewWidget) {
return LayoutDeviceIntPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
nsPoint pt = (aPt +
viewOffset).ApplyResolution(GetCurrentAPZResolutionScale(aPresContext->PresShell()));
LayoutDeviceIntPoint relativeToViewWidget(aPresContext->AppUnitsToDevPixels(pt.x),
aPresContext->AppUnitsToDevPixels(pt.y));
return relativeToViewWidget + WidgetToWidgetOffset(viewWidget, aWidget);
}
// Combine aNewBreakType with aOrigBreakType, but limit the break types
// to StyleClear::Left, Right, Both.
StyleClear
nsLayoutUtils::CombineBreakType(StyleClear aOrigBreakType,
StyleClear aNewBreakType)
{
StyleClear breakType = aOrigBreakType;
switch(breakType) {
case StyleClear::Left:
if (StyleClear::Right == aNewBreakType ||
StyleClear::Both == aNewBreakType) {
breakType = StyleClear::Both;
}
break;
case StyleClear::Right:
if (StyleClear::Left == aNewBreakType ||
StyleClear::Both == aNewBreakType) {
breakType = StyleClear::Both;
}
break;
case StyleClear::None:
if (StyleClear::Left == aNewBreakType ||
StyleClear::Right == aNewBreakType ||
StyleClear::Both == aNewBreakType) {
breakType = aNewBreakType;
}
break;
default:
break;
}
return breakType;
}
#ifdef MOZ_DUMP_PAINTING
#include <stdio.h>
static bool gDumpEventList = false;
// nsLayoutUtils::PaintFrame() can call itself recursively, so rather than
// maintaining a single paint count, we need a stack.
StaticAutoPtr<nsTArray<int>> gPaintCountStack;
struct AutoNestedPaintCount {
AutoNestedPaintCount() {
gPaintCountStack->AppendElement(0);
}
~AutoNestedPaintCount() {
gPaintCountStack->RemoveElementAt(gPaintCountStack->Length() - 1);
}
};
#endif
nsIFrame*
nsLayoutUtils::GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt, uint32_t aFlags)
{
PROFILER_LABEL("nsLayoutUtils", "GetFrameForPoint",
js::ProfileEntry::Category::GRAPHICS);
nsresult rv;
AutoTArray<nsIFrame*,8> outFrames;
rv = GetFramesForArea(aFrame, nsRect(aPt, nsSize(1, 1)), outFrames, aFlags);
NS_ENSURE_SUCCESS(rv, nullptr);
return outFrames.Length() ? outFrames.ElementAt(0) : nullptr;
}
nsresult
nsLayoutUtils::GetFramesForArea(nsIFrame* aFrame, const nsRect& aRect,
nsTArray<nsIFrame*> &aOutFrames,
uint32_t aFlags)
{
PROFILER_LABEL("nsLayoutUtils", "GetFramesForArea",
js::ProfileEntry::Category::GRAPHICS);
nsDisplayListBuilder builder(aFrame,
nsDisplayListBuilderMode::EVENT_DELIVERY,
false);
nsDisplayList list;
if (aFlags & IGNORE_PAINT_SUPPRESSION) {
builder.IgnorePaintSuppression();
}
if (aFlags & IGNORE_ROOT_SCROLL_FRAME) {
nsIFrame* rootScrollFrame =
aFrame->PresContext()->PresShell()->GetRootScrollFrame();
if (rootScrollFrame) {
builder.SetIgnoreScrollFrame(rootScrollFrame);
}
}
if (aFlags & IGNORE_CROSS_DOC) {
builder.SetDescendIntoSubdocuments(false);
}
builder.EnterPresShell(aFrame);
aFrame->BuildDisplayListForStackingContext(&builder, aRect, &list);
builder.LeavePresShell(aFrame, nullptr);
#ifdef MOZ_DUMP_PAINTING
if (gDumpEventList) {
fprintf_stderr(stderr, "Event handling --- (%d,%d):\n", aRect.x, aRect.y);
std::stringstream ss;
nsFrame::PrintDisplayList(&builder, list, ss);
print_stderr(ss);
}
#endif
nsDisplayItem::HitTestState hitTestState;
builder.SetHitTestShouldStopAtFirstOpaque(aFlags & ONLY_VISIBLE);
list.HitTest(&builder, aRect, &hitTestState, &aOutFrames);
list.DeleteAll();
return NS_OK;
}
// aScrollFrameAsScrollable must be non-nullptr and queryable to an nsIFrame
FrameMetrics
nsLayoutUtils::CalculateBasicFrameMetrics(nsIScrollableFrame* aScrollFrame) {
nsIFrame* frame = do_QueryFrame(aScrollFrame);
MOZ_ASSERT(frame);
// Calculate the metrics necessary for calculating the displayport.
// This code has a lot in common with the code in ComputeFrameMetrics();
// we may want to refactor this at some point.
FrameMetrics metrics;
nsPresContext* presContext = frame->PresContext();
nsIPresShell* presShell = presContext->PresShell();
CSSToLayoutDeviceScale deviceScale = presContext->CSSToDevPixelScale();
float resolution = 1.0f;
if (frame == presShell->GetRootScrollFrame()) {
// Only the root scrollable frame for a given presShell should pick up
// the presShell's resolution. All the other frames are 1.0.
resolution = presShell->GetResolution();
}
// Note: unlike in ComputeFrameMetrics(), we don't know the full cumulative
// resolution including FrameMetrics::mExtraResolution, because layout hasn't
// chosen a resolution to paint at yet. However, the display port calculation
// divides out mExtraResolution anyways, so we get the correct result by
// setting the mCumulativeResolution to everything except the extra resolution
// and leaving mExtraResolution at 1.
LayoutDeviceToLayerScale2D cumulativeResolution(
presShell->GetCumulativeResolution()
* nsLayoutUtils::GetTransformToAncestorScale(frame));
LayerToParentLayerScale layerToParentLayerScale(1.0f);
metrics.SetDevPixelsPerCSSPixel(deviceScale);
metrics.SetPresShellResolution(resolution);
metrics.SetCumulativeResolution(cumulativeResolution);
metrics.SetZoom(deviceScale * cumulativeResolution * layerToParentLayerScale);
// Only the size of the composition bounds is relevant to the
// displayport calculation, not its origin.
nsSize compositionSize = nsLayoutUtils::CalculateCompositionSizeForFrame(frame);
LayoutDeviceToParentLayerScale2D compBoundsScale;
if (frame == presShell->GetRootScrollFrame() && presContext->IsRootContentDocument()) {
if (presContext->GetParentPresContext()) {
float res = presContext->GetParentPresContext()->PresShell()->GetCumulativeResolution();
compBoundsScale = LayoutDeviceToParentLayerScale2D(
LayoutDeviceToParentLayerScale(res));
}
} else {
compBoundsScale = cumulativeResolution * layerToParentLayerScale;
}
metrics.SetCompositionBounds(
LayoutDeviceRect::FromAppUnits(nsRect(nsPoint(0, 0), compositionSize),
presContext->AppUnitsPerDevPixel())
* compBoundsScale);
metrics.SetRootCompositionSize(
nsLayoutUtils::CalculateRootCompositionSize(frame, false, metrics));
metrics.SetScrollOffset(CSSPoint::FromAppUnits(
aScrollFrame->GetScrollPosition()));
metrics.SetScrollableRect(CSSRect::FromAppUnits(
nsLayoutUtils::CalculateScrollableRectForFrame(aScrollFrame, nullptr)));
return metrics;
}
bool
nsLayoutUtils::CalculateAndSetDisplayPortMargins(nsIScrollableFrame* aScrollFrame,
RepaintMode aRepaintMode) {
nsIFrame* frame = do_QueryFrame(aScrollFrame);
MOZ_ASSERT(frame);
nsIContent* content = frame->GetContent();
MOZ_ASSERT(content);
FrameMetrics metrics = CalculateBasicFrameMetrics(aScrollFrame);
ScreenMargin displayportMargins = APZCTreeManager::CalculatePendingDisplayPort(
metrics, ParentLayerPoint(0.0f, 0.0f));
nsIPresShell* presShell = frame->PresContext()->GetPresShell();
return nsLayoutUtils::SetDisplayPortMargins(
content, presShell, displayportMargins, 0, aRepaintMode);
}
void
nsLayoutUtils::MaybeCreateDisplayPort(nsDisplayListBuilder& aBuilder,
nsIFrame* aScrollFrame) {
nsIContent* content = aScrollFrame->GetContent();
nsIScrollableFrame* scrollableFrame = do_QueryFrame(aScrollFrame);
if (!content || !scrollableFrame) {
return;
}
bool haveDisplayPort = HasDisplayPort(content);
// We perform an optimization where we ensure that at least one
// async-scrollable frame (i.e. one that WantsAsyncScroll()) has a displayport.
// If that's not the case yet, and we are async-scrollable, we will get a
// displayport.
if (aBuilder.IsPaintingToWindow() &&
nsLayoutUtils::AsyncPanZoomEnabled(aScrollFrame) &&
!aBuilder.HaveScrollableDisplayPort() &&
scrollableFrame->WantAsyncScroll()) {
// If we don't already have a displayport, calculate and set one.
if (!haveDisplayPort) {
CalculateAndSetDisplayPortMargins(scrollableFrame, nsLayoutUtils::RepaintMode::DoNotRepaint);
#ifdef DEBUG
haveDisplayPort = HasDisplayPort(content);
MOZ_ASSERT(haveDisplayPort, "should have a displayport after having just set it");
#endif
}
// Record that the we now have a scrollable display port.
aBuilder.SetHaveScrollableDisplayPort();
}
}
nsIScrollableFrame*
nsLayoutUtils::GetAsyncScrollableAncestorFrame(nsIFrame* aTarget)
{
uint32_t flags = nsLayoutUtils::SCROLLABLE_ALWAYS_MATCH_ROOT
| nsLayoutUtils::SCROLLABLE_ONLY_ASYNC_SCROLLABLE
| nsLayoutUtils::SCROLLABLE_FIXEDPOS_FINDS_ROOT;
return nsLayoutUtils::GetNearestScrollableFrame(aTarget, flags);
}
void
nsLayoutUtils::SetZeroMarginDisplayPortOnAsyncScrollableAncestors(nsIFrame* aFrame,
RepaintMode aRepaintMode)
{
nsIFrame* frame = aFrame;
while (frame) {
frame = nsLayoutUtils::GetCrossDocParentFrame(frame);
if (!frame) {
break;
}
nsIScrollableFrame* scrollAncestor = GetAsyncScrollableAncestorFrame(frame);
if (!scrollAncestor) {
break;
}
frame = do_QueryFrame(scrollAncestor);
MOZ_ASSERT(frame);
MOZ_ASSERT(scrollAncestor->WantAsyncScroll() ||
frame->PresContext()->PresShell()->GetRootScrollFrame() == frame);
if (nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
!nsLayoutUtils::HasDisplayPort(frame->GetContent())) {
nsLayoutUtils::SetDisplayPortMargins(
frame->GetContent(), frame->PresContext()->PresShell(), ScreenMargin(), 0,
aRepaintMode);
}
}
}
void
nsLayoutUtils::ExpireDisplayPortOnAsyncScrollableAncestor(nsIFrame* aFrame)
{
nsIFrame* frame = aFrame;
while (frame) {
frame = nsLayoutUtils::GetCrossDocParentFrame(frame);
if (!frame) {
break;
}
nsIScrollableFrame* scrollAncestor = GetAsyncScrollableAncestorFrame(frame);
if (!scrollAncestor) {
break;
}
frame = do_QueryFrame(scrollAncestor);
MOZ_ASSERT(frame);
MOZ_ASSERT(scrollAncestor->WantAsyncScroll() ||
frame->PresContext()->PresShell()->GetRootScrollFrame() == frame);
if (nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
nsLayoutUtils::HasDisplayPort(frame->GetContent())) {
scrollAncestor->TriggerDisplayPortExpiration();
// Stop after the first trigger. If it failed, there's no point in
// continuing because all the rest of the frames we encounter are going
// to be ancestors of |scrollAncestor| which will keep its displayport.
// If the trigger succeeded, we stop because when the trigger executes
// it will call this function again to trigger the next ancestor up the
// chain.
break;
}
}
}
nsresult
nsLayoutUtils::PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
const nsRegion& aDirtyRegion, nscolor aBackstop,
nsDisplayListBuilderMode aBuilderMode,
PaintFrameFlags aFlags)
{
PROFILER_LABEL("nsLayoutUtils", "PaintFrame",
js::ProfileEntry::Category::GRAPHICS);
#ifdef MOZ_DUMP_PAINTING
if (!gPaintCountStack) {
gPaintCountStack = new nsTArray<int>();
ClearOnShutdown(&gPaintCountStack);
gPaintCountStack->AppendElement(0);
}
++gPaintCountStack->LastElement();
AutoNestedPaintCount nestedPaintCount;
#endif
if (aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) {
nsView* view = aFrame->GetView();
if (!(view && view->GetWidget() && GetDisplayRootFrame(aFrame) == aFrame)) {
aFlags &= ~PaintFrameFlags::PAINT_WIDGET_LAYERS;
NS_ASSERTION(aRenderingContext, "need a rendering context");
}
}
nsPresContext* presContext = aFrame->PresContext();
nsIPresShell* presShell = presContext->PresShell();
nsRootPresContext* rootPresContext = presContext->GetRootPresContext();
if (!rootPresContext) {
return NS_OK;
}
TimeStamp startBuildDisplayList = TimeStamp::Now();
nsDisplayListBuilder builder(aFrame, aBuilderMode,
!(aFlags & PaintFrameFlags::PAINT_HIDE_CARET));
if (aFlags & PaintFrameFlags::PAINT_IN_TRANSFORM) {
builder.SetInTransform(true);
}
if (aFlags & PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES) {
builder.SetSyncDecodeImages(true);
}
if (aFlags & (PaintFrameFlags::PAINT_WIDGET_LAYERS |
PaintFrameFlags::PAINT_TO_WINDOW)) {
builder.SetPaintingToWindow(true);
}
if (aFlags & PaintFrameFlags::PAINT_IGNORE_SUPPRESSION) {
builder.IgnorePaintSuppression();
}
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
if (rootScrollFrame && !aFrame->GetParent()) {
nsIScrollableFrame* rootScrollableFrame = presShell->GetRootScrollFrameAsScrollable();
MOZ_ASSERT(rootScrollableFrame);
nsRect displayPortBase = aFrame->GetVisualOverflowRectRelativeToSelf();
Unused << rootScrollableFrame->DecideScrollableLayer(&builder, &displayPortBase,
/* aAllowCreateDisplayPort = */ true);
}
nsRegion visibleRegion;
if (aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) {
// This layer tree will be reused, so we'll need to calculate it
// for the whole "visible" area of the window
//
// |ignoreViewportScrolling| and |usingDisplayPort| are persistent
// document-rendering state. We rely on PresShell to flush
// retained layers as needed when that persistent state changes.
visibleRegion = aFrame->GetVisualOverflowRectRelativeToSelf();
} else {
visibleRegion = aDirtyRegion;
}
nsDisplayList list;
// If the root has embedded plugins, flag the builder so we know we'll need
// to update plugin geometry after painting.
if ((aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) &&
!(aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE) &&
rootPresContext->NeedToComputePluginGeometryUpdates()) {
builder.SetWillComputePluginGeometry(true);
}
nsRect canvasArea(nsPoint(0, 0), aFrame->GetSize());
bool ignoreViewportScrolling =
aFrame->GetParent() ? false : presShell->IgnoringViewportScrolling();
if (ignoreViewportScrolling && rootScrollFrame) {
nsIScrollableFrame* rootScrollableFrame =
presShell->GetRootScrollFrameAsScrollable();
if (aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE) {
// Make visibleRegion and aRenderingContext relative to the
// scrolled frame instead of the root frame.
nsPoint pos = rootScrollableFrame->GetScrollPosition();
visibleRegion.MoveBy(-pos);
if (aRenderingContext) {
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(pos,
presContext->AppUnitsPerDevPixel());
aRenderingContext->ThebesContext()->SetMatrix(
aRenderingContext->ThebesContext()->CurrentMatrix().Translate(devPixelOffset));
}
}
builder.SetIgnoreScrollFrame(rootScrollFrame);
nsCanvasFrame* canvasFrame =
do_QueryFrame(rootScrollableFrame->GetScrolledFrame());
if (canvasFrame) {
// Use UnionRect here to ensure that areas where the scrollbars
// were are still filled with the background color.
canvasArea.UnionRect(canvasArea,
canvasFrame->CanvasArea() + builder.ToReferenceFrame(canvasFrame));
}
}
builder.EnterPresShell(aFrame);
nsRect dirtyRect = visibleRegion.GetBounds();
{
// If a scrollable container layer is created in nsDisplayList::PaintForFrame,
// it will be the scroll parent for display items that are built in the
// BuildDisplayListForStackingContext call below. We need to set the scroll
// parent on the display list builder while we build those items, so that they
// can pick up their scroll parent's id.
ViewID id = FrameMetrics::NULL_SCROLL_ID;
if (ignoreViewportScrolling && presContext->IsRootContentDocument()) {
if (nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame()) {
if (nsIContent* content = rootScrollFrame->GetContent()) {
id = nsLayoutUtils::FindOrCreateIDFor(content);
}
}
}
else if (presShell->GetDocument() && presShell->GetDocument()->IsRootDisplayDocument()
&& !presShell->GetRootScrollFrame()) {
// In cases where the root document is a XUL document, we want to take
// the ViewID from the root element, as that will be the ViewID of the
// root APZC in the tree. Skip doing this in cases where we know
// nsGfxScrollFrame::BuilDisplayList will do it instead.
if (dom::Element* element = presShell->GetDocument()->GetDocumentElement()) {
id = nsLayoutUtils::FindOrCreateIDFor(element);
}
}
nsDisplayListBuilder::AutoCurrentScrollParentIdSetter idSetter(&builder, id);
PROFILER_LABEL("nsLayoutUtils", "PaintFrame::BuildDisplayList",
js::ProfileEntry::Category::GRAPHICS);
PaintTelemetry::AutoRecord record(PaintTelemetry::Metric::DisplayList);
aFrame->BuildDisplayListForStackingContext(&builder, dirtyRect, &list);
}
nsIAtom* frameType = aFrame->GetType();
// For the viewport frame in print preview/page layout we want to paint
// the grey background behind the page, not the canvas color.
if (frameType == nsGkAtoms::viewportFrame &&
nsLayoutUtils::NeedsPrintPreviewBackground(presContext)) {
nsRect bounds = nsRect(builder.ToReferenceFrame(aFrame),
aFrame->GetSize());
nsDisplayListBuilder::AutoBuildingDisplayList
buildingDisplayList(&builder, aFrame, bounds, false);
presShell->AddPrintPreviewBackgroundItem(builder, list, aFrame, bounds);
} else if (frameType != nsGkAtoms::pageFrame) {
// For printing, this function is first called on an nsPageFrame, which
// creates a display list with a PageContent item. The PageContent item's
// paint function calls this function on the nsPageFrame's child which is
// an nsPageContentFrame. We only want to add the canvas background color
// item once, for the nsPageContentFrame.
// Add the canvas background color to the bottom of the list. This
// happens after we've built the list so that AddCanvasBackgroundColorItem
// can monkey with the contents if necessary.
canvasArea.IntersectRect(canvasArea, visibleRegion.GetBounds());
nsDisplayListBuilder::AutoBuildingDisplayList
buildingDisplayList(&builder, aFrame, canvasArea, false);
presShell->AddCanvasBackgroundColorItem(
builder, list, aFrame, canvasArea, aBackstop);
}
builder.LeavePresShell(aFrame, &list);
Telemetry::AccumulateTimeDelta(Telemetry::PAINT_BUILD_DISPLAYLIST_TIME,
startBuildDisplayList);
bool profilerNeedsDisplayList = profiler_feature_active("displaylistdump");
bool consoleNeedsDisplayList = gfxUtils::DumpDisplayList() || gfxEnv::DumpPaint();
#ifdef MOZ_DUMP_PAINTING
FILE* savedDumpFile = gfxUtils::sDumpPaintFile;
#endif
UniquePtr<std::stringstream> ss;
if (consoleNeedsDisplayList || profilerNeedsDisplayList) {
ss = MakeUnique<std::stringstream>();
#ifdef MOZ_DUMP_PAINTING
if (gfxEnv::DumpPaintToFile()) {
nsCString string("dump-");
// Include the process ID in the dump file name, to make sure that in an
// e10s setup different processes don't clobber each other's dump files.
string.AppendInt(getpid());
for (int paintCount : *gPaintCountStack) {
string.AppendLiteral("-");
string.AppendInt(paintCount);
}
string.AppendLiteral(".html");
gfxUtils::sDumpPaintFile = fopen(string.BeginReading(), "w");
} else {
gfxUtils::sDumpPaintFile = stderr;
}
if (gfxEnv::DumpPaintToFile()) {
*ss << "<html><head><script>\n"
"var array = {};\n"
"function ViewImage(index) { \n"
" var image = document.getElementById(index);\n"
" if (image.src) {\n"
" image.removeAttribute('src');\n"
" } else {\n"
" image.src = array[index];\n"
" }\n"
"}</script></head><body>";
}
#endif
*ss << nsPrintfCString("Painting --- before optimization (dirty %d,%d,%d,%d):\n",
dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height).get();
nsFrame::PrintDisplayList(&builder, list, *ss, gfxEnv::DumpPaintToFile());
if (gfxEnv::DumpPaint() || gfxEnv::DumpPaintItems()) {
// Flush stream now to avoid reordering dump output relative to
// messages dumped by PaintRoot below.
if (profilerNeedsDisplayList && !consoleNeedsDisplayList) {
profiler_log(ss->str().c_str());
} else {
// Send to the console which will send to the profiler if required.
fprint_stderr(gfxUtils::sDumpPaintFile, *ss);
}
ss = MakeUnique<std::stringstream>();
}
}
uint32_t flags = nsDisplayList::PAINT_DEFAULT;
if (aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) {
flags |= nsDisplayList::PAINT_USE_WIDGET_LAYERS;
if (!(aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE)) {
nsIWidget *widget = aFrame->GetNearestWidget();
if (widget) {
// If we're finished building display list items for painting of the outermost
// pres shell, notify the widget about any toolbars we've encountered.
widget->UpdateThemeGeometries(builder.GetThemeGeometries());
}
}
}
if (aFlags & PaintFrameFlags::PAINT_EXISTING_TRANSACTION) {
flags |= nsDisplayList::PAINT_EXISTING_TRANSACTION;
}
if (aFlags & PaintFrameFlags::PAINT_NO_COMPOSITE) {
flags |= nsDisplayList::PAINT_NO_COMPOSITE;
}
if (aFlags & PaintFrameFlags::PAINT_COMPRESSED) {
flags |= nsDisplayList::PAINT_COMPRESSED;
}
TimeStamp paintStart = TimeStamp::Now();
RefPtr<LayerManager> layerManager
= list.PaintRoot(&builder, aRenderingContext, flags);
Telemetry::AccumulateTimeDelta(Telemetry::PAINT_RASTERIZE_TIME,
paintStart);
if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) {
TimeStamp now = TimeStamp::Now();
float rasterizeTime = (now - paintStart).ToMilliseconds();
uint32_t pixelCount = layerManager->GetAndClearPaintedPixelCount();
static std::vector<std::pair<TimeStamp, uint32_t>> history;
if (pixelCount) {
history.push_back(std::make_pair(now, pixelCount));
}
uint32_t paintedInLastSecond = 0;
for (auto i = history.begin(); i != history.end(); i++) {
if ((now - i->first).ToMilliseconds() > 1000.0f) {
// more than 1000ms ago, don't count it
continue;
}
if (paintedInLastSecond == 0) {
// This is the first one in the last 1000ms, so drop everything earlier
history.erase(history.begin(), i);
i = history.begin();
}
paintedInLastSecond += i->second;
MOZ_ASSERT(paintedInLastSecond); // all historical pixel counts are > 0
}
printf_stderr("Painted %u pixels in %fms (%u in the last 1000ms)\n",
pixelCount, rasterizeTime, paintedInLastSecond);
}
if (consoleNeedsDisplayList || profilerNeedsDisplayList) {
*ss << "Painting --- after optimization:\n";
nsFrame::PrintDisplayList(&builder, list, *ss, gfxEnv::DumpPaintToFile());
*ss << "Painting --- layer tree:\n";
if (layerManager) {
FrameLayerBuilder::DumpRetainedLayerTree(layerManager, *ss,
gfxEnv::DumpPaintToFile());
}
if (profilerNeedsDisplayList && !consoleNeedsDisplayList) {
profiler_log(ss->str().c_str());
} else {
// Send to the console which will send to the profiler if required.
fprint_stderr(gfxUtils::sDumpPaintFile, *ss);
}
#ifdef MOZ_DUMP_PAINTING
if (gfxEnv::DumpPaintToFile()) {
*ss << "</body></html>";
}
if (gfxEnv::DumpPaintToFile()) {
fclose(gfxUtils::sDumpPaintFile);
}
gfxUtils::sDumpPaintFile = savedDumpFile;
#endif
std::stringstream lsStream;
nsFrame::PrintDisplayList(&builder, list, lsStream);
layerManager->GetRoot()->SetDisplayListLog(lsStream.str().c_str());
}
#ifdef MOZ_DUMP_PAINTING
if (gfxPrefs::DumpClientLayers()) {
std::stringstream ss;
FrameLayerBuilder::DumpRetainedLayerTree(layerManager, ss, false);
print_stderr(ss);
}
#endif
// Update the widget's opaque region information. This sets
// glass boundaries on Windows. Also set up the window dragging region
// and plugin clip regions and bounds.
if ((aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) &&
!(aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE)) {
nsIWidget *widget = aFrame->GetNearestWidget();
if (widget) {
nsRegion opaqueRegion;
opaqueRegion.And(builder.GetWindowExcludeGlassRegion(), builder.GetWindowOpaqueRegion());
widget->UpdateOpaqueRegion(
LayoutDeviceIntRegion::FromUnknownRegion(
opaqueRegion.ToNearestPixels(presContext->AppUnitsPerDevPixel())));
widget->UpdateWindowDraggingRegion(builder.GetWindowDraggingRegion());
}
}
if (builder.WillComputePluginGeometry()) {
// For single process compute and apply plugin geometry updates to plugin
// windows, then request composition. For content processes skip eveything
// except requesting composition. Geometry updates were calculated and
// shipped to the chrome process in nsDisplayList when the layer
// transaction completed.
if (XRE_IsParentProcess()) {
rootPresContext->ComputePluginGeometryUpdates(aFrame, &builder, &list);
// We're not going to get a WillPaintWindow event here if we didn't do
// widget invalidation, so just apply the plugin geometry update here
// instead. We could instead have the compositor send back an equivalent
// to WillPaintWindow, but it should be close enough to now not to matter.
if (layerManager && !layerManager->NeedsWidgetInvalidation()) {
rootPresContext->ApplyPluginGeometryUpdates();
}
}
// We told the compositor thread not to composite when it received the
// transaction because we wanted to update plugins first. Schedule the
// composite now.
if (layerManager) {
layerManager->Composite();
}
}
// Flush the list so we don't trigger the IsEmpty-on-destruction assertion
list.DeleteAll();
return NS_OK;
}
/**
* Uses a binary search for find where the cursor falls in the line of text
* It also keeps track of the part of the string that has already been measured
* so it doesn't have to keep measuring the same text over and over
*
* @param "aBaseWidth" contains the width in twips of the portion
* of the text that has already been measured, and aBaseInx contains
* the index of the text that has already been measured.
*
* @param aTextWidth returns the (in twips) the length of the text that falls
* before the cursor aIndex contains the index of the text where the cursor falls
*/
bool
nsLayoutUtils::BinarySearchForPosition(DrawTarget* aDrawTarget,
nsFontMetrics& aFontMetrics,
const char16_t* aText,
int32_t aBaseWidth,
int32_t aBaseInx,
int32_t aStartInx,
int32_t aEndInx,
int32_t aCursorPos,
int32_t& aIndex,
int32_t& aTextWidth)
{
int32_t range = aEndInx - aStartInx;
if ((range == 1) || (range == 2 && NS_IS_HIGH_SURROGATE(aText[aStartInx]))) {
aIndex = aStartInx + aBaseInx;
aTextWidth = nsLayoutUtils::AppUnitWidthOfString(aText, aIndex,
aFontMetrics, aDrawTarget);
return true;
}
int32_t inx = aStartInx + (range / 2);
// Make sure we don't leave a dangling low surrogate
if (NS_IS_HIGH_SURROGATE(aText[inx-1]))
inx++;
int32_t textWidth = nsLayoutUtils::AppUnitWidthOfString(aText, inx,
aFontMetrics,
aDrawTarget);
int32_t fullWidth = aBaseWidth + textWidth;
if (fullWidth == aCursorPos) {
aTextWidth = textWidth;
aIndex = inx;
return true;
} else if (aCursorPos < fullWidth) {
aTextWidth = aBaseWidth;
if (BinarySearchForPosition(aDrawTarget, aFontMetrics, aText, aBaseWidth,
aBaseInx, aStartInx, inx, aCursorPos, aIndex,
aTextWidth)) {
return true;
}
} else {
aTextWidth = fullWidth;
if (BinarySearchForPosition(aDrawTarget, aFontMetrics, aText, aBaseWidth,
aBaseInx, inx, aEndInx, aCursorPos, aIndex,
aTextWidth)) {
return true;
}
}
return false;
}
static void
AddBoxesForFrame(nsIFrame* aFrame,
nsLayoutUtils::BoxCallback* aCallback)
{
nsIAtom* pseudoType = aFrame->StyleContext()->GetPseudo();
if (pseudoType == nsCSSAnonBoxes::tableWrapper) {
AddBoxesForFrame(aFrame->PrincipalChildList().FirstChild(), aCallback);
if (aCallback->mIncludeCaptionBoxForTable) {
nsIFrame* kid = aFrame->GetChildList(nsIFrame::kCaptionList).FirstChild();
if (kid) {
AddBoxesForFrame(kid, aCallback);
}
}
} else if (pseudoType == nsCSSAnonBoxes::mozAnonymousBlock ||
pseudoType == nsCSSAnonBoxes::mozAnonymousPositionedBlock ||
pseudoType == nsCSSAnonBoxes::mozMathMLAnonymousBlock ||
pseudoType == nsCSSAnonBoxes::mozXULAnonymousBlock) {
for (nsIFrame* kid : aFrame->PrincipalChildList()) {
AddBoxesForFrame(kid, aCallback);
}
} else {
aCallback->AddBox(aFrame);
}
}
void
nsLayoutUtils::GetAllInFlowBoxes(nsIFrame* aFrame, BoxCallback* aCallback)
{
while (aFrame) {
AddBoxesForFrame(aFrame, aCallback);
aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
}
}
nsIFrame*
nsLayoutUtils::GetFirstNonAnonymousFrame(nsIFrame* aFrame)
{
while (aFrame) {
nsIAtom* pseudoType = aFrame->StyleContext()->GetPseudo();
if (pseudoType == nsCSSAnonBoxes::tableWrapper) {
nsIFrame* f = GetFirstNonAnonymousFrame(aFrame->PrincipalChildList().FirstChild());
if (f) {
return f;
}
nsIFrame* kid = aFrame->GetChildList(nsIFrame::kCaptionList).FirstChild();
if (kid) {
f = GetFirstNonAnonymousFrame(kid);
if (f) {
return f;
}
}
} else if (pseudoType == nsCSSAnonBoxes::mozAnonymousBlock ||
pseudoType == nsCSSAnonBoxes::mozAnonymousPositionedBlock ||
pseudoType == nsCSSAnonBoxes::mozMathMLAnonymousBlock ||
pseudoType == nsCSSAnonBoxes::mozXULAnonymousBlock) {
for (nsIFrame* kid : aFrame->PrincipalChildList()) {
nsIFrame* f = GetFirstNonAnonymousFrame(kid);
if (f) {
return f;
}
}
} else {
return aFrame;
}
aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
}
return nullptr;
}
struct BoxToRect : public nsLayoutUtils::BoxCallback {
nsIFrame* mRelativeTo;
nsLayoutUtils::RectCallback* mCallback;
uint32_t mFlags;
BoxToRect(nsIFrame* aRelativeTo, nsLayoutUtils::RectCallback* aCallback,
uint32_t aFlags)
: mRelativeTo(aRelativeTo), mCallback(aCallback), mFlags(aFlags) {}
virtual void AddBox(nsIFrame* aFrame) override {
nsRect r;
nsIFrame* outer = nsSVGUtils::GetOuterSVGFrameAndCoveredRegion(aFrame, &r);
if (!outer) {
outer = aFrame;
switch (mFlags & nsLayoutUtils::RECTS_WHICH_BOX_MASK) {
case nsLayoutUtils::RECTS_USE_CONTENT_BOX:
r = aFrame->GetContentRectRelativeToSelf();
break;
case nsLayoutUtils::RECTS_USE_PADDING_BOX:
r = aFrame->GetPaddingRectRelativeToSelf();
break;
case nsLayoutUtils::RECTS_USE_MARGIN_BOX:
r = aFrame->GetMarginRectRelativeToSelf();
break;
default: // Use the border box
r = aFrame->GetRectRelativeToSelf();
}
}
if (mFlags & nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS) {
r = nsLayoutUtils::TransformFrameRectToAncestor(outer, r, mRelativeTo);
} else {
r += outer->GetOffsetTo(mRelativeTo);
}
mCallback->AddRect(r);
}
};
struct BoxToRectAndText : public BoxToRect {
mozilla::dom::DOMStringList* mTextList;
BoxToRectAndText(nsIFrame* aRelativeTo, nsLayoutUtils::RectCallback* aCallback,
mozilla::dom::DOMStringList* aTextList, uint32_t aFlags)
: BoxToRect(aRelativeTo, aCallback, aFlags), mTextList(aTextList) {}
virtual void AddBox(nsIFrame* aFrame) override {
BoxToRect::AddBox(aFrame);
if (mTextList) {
nsIContent* content = aFrame->GetContent();
nsAutoString textContent;
mozilla::ErrorResult err; // ignored
content->GetTextContent(textContent, err);
mTextList->Add(textContent);
}
}
};
void
nsLayoutUtils::GetAllInFlowRects(nsIFrame* aFrame, nsIFrame* aRelativeTo,
RectCallback* aCallback, uint32_t aFlags)
{
BoxToRect converter(aRelativeTo, aCallback, aFlags);
GetAllInFlowBoxes(aFrame, &converter);
}
void
nsLayoutUtils::GetAllInFlowRectsAndTexts(nsIFrame* aFrame, nsIFrame* aRelativeTo,
RectCallback* aCallback,
mozilla::dom::DOMStringList* aTextList,
uint32_t aFlags)
{
BoxToRectAndText converter(aRelativeTo, aCallback, aTextList, aFlags);
GetAllInFlowBoxes(aFrame, &converter);
}
nsLayoutUtils::RectAccumulator::RectAccumulator() : mSeenFirstRect(false) {}
void nsLayoutUtils::RectAccumulator::AddRect(const nsRect& aRect) {
mResultRect.UnionRect(mResultRect, aRect);
if (!mSeenFirstRect) {
mSeenFirstRect = true;
mFirstRect = aRect;
}
}
nsLayoutUtils::RectListBuilder::RectListBuilder(DOMRectList* aList)
: mRectList(aList)
{
}
void nsLayoutUtils::RectListBuilder::AddRect(const nsRect& aRect) {
RefPtr<DOMRect> rect = new DOMRect(mRectList);
rect->SetLayoutRect(aRect);
mRectList->Append(rect);
}
nsIFrame* nsLayoutUtils::GetContainingBlockForClientRect(nsIFrame* aFrame)
{
return aFrame->PresContext()->PresShell()->GetRootFrame();
}
nsRect
nsLayoutUtils::GetAllInFlowRectsUnion(nsIFrame* aFrame, nsIFrame* aRelativeTo,
uint32_t aFlags) {
RectAccumulator accumulator;
GetAllInFlowRects(aFrame, aRelativeTo, &accumulator, aFlags);
return accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect
: accumulator.mResultRect;
}
nsRect
nsLayoutUtils::GetTextShadowRectsUnion(const nsRect& aTextAndDecorationsRect,
nsIFrame* aFrame,
uint32_t aFlags)
{
const nsStyleText* textStyle = aFrame->StyleText();
if (!textStyle->HasTextShadow())
return aTextAndDecorationsRect;
nsRect resultRect = aTextAndDecorationsRect;
int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
for (uint32_t i = 0; i < textStyle->mTextShadow->Length(); ++i) {
nsCSSShadowItem* shadow = textStyle->mTextShadow->ShadowAt(i);
nsMargin blur = nsContextBoxBlur::GetBlurRadiusMargin(shadow->mRadius, A2D);
if ((aFlags & EXCLUDE_BLUR_SHADOWS) && blur != nsMargin(0, 0, 0, 0))
continue;
nsRect tmpRect(aTextAndDecorationsRect);
tmpRect.MoveBy(nsPoint(shadow->mXOffset, shadow->mYOffset));
tmpRect.Inflate(blur);
resultRect.UnionRect(resultRect, tmpRect);
}
return resultRect;
}
enum ObjectDimensionType { eWidth, eHeight };
static nscoord
ComputeMissingDimension(const nsSize& aDefaultObjectSize,
const nsSize& aIntrinsicRatio,
const Maybe<nscoord>& aSpecifiedWidth,
const Maybe<nscoord>& aSpecifiedHeight,
ObjectDimensionType aDimensionToCompute)
{
// The "default sizing algorithm" computes the missing dimension as follows:
// (source: http://dev.w3.org/csswg/css-images-3/#default-sizing )
// 1. "If the object has an intrinsic aspect ratio, the missing dimension of
// the concrete object size is calculated using the intrinsic aspect
// ratio and the present dimension."
if (aIntrinsicRatio.width > 0 && aIntrinsicRatio.height > 0) {
// Fill in the missing dimension using the intrinsic aspect ratio.
nscoord knownDimensionSize;
float ratio;
if (aDimensionToCompute == eWidth) {
knownDimensionSize = *aSpecifiedHeight;
ratio = aIntrinsicRatio.width / aIntrinsicRatio.height;
} else {
knownDimensionSize = *aSpecifiedWidth;
ratio = aIntrinsicRatio.height / aIntrinsicRatio.width;
}
return NSCoordSaturatingNonnegativeMultiply(knownDimensionSize, ratio);
}
// 2. "Otherwise, if the missing dimension is present in the object’s
// intrinsic dimensions, [...]"
// NOTE: *Skipping* this case, because we already know it's not true -- we're
// in this function because the missing dimension is *not* present in
// the object's intrinsic dimensions.
// 3. "Otherwise, the missing dimension of the concrete object size is taken
// from the default object size. "
return (aDimensionToCompute == eWidth) ?
aDefaultObjectSize.width : aDefaultObjectSize.height;
}
/*
* This computes & returns the concrete object size of replaced content, if
* that content were to be rendered with "object-fit: none". (Or, if the
* element has neither an intrinsic height nor width, this method returns an
* empty Maybe<> object.)
*
* As specced...
* http://dev.w3.org/csswg/css-images-3/#valdef-object-fit-none
* ..we use "the default sizing algorithm with no specified size,
* and a default object size equal to the replaced element's used width and
* height."
*
* The default sizing algorithm is described here:
* http://dev.w3.org/csswg/css-images-3/#default-sizing
* Quotes in the function-impl are taken from that ^ spec-text.
*
* Per its final bulleted section: since there's no specified size,
* we run the default sizing algorithm using the object's intrinsic size in
* place of the specified size. But if the object has neither an intrinsic
* height nor an intrinsic width, then we instead return without populating our
* outparam, and we let the caller figure out the size (using a contain
* constraint).
*/
static Maybe<nsSize>
MaybeComputeObjectFitNoneSize(const nsSize& aDefaultObjectSize,
const IntrinsicSize& aIntrinsicSize,
const nsSize& aIntrinsicRatio)
{
// "If the object has an intrinsic height or width, its size is resolved as
// if its intrinsic dimensions were given as the specified size."
//
// So, first we check if we have an intrinsic height and/or width:
Maybe<nscoord> specifiedWidth;
if (aIntrinsicSize.width.GetUnit() == eStyleUnit_Coord) {
specifiedWidth.emplace(aIntrinsicSize.width.GetCoordValue());
}
Maybe<nscoord> specifiedHeight;
if (aIntrinsicSize.height.GetUnit() == eStyleUnit_Coord) {
specifiedHeight.emplace(aIntrinsicSize.height.GetCoordValue());
}
Maybe<nsSize> noneSize; // (the value we'll return)
if (specifiedWidth || specifiedHeight) {
// We have at least one specified dimension; use whichever dimension is
// specified, and compute the other one using our intrinsic ratio, or (if
// no valid ratio) using the default object size.
noneSize.emplace();
noneSize->width = specifiedWidth ?
*specifiedWidth :
ComputeMissingDimension(aDefaultObjectSize, aIntrinsicRatio,
specifiedWidth, specifiedHeight,
eWidth);
noneSize->height = specifiedHeight ?
*specifiedHeight :
ComputeMissingDimension(aDefaultObjectSize, aIntrinsicRatio,
specifiedWidth, specifiedHeight,
eHeight);
}
// [else:] "Otherwise [if there's neither an intrinsic height nor width], its
// size is resolved as a contain constraint against the default object size."
// We'll let our caller do that, to share code & avoid redundant
// computations; so, we return w/out populating noneSize.
return noneSize;
}
// Computes the concrete object size to render into, as described at
// http://dev.w3.org/csswg/css-images-3/#concrete-size-resolution
static nsSize
ComputeConcreteObjectSize(const nsSize& aConstraintSize,
const IntrinsicSize& aIntrinsicSize,
const nsSize& aIntrinsicRatio,
uint8_t aObjectFit)
{
// Handle default behavior (filling the container) w/ fast early return.
// (Also: if there's no valid intrinsic ratio, then we have the "fill"
// behavior & just use the constraint size.)
if (MOZ_LIKELY(aObjectFit == NS_STYLE_OBJECT_FIT_FILL) ||
aIntrinsicRatio.width == 0 ||
aIntrinsicRatio.height == 0) {
return aConstraintSize;
}
// The type of constraint to compute (cover/contain), if needed:
Maybe<nsImageRenderer::FitType> fitType;
Maybe<nsSize> noneSize;
if (aObjectFit == NS_STYLE_OBJECT_FIT_NONE ||
aObjectFit == NS_STYLE_OBJECT_FIT_SCALE_DOWN) {
noneSize = MaybeComputeObjectFitNoneSize(aConstraintSize, aIntrinsicSize,
aIntrinsicRatio);
if (!noneSize || aObjectFit == NS_STYLE_OBJECT_FIT_SCALE_DOWN) {
// Need to compute a 'CONTAIN' constraint (either for the 'none' size
// itself, or for comparison w/ the 'none' size to resolve 'scale-down'.)
fitType.emplace(nsImageRenderer::CONTAIN);
}
} else if (aObjectFit == NS_STYLE_OBJECT_FIT_COVER) {
fitType.emplace(nsImageRenderer::COVER);
} else if (aObjectFit == NS_STYLE_OBJECT_FIT_CONTAIN) {
fitType.emplace(nsImageRenderer::CONTAIN);
}
Maybe<nsSize> constrainedSize;
if (fitType) {
constrainedSize.emplace(
nsImageRenderer::ComputeConstrainedSize(aConstraintSize,
aIntrinsicRatio,
*fitType));
}
// Now, we should have all the sizing information that we need.
switch (aObjectFit) {
// skipping NS_STYLE_OBJECT_FIT_FILL; we handled it w/ early-return.
case NS_STYLE_OBJECT_FIT_CONTAIN:
case NS_STYLE_OBJECT_FIT_COVER:
MOZ_ASSERT(constrainedSize);
return *constrainedSize;
case NS_STYLE_OBJECT_FIT_NONE:
if (noneSize) {
return *noneSize;
}
MOZ_ASSERT(constrainedSize);
return *constrainedSize;
case NS_STYLE_OBJECT_FIT_SCALE_DOWN:
MOZ_ASSERT(constrainedSize);
if (noneSize) {
constrainedSize->width =
std::min(constrainedSize->width, noneSize->width);
constrainedSize->height =
std::min(constrainedSize->height, noneSize->height);
}
return *constrainedSize;
default:
MOZ_ASSERT_UNREACHABLE("Unexpected enum value for 'object-fit'");
return aConstraintSize; // fall back to (default) 'fill' behavior
}
}
// (Helper for HasInitialObjectFitAndPosition, to check
// each "object-position" coord.)
static bool
IsCoord50Pct(const mozilla::Position::Coord& aCoord)
{
return (aCoord.mLength == 0 &&
aCoord.mHasPercent &&
aCoord.mPercent == 0.5f);
}
// Indicates whether the given nsStylePosition has the initial values
// for the "object-fit" and "object-position" properties.
static bool
HasInitialObjectFitAndPosition(const nsStylePosition* aStylePos)
{
const mozilla::Position& objectPos = aStylePos->mObjectPosition;
return aStylePos->mObjectFit == NS_STYLE_OBJECT_FIT_FILL &&
IsCoord50Pct(objectPos.mXPosition) &&
IsCoord50Pct(objectPos.mYPosition);
}
/* static */ nsRect
nsLayoutUtils::ComputeObjectDestRect(const nsRect& aConstraintRect,
const IntrinsicSize& aIntrinsicSize,
const nsSize& aIntrinsicRatio,
const nsStylePosition* aStylePos,
nsPoint* aAnchorPoint)
{
// Step 1: Figure out our "concrete object size"
// (the size of the region we'll actually draw our image's pixels into).
nsSize concreteObjectSize =
ComputeConcreteObjectSize(aConstraintRect.Size(), aIntrinsicSize,
aIntrinsicRatio, aStylePos->mObjectFit);
// Step 2: Figure out how to align that region in the element's content-box.
nsPoint imageTopLeftPt, imageAnchorPt;
nsImageRenderer::ComputeObjectAnchorPoint(aStylePos->mObjectPosition,
aConstraintRect.Size(),
concreteObjectSize,
&imageTopLeftPt, &imageAnchorPt);
// Right now, we're with respect to aConstraintRect's top-left point. We add
// that point here, to convert to the same broader coordinate space that
// aConstraintRect is in.
imageTopLeftPt += aConstraintRect.TopLeft();
imageAnchorPt += aConstraintRect.TopLeft();
if (aAnchorPoint) {
// Special-case: if our "object-fit" and "object-position" properties have
// their default values ("object-fit: fill; object-position:50% 50%"), then
// we'll override the calculated imageAnchorPt, and instead use the
// object's top-left corner.
//
// This special case is partly for backwards compatibility (since
// traditionally we've pixel-aligned the top-left corner of e.g. <img>
// elements), and partly because ComputeSnappedDrawingParameters produces
// less error if the anchor point is at the top-left corner. So, all other
// things being equal, we prefer that code path with less error.
if (HasInitialObjectFitAndPosition(aStylePos)) {
*aAnchorPoint = imageTopLeftPt;
} else {
*aAnchorPoint = imageAnchorPt;
}
}
return nsRect(imageTopLeftPt, concreteObjectSize);
}
already_AddRefed<nsFontMetrics>
nsLayoutUtils::GetFontMetricsForFrame(const nsIFrame* aFrame, float aInflation)
{
nsStyleContext* styleContext = aFrame->StyleContext();
uint8_t variantWidth = NS_FONT_VARIANT_WIDTH_NORMAL;
if (styleContext->IsTextCombined()) {
MOZ_ASSERT(aFrame->GetType() == nsGkAtoms::textFrame);
auto textFrame = static_cast<const nsTextFrame*>(aFrame);
auto clusters = textFrame->CountGraphemeClusters();
if (clusters == 2) {
variantWidth = NS_FONT_VARIANT_WIDTH_HALF;
} else if (clusters == 3) {
variantWidth = NS_FONT_VARIANT_WIDTH_THIRD;
} else if (clusters == 4) {
variantWidth = NS_FONT_VARIANT_WIDTH_QUARTER;
}
}
return GetFontMetricsForStyleContext(styleContext, aInflation, variantWidth);
}
already_AddRefed<nsFontMetrics>
nsLayoutUtils::GetFontMetricsForStyleContext(nsStyleContext* aStyleContext,
float aInflation,
uint8_t aVariantWidth)
{
nsPresContext* pc = aStyleContext->PresContext();
WritingMode wm(aStyleContext);
const nsStyleFont* styleFont = aStyleContext->StyleFont();
nsFontMetrics::Params params;
params.language = styleFont->mLanguage;
params.explicitLanguage = styleFont->mExplicitLanguage;
params.orientation =
wm.IsVertical() && !wm.IsSideways() ? gfxFont::eVertical
: gfxFont::eHorizontal;
// pass the user font set object into the device context to
// pass along to CreateFontGroup
params.userFontSet = pc->GetUserFontSet();
params.textPerf = pc->GetTextPerfMetrics();
// When aInflation is 1.0 and we don't require width variant, avoid
// making a local copy of the nsFont.
// This also avoids running font.size through floats when it is large,
// which would be lossy. Fortunately, in such cases, aInflation is
// guaranteed to be 1.0f.
if (aInflation == 1.0f && aVariantWidth == NS_FONT_VARIANT_WIDTH_NORMAL) {
return pc->DeviceContext()->GetMetricsFor(styleFont->mFont, params);
}
nsFont font = styleFont->mFont;
font.size = NSToCoordRound(font.size * aInflation);
font.variantWidth = aVariantWidth;
return pc->DeviceContext()->GetMetricsFor(font, params);
}
nsIFrame*
nsLayoutUtils::FindChildContainingDescendant(nsIFrame* aParent, nsIFrame* aDescendantFrame)
{
nsIFrame* result = aDescendantFrame;
while (result) {
nsIFrame* parent = result->GetParent();
if (parent == aParent) {
break;
}
// The frame is not an immediate child of aParent so walk up another level
result = parent;
}
return result;
}
nsBlockFrame*
nsLayoutUtils::GetAsBlock(nsIFrame* aFrame)
{
nsBlockFrame* block = do_QueryFrame(aFrame);
return block;
}
nsBlockFrame*
nsLayoutUtils::FindNearestBlockAncestor(nsIFrame* aFrame)
{
nsIFrame* nextAncestor;
for (nextAncestor = aFrame->GetParent(); nextAncestor;
nextAncestor = nextAncestor->GetParent()) {
nsBlockFrame* block = GetAsBlock(nextAncestor);
if (block)
return block;
}
return nullptr;
}
nsIFrame*
nsLayoutUtils::GetNonGeneratedAncestor(nsIFrame* aFrame)
{
if (!(aFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT))
return aFrame;
nsIFrame* f = aFrame;
do {
f = GetParentOrPlaceholderFor(f);
} while (f->GetStateBits() & NS_FRAME_GENERATED_CONTENT);
return f;
}
nsIFrame*
nsLayoutUtils::GetParentOrPlaceholderFor(nsIFrame* aFrame)
{
if ((aFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)
&& !aFrame->GetPrevInFlow()) {
return aFrame->PresContext()->PresShell()->FrameManager()->
GetPlaceholderFrameFor(aFrame);
}
return aFrame->GetParent();
}
nsIFrame*
nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(nsIFrame* aFrame)
{
nsIFrame* f = GetParentOrPlaceholderFor(aFrame);
if (f)
return f;
return GetCrossDocParentFrame(aFrame);
}
nsIFrame*
nsLayoutUtils::GetNextContinuationOrIBSplitSibling(nsIFrame *aFrame)
{
nsIFrame *result = aFrame->GetNextContinuation();
if (result)
return result;
if ((aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) != 0) {
// We only store the ib-split sibling annotation with the first
// frame in the continuation chain. Walk back to find that frame now.
aFrame = aFrame->FirstContinuation();
return aFrame->Properties().Get(nsIFrame::IBSplitSibling());
}
return nullptr;
}
nsIFrame*
nsLayoutUtils::FirstContinuationOrIBSplitSibling(nsIFrame *aFrame)
{
nsIFrame *result = aFrame->FirstContinuation();
if (result->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) {
while (true) {
nsIFrame* f =
result->Properties().Get(nsIFrame::IBSplitPrevSibling());
if (!f)
break;
result = f;
}
}
return result;
}
nsIFrame*
nsLayoutUtils::LastContinuationOrIBSplitSibling(nsIFrame *aFrame)
{
nsIFrame *result = aFrame->FirstContinuation();
if (result->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) {
while (true) {
nsIFrame* f =
result->Properties().Get(nsIFrame::IBSplitSibling());
if (!f)
break;
result = f;
}
}
result = result->LastContinuation();
return result;
}
bool
nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(nsIFrame *aFrame)
{
if (aFrame->GetPrevContinuation()) {
return false;
}
if ((aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) &&
aFrame->Properties().Get(nsIFrame::IBSplitPrevSibling())) {
return false;
}
return true;
}
bool
nsLayoutUtils::IsViewportScrollbarFrame(nsIFrame* aFrame)
{
if (!aFrame)
return false;
nsIFrame* rootScrollFrame =
aFrame->PresContext()->PresShell()->GetRootScrollFrame();
if (!rootScrollFrame)
return false;
nsIScrollableFrame* rootScrollableFrame = do_QueryFrame(rootScrollFrame);
NS_ASSERTION(rootScrollableFrame, "The root scorollable frame is null");
if (!IsProperAncestorFrame(rootScrollFrame, aFrame))
return false;
nsIFrame* rootScrolledFrame = rootScrollableFrame->GetScrolledFrame();
return !(rootScrolledFrame == aFrame ||
IsProperAncestorFrame(rootScrolledFrame, aFrame));
}
// Use only for widths/heights (or their min/max), since it clamps
// negative calc() results to 0.
static bool GetAbsoluteCoord(const nsStyleCoord& aStyle, nscoord& aResult)
{
if (aStyle.IsCalcUnit()) {
if (aStyle.CalcHasPercent()) {
return false;
}
// If it has no percents, we can pass 0 for the percentage basis.
aResult = nsRuleNode::ComputeComputedCalc(aStyle, 0);
if (aResult < 0)
aResult = 0;
return true;
}
if (eStyleUnit_Coord != aStyle.GetUnit())
return false;
aResult = aStyle.GetCoordValue();
NS_ASSERTION(aResult >= 0, "negative widths not allowed");
return true;
}
static nscoord
GetBSizeTakenByBoxSizing(StyleBoxSizing aBoxSizing,
nsIFrame* aFrame,
bool aHorizontalAxis,
bool aIgnorePadding);
// Only call on style coords for which GetAbsoluteCoord returned false.
static bool
GetPercentBSize(const nsStyleCoord& aStyle,
nsIFrame* aFrame,
bool aHorizontalAxis,
nscoord& aResult)
{
if (eStyleUnit_Percent != aStyle.GetUnit() &&
!aStyle.IsCalcUnit())
return false;
MOZ_ASSERT(!aStyle.IsCalcUnit() || aStyle.CalcHasPercent(),
"GetAbsoluteCoord should have handled this");
// During reflow, nsHTMLScrollFrame::ReflowScrolledFrame uses
// SetComputedHeight on the reflow state for its child to propagate its
// computed height to the scrolled content. So here we skip to the scroll
// frame that contains this scrolled content in order to get the same
// behavior as layout when computing percentage heights.
nsIFrame *f = aFrame->GetContainingBlock(nsIFrame::SKIP_SCROLLED_FRAME);
if (!f) {
NS_NOTREACHED("top of frame tree not a containing block");
return false;
}
WritingMode wm = f->GetWritingMode();
const nsStylePosition *pos = f->StylePosition();
const nsStyleCoord& bSizeCoord = pos->BSize(wm);
nscoord h;
if (!GetAbsoluteCoord(bSizeCoord, h) &&
!GetPercentBSize(bSizeCoord, f, aHorizontalAxis, h)) {
NS_ASSERTION(bSizeCoord.GetUnit() == eStyleUnit_Auto ||
bSizeCoord.HasPercent(),
"unknown block-size unit");
nsIAtom* fType = f->GetType();
if (fType != nsGkAtoms::viewportFrame && fType != nsGkAtoms::canvasFrame &&
fType != nsGkAtoms::pageContentFrame) {
// There's no basis for the percentage height, so it acts like auto.
// Should we consider a max-height < min-height pair a basis for
// percentage heights? The spec is somewhat unclear, and not doing
// so is simpler and avoids troubling discontinuities in behavior,
// so I'll choose not to. -LDB
return false;
}
NS_ASSERTION(bSizeCoord.GetUnit() == eStyleUnit_Auto,
"Unexpected block-size unit for viewport or canvas or page-content");
// For the viewport, canvas, and page-content kids, the percentage
// basis is just the parent block-size.
h = f->BSize(wm);
if (h == NS_UNCONSTRAINEDSIZE) {
// We don't have a percentage basis after all
return false;
}
}
const nsStyleCoord& maxBSizeCoord = pos->MaxBSize(wm);
nscoord maxh;
if (GetAbsoluteCoord(maxBSizeCoord, maxh) ||
GetPercentBSize(maxBSizeCoord, f, aHorizontalAxis, maxh)) {
if (maxh < h)
h = maxh;
} else {
NS_ASSERTION(maxBSizeCoord.GetUnit() == eStyleUnit_None ||
maxBSizeCoord.HasPercent(),
"unknown max block-size unit");
}
const nsStyleCoord& minBSizeCoord = pos->MinBSize(wm);
nscoord minh;
if (GetAbsoluteCoord(minBSizeCoord, minh) ||
GetPercentBSize(minBSizeCoord, f, aHorizontalAxis, minh)) {
if (minh > h)
h = minh;
} else {
NS_ASSERTION(minBSizeCoord.HasPercent() ||
minBSizeCoord.GetUnit() == eStyleUnit_Auto,
"unknown min block-size unit");
}
// Now adjust h for box-sizing styles on the parent. We never ignore padding
// here. That could conceivably cause some problems with fieldsets (which are
// the one place that wants to ignore padding), but solving that here without
// hardcoding a check for f being a fieldset-content frame is a bit of a pain.
nscoord bSizeTakenByBoxSizing =
GetBSizeTakenByBoxSizing(pos->mBoxSizing, f, aHorizontalAxis, false);
h = std::max(0, h - bSizeTakenByBoxSizing);
if (aStyle.IsCalcUnit()) {
aResult = std::max(nsRuleNode::ComputeComputedCalc(aStyle, h), 0);
return true;
}
aResult = NSToCoordRound(aStyle.GetPercentValue() * h);
return true;
}
// Get the amount of vertical space taken out of aFrame's content area due to
// its borders and paddings given the box-sizing value in aBoxSizing. We don't
// get aBoxSizing from the frame because some callers want to compute this for
// specific box-sizing values. aHorizontalAxis is true if our inline direction
// is horisontal and our block direction is vertical. aIgnorePadding is true if
// padding should be ignored.
static nscoord
GetBSizeTakenByBoxSizing(StyleBoxSizing aBoxSizing,
nsIFrame* aFrame,
bool aHorizontalAxis,
bool aIgnorePadding)
{
nscoord bSizeTakenByBoxSizing = 0;
if (aBoxSizing == StyleBoxSizing::Border) {
const nsStyleBorder* styleBorder = aFrame->StyleBorder();
bSizeTakenByBoxSizing +=
aHorizontalAxis ? styleBorder->GetComputedBorder().TopBottom()
: styleBorder->GetComputedBorder().LeftRight();
if (!aIgnorePadding) {
const nsStyleSides& stylePadding =
aFrame->StylePadding()->mPadding;
const nsStyleCoord& paddingStart =
stylePadding.Get(aHorizontalAxis ? eSideTop : eSideLeft);
const nsStyleCoord& paddingEnd =
stylePadding.Get(aHorizontalAxis ? eSideBottom : eSideRight);
nscoord pad;
// XXXbz Calling GetPercentBSize on padding values looks bogus, since
// percent padding is always a percentage of the inline-size of the
// containing block. We should perhaps just treat non-absolute paddings
// here as 0 instead, except that in some cases the width may in fact be
// known. See bug 1231059.
if (GetAbsoluteCoord(paddingStart, pad) ||
GetPercentBSize(paddingStart, aFrame, aHorizontalAxis, pad)) {
bSizeTakenByBoxSizing += pad;
}
if (GetAbsoluteCoord(paddingEnd, pad) ||
GetPercentBSize(paddingEnd, aFrame, aHorizontalAxis, pad)) {
bSizeTakenByBoxSizing += pad;
}
}
}
return bSizeTakenByBoxSizing;
}
// Handles only -moz-max-content and -moz-min-content, and
// -moz-fit-content for min-width and max-width, since the others
// (-moz-fit-content for width, and -moz-available) have no effect on
// intrinsic widths.
enum eWidthProperty { PROP_WIDTH, PROP_MAX_WIDTH, PROP_MIN_WIDTH };
static bool
GetIntrinsicCoord(const nsStyleCoord& aStyle,
nsRenderingContext* aRenderingContext,
nsIFrame* aFrame,
eWidthProperty aProperty,
nscoord& aResult)
{
NS_PRECONDITION(aProperty == PROP_WIDTH || aProperty == PROP_MAX_WIDTH ||
aProperty == PROP_MIN_WIDTH, "unexpected property");
if (aStyle.GetUnit() != eStyleUnit_Enumerated)
return false;
int32_t val = aStyle.GetIntValue();
NS_ASSERTION(val == NS_STYLE_WIDTH_MAX_CONTENT ||
val == NS_STYLE_WIDTH_MIN_CONTENT ||
val == NS_STYLE_WIDTH_FIT_CONTENT ||
val == NS_STYLE_WIDTH_AVAILABLE,
"unexpected enumerated value for width property");
if (val == NS_STYLE_WIDTH_AVAILABLE)
return false;
if (val == NS_STYLE_WIDTH_FIT_CONTENT) {
if (aProperty == PROP_WIDTH)
return false; // handle like 'width: auto'
if (aProperty == PROP_MAX_WIDTH)
// constrain large 'width' values down to -moz-max-content
val = NS_STYLE_WIDTH_MAX_CONTENT;
else
// constrain small 'width' or 'max-width' values up to -moz-min-content
val = NS_STYLE_WIDTH_MIN_CONTENT;
}
NS_ASSERTION(val == NS_STYLE_WIDTH_MAX_CONTENT ||
val == NS_STYLE_WIDTH_MIN_CONTENT,
"should have reduced everything remaining to one of these");
// If aFrame is a container for font size inflation, then shrink
// wrapping inside of it should not apply font size inflation.
AutoMaybeDisableFontInflation an(aFrame);
if (val == NS_STYLE_WIDTH_MAX_CONTENT)
aResult = aFrame->GetPrefISize(aRenderingContext);
else
aResult = aFrame->GetMinISize(aRenderingContext);
return true;
}
#undef DEBUG_INTRINSIC_WIDTH
#ifdef DEBUG_INTRINSIC_WIDTH
static int32_t gNoiseIndent = 0;
#endif
// Return true for form controls whose minimum intrinsic inline-size
// shrinks to 0 when they have a percentage inline-size (but not
// percentage max-inline-size). (Proper replaced elements, whose
// intrinsic minimium inline-size shrinks to 0 for both percentage
// inline-size and percentage max-inline-size, are handled elsewhere.)
inline static bool
FormControlShrinksForPercentISize(nsIFrame* aFrame)
{
if (!aFrame->IsFrameOfType(nsIFrame::eReplaced)) {
// Quick test to reject most frames.
return false;
}
nsIAtom* fType = aFrame->GetType();
if (fType == nsGkAtoms::meterFrame || fType == nsGkAtoms::progressFrame) {
// progress and meter do have this shrinking behavior
// FIXME: Maybe these should be nsIFormControlFrame?
return true;
}
if (!static_cast<nsIFormControlFrame*>(do_QueryFrame(aFrame))) {
// Not a form control. This includes fieldsets, which do not
// shrink.
return false;
}
if (fType == nsGkAtoms::gfxButtonControlFrame ||
fType == nsGkAtoms::HTMLButtonControlFrame) {
// Buttons don't have this shrinking behavior. (Note that color
// inputs do, even though they inherit from button, so we can't use
// do_QueryFrame here.)
return false;
}
return true;
}
/**
* Add aOffsets which describes what to add on outside of the content box
* aContentSize (controlled by 'box-sizing') and apply min/max properties.
* We have to account for these properties after getting all the offsets
* (margin, border, padding) because percentages do not operate linearly.
* Doing this is ok because although percentages aren't handled linearly,
* they are handled monotonically.
*
* @param aContentSize the content size calculated so far
(@see IntrinsicForContainer)
* @param aContentMinSize ditto min content size
* @param aStyleSize a 'width' or 'height' property value
* @param aFixedMinSize if aStyleMinSize is a definite size then this points to
* the value, otherwise nullptr
* @param aStyleMinSize a 'min-width' or 'min-height' property value
* @param aFixedMaxSize if aStyleMaxSize is a definite size then this points to
* the value, otherwise nullptr
* @param aStyleMaxSize a 'max-width' or 'max-height' property value
* @param aFlags same as for IntrinsicForContainer
* @param aContainerWM the container's WM
*/
static nscoord
AddIntrinsicSizeOffset(nsRenderingContext* aRenderingContext,
nsIFrame* aFrame,
const nsIFrame::IntrinsicISizeOffsetData& aOffsets,
nsLayoutUtils::IntrinsicISizeType aType,
StyleBoxSizing aBoxSizing,
nscoord aContentSize,
nscoord aContentMinSize,
const nsStyleCoord& aStyleSize,
const nscoord* aFixedMinSize,
const nsStyleCoord& aStyleMinSize,
const nscoord* aFixedMaxSize,
const nsStyleCoord& aStyleMaxSize,
uint32_t aFlags,
PhysicalAxis aAxis)
{
nscoord result = aContentSize;
nscoord min = aContentMinSize;
nscoord coordOutsideSize = 0;
float pctOutsideSize = 0;
float pctTotal = 0.0f;
if (!(aFlags & nsLayoutUtils::IGNORE_PADDING)) {
coordOutsideSize += aOffsets.hPadding;
pctOutsideSize += aOffsets.hPctPadding;
}
coordOutsideSize += aOffsets.hBorder;
if (aBoxSizing == StyleBoxSizing::Border) {
min += coordOutsideSize;
result = NSCoordSaturatingAdd(result, coordOutsideSize);
pctTotal += pctOutsideSize;
coordOutsideSize = 0;
pctOutsideSize = 0.0f;
}
coordOutsideSize += aOffsets.hMargin;
pctOutsideSize += aOffsets.hPctMargin;
min += coordOutsideSize;
result = NSCoordSaturatingAdd(result, coordOutsideSize);
pctTotal += pctOutsideSize;
const bool shouldAddPercent = aType == nsLayoutUtils::PREF_ISIZE ||
(aFlags & nsLayoutUtils::ADD_PERCENTS);
nscoord size;
if (aType == nsLayoutUtils::MIN_ISIZE &&
(((aStyleSize.HasPercent() || aStyleMaxSize.HasPercent()) &&
aFrame->IsFrameOfType(nsIFrame::eReplacedSizing)) ||
(aStyleSize.HasPercent() &&
FormControlShrinksForPercentISize(aFrame)))) {
// A percentage width or max-width on replaced elements means they
// can shrink to 0.
// This is also true for percentage widths (but not max-widths) on
// text inputs.
// Note that if this is max-width, this overrides the fixed-width
// rule in the next condition.
result = 0; // let |min| handle padding/border/margin
} else if (GetAbsoluteCoord(aStyleSize, size) ||
GetIntrinsicCoord(aStyleSize, aRenderingContext, aFrame,
PROP_WIDTH, size)) {
result = size + coordOutsideSize;
if (shouldAddPercent) {
result = nsLayoutUtils::AddPercents(result, pctOutsideSize);
}
} else {
// NOTE: We could really do a lot better for percents and for some
// cases of calc() containing percent (certainly including any where
// the coefficient on the percent is positive and there are no max()
// expressions). However, doing better for percents wouldn't be
// backwards compatible.
if (shouldAddPercent) {
result = nsLayoutUtils::AddPercents(result, pctTotal);
}
}
nscoord maxSize = aFixedMaxSize ? *aFixedMaxSize : 0;
if (aFixedMaxSize ||
GetIntrinsicCoord(aStyleMaxSize, aRenderingContext, aFrame,
PROP_MAX_WIDTH, maxSize)) {
maxSize += coordOutsideSize;
if (shouldAddPercent) {
maxSize = nsLayoutUtils::AddPercents(maxSize, pctOutsideSize);
}
if (result > maxSize) {
result = maxSize;
}
}
nscoord minSize = aFixedMinSize ? *aFixedMinSize : 0;
if (aFixedMinSize ||
GetIntrinsicCoord(aStyleMinSize, aRenderingContext, aFrame,
PROP_MIN_WIDTH, minSize)) {
minSize += coordOutsideSize;
if (shouldAddPercent) {
minSize = nsLayoutUtils::AddPercents(minSize, pctOutsideSize);
}
if (result < minSize) {
result = minSize;
}
}
if (shouldAddPercent) {
min = nsLayoutUtils::AddPercents(min, pctTotal);
}
if (result < min) {
result = min;
}
const nsStyleDisplay* disp = aFrame->StyleDisplay();
if (aFrame->IsThemed(disp)) {
LayoutDeviceIntSize devSize;
bool canOverride = true;
nsPresContext* pc = aFrame->PresContext();
pc->GetTheme()->GetMinimumWidgetSize(pc, aFrame, disp->mAppearance,
&devSize, &canOverride);
nscoord themeSize =
pc->DevPixelsToAppUnits(aAxis == eAxisVertical ? devSize.height
: devSize.width);
// GetMinimumWidgetSize() returns a border-box width.
themeSize += aOffsets.hMargin;
if (shouldAddPercent) {
themeSize = nsLayoutUtils::AddPercents(themeSize, aOffsets.hPctMargin);
}
if (themeSize > result || !canOverride) {
result = themeSize;
}
}
return result;
}
static void
AddStateBitToAncestors(nsIFrame* aFrame, nsFrameState aBit)
{
for (nsIFrame* f = aFrame; f; f = f->GetParent()) {
if (f->HasAnyStateBits(aBit)) {
break;
}
f->AddStateBits(aBit);
}
}
/* static */ nscoord
nsLayoutUtils::IntrinsicForAxis(PhysicalAxis aAxis,
nsRenderingContext* aRenderingContext,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags,
nscoord aMarginBoxMinSizeClamp)
{
NS_PRECONDITION(aFrame, "null frame");
NS_PRECONDITION(aFrame->GetParent(),
"IntrinsicForAxis called on frame not in tree");
NS_PRECONDITION(aType == MIN_ISIZE || aType == PREF_ISIZE, "bad type");
const bool horizontalAxis = MOZ_LIKELY(aAxis == eAxisHorizontal);
#ifdef DEBUG_INTRINSIC_WIDTH
nsFrame::IndentBy(stderr, gNoiseIndent);
static_cast<nsFrame*>(aFrame)->ListTag(stderr);
printf_stderr(" %s %s intrinsic size for container:\n",
aType == MIN_ISIZE ? "min" : "pref",
horizontalAxis ? "horizontal" : "vertical");
#endif
// If aFrame is a container for font size inflation, then shrink
// wrapping inside of it should not apply font size inflation.
AutoMaybeDisableFontInflation an(aFrame);
// We want the size this frame will contribute to the parent's inline-size,
// so we work in the parent's writing mode; but if aFrame is orthogonal to
// its parent, we'll need to look at its BSize instead of min/pref-ISize.
const nsStylePosition* stylePos = aFrame->StylePosition();
StyleBoxSizing boxSizing = stylePos->mBoxSizing;
const nsStyleCoord& styleMinISize =
horizontalAxis ? stylePos->mMinWidth : stylePos->mMinHeight;
const nsStyleCoord& styleISize =
(aFlags & MIN_INTRINSIC_ISIZE) ? styleMinISize :
(horizontalAxis ? stylePos->mWidth : stylePos->mHeight);
MOZ_ASSERT(!(aFlags & MIN_INTRINSIC_ISIZE) ||
styleISize.GetUnit() == eStyleUnit_Auto ||
styleISize.GetUnit() == eStyleUnit_Enumerated,
"should only use MIN_INTRINSIC_ISIZE for intrinsic values");
const nsStyleCoord& styleMaxISize =
horizontalAxis ? stylePos->mMaxWidth : stylePos->mMaxHeight;
// We build up two values starting with the content box, and then
// adding padding, border and margin. The result is normally
// |result|. Then, when we handle 'width', 'min-width', and
// 'max-width', we use the results we've been building in |min| as a
// minimum, overriding 'min-width'. This ensures two things:
// * that we don't let a value of 'box-sizing' specifying a width
// smaller than the padding/border inside the box-sizing box give
// a content width less than zero
// * that we prevent tables from becoming smaller than their
// intrinsic minimum width
nscoord result = 0, min = 0;
nscoord maxISize;
bool haveFixedMaxISize = GetAbsoluteCoord(styleMaxISize, maxISize);
nscoord minISize;
// Treat "min-width: auto" as 0.
bool haveFixedMinISize;
if (eStyleUnit_Auto == styleMinISize.GetUnit()) {
// NOTE: Technically, "auto" is supposed to behave like "min-content" on
// flex items. However, we don't need to worry about that here, because
// flex items' min-sizes are intentionally ignored until the flex
// container explicitly considers them during space distribution.
minISize = 0;
haveFixedMinISize = true;
} else {
haveFixedMinISize = GetAbsoluteCoord(styleMinISize, minISize);
}
PhysicalAxis ourInlineAxis =
aFrame->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
// If we have a specified width (or a specified 'min-width' greater
// than the specified 'max-width', which works out to the same thing),
// don't even bother getting the frame's intrinsic width, because in
// this case GetAbsoluteCoord(styleISize, w) will always succeed, so
// we'll never need the intrinsic dimensions.
if (styleISize.GetUnit() == eStyleUnit_Enumerated &&
(styleISize.GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
styleISize.GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT)) {
// -moz-fit-content and -moz-available enumerated widths compute intrinsic
// widths just like auto.
// For -moz-max-content and -moz-min-content, we handle them like
// specified widths, but ignore box-sizing.
boxSizing = StyleBoxSizing::Content;
if (aMarginBoxMinSizeClamp != NS_MAXSIZE &&
styleISize.GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT) {
// We need |result| to be the 'min-content size' for the clamping below.
result = aFrame->GetMinISize(aRenderingContext);
}
} else if (!styleISize.ConvertsToLength() &&
!(haveFixedMinISize && haveFixedMaxISize && maxISize <= minISize)) {
#ifdef DEBUG_INTRINSIC_WIDTH
++gNoiseIndent;
#endif
if (aType != MIN_ISIZE) {
// At this point, |styleISize| is auto/-moz-fit-content/-moz-available or
// has a percentage. The intrinisic size for those under a max-content
// constraint is the max-content contribution which we shouldn't clamp.
aMarginBoxMinSizeClamp = NS_MAXSIZE;
}
if (MOZ_UNLIKELY(aAxis != ourInlineAxis)) {
IntrinsicSize intrinsicSize = aFrame->GetIntrinsicSize();
const nsStyleCoord intrinsicBCoord =
horizontalAxis ? intrinsicSize.width : intrinsicSize.height;
if (intrinsicBCoord.GetUnit() == eStyleUnit_Coord) {
result = intrinsicBCoord.GetCoordValue();
} else {
// We don't have an intrinsic bsize and we need aFrame's block-dir size.
if (aFlags & BAIL_IF_REFLOW_NEEDED) {
return NS_INTRINSIC_WIDTH_UNKNOWN;
}
// XXX Unfortunately, we probably don't know this yet, so this is wrong...
// but it's not clear what we should do. If aFrame's inline size hasn't
// been determined yet, we can't necessarily figure out its block size
// either. For now, authors who put orthogonal elements into things like
// buttons or table cells may have to explicitly provide sizes rather
// than expecting intrinsic sizing to work "perfectly" in underspecified
// cases.
result = aFrame->BSize();
}
} else {
result = aType == MIN_ISIZE
? aFrame->GetMinISize(aRenderingContext)
: aFrame->GetPrefISize(aRenderingContext);
}
#ifdef DEBUG_INTRINSIC_WIDTH
--gNoiseIndent;
nsFrame::IndentBy(stderr, gNoiseIndent);
static_cast<nsFrame*>(aFrame)->ListTag(stderr);
printf_stderr(" %s %s intrinsic size from frame is %d.\n",
aType == MIN_ISIZE ? "min" : "pref",
horizontalAxis ? "horizontal" : "vertical",
result);
#endif
// Handle elements with an intrinsic ratio (or size) and a specified
// height, min-height, or max-height.
// NOTE: We treat "min-height:auto" as "0" for the purpose of this code,
// since that's what it means in all cases except for on flex items -- and
// even there, we're supposed to ignore it (i.e. treat it as 0) until the
// flex container explicitly considers it.
const nsStyleCoord& styleBSize =
horizontalAxis ? stylePos->mHeight : stylePos->mWidth;
const nsStyleCoord& styleMinBSize =
horizontalAxis ? stylePos->mMinHeight : stylePos->mMinWidth;
const nsStyleCoord& styleMaxBSize =
horizontalAxis ? stylePos->mMaxHeight : stylePos->mMaxWidth;
if (styleBSize.GetUnit() != eStyleUnit_Auto ||
!(styleMinBSize.GetUnit() == eStyleUnit_Auto ||
(styleMinBSize.GetUnit() == eStyleUnit_Coord &&
styleMinBSize.GetCoordValue() == 0)) ||
styleMaxBSize.GetUnit() != eStyleUnit_None) {
nsSize ratio(aFrame->GetIntrinsicRatio());
nscoord ratioISize = (horizontalAxis ? ratio.width : ratio.height);
nscoord ratioBSize = (horizontalAxis ? ratio.height : ratio.width);
if (ratioBSize != 0) {
AddStateBitToAncestors(aFrame,
NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE);
nscoord bSizeTakenByBoxSizing =
GetBSizeTakenByBoxSizing(boxSizing, aFrame, horizontalAxis,
aFlags & IGNORE_PADDING);
// NOTE: This is only the minContentSize if we've been passed MIN_INTRINSIC_ISIZE
// (which is fine, because this should only be used inside a check for that flag).
nscoord minContentSize = result;
nscoord h;
if (GetAbsoluteCoord(styleBSize, h) ||
GetPercentBSize(styleBSize, aFrame, horizontalAxis, h)) {
h = std::max(0, h - bSizeTakenByBoxSizing);
result = NSCoordMulDiv(h, ratioISize, ratioBSize);
}
if (GetAbsoluteCoord(styleMaxBSize, h) ||
GetPercentBSize(styleMaxBSize, aFrame, horizontalAxis, h)) {
h = std::max(0, h - bSizeTakenByBoxSizing);
nscoord maxISize = NSCoordMulDiv(h, ratioISize, ratioBSize);
if (maxISize < result) {
result = maxISize;
}
if (maxISize < minContentSize) {
minContentSize = maxISize;
}
}
if (GetAbsoluteCoord(styleMinBSize, h) ||
GetPercentBSize(styleMinBSize, aFrame, horizontalAxis, h)) {
h = std::max(0, h - bSizeTakenByBoxSizing);
nscoord minISize = NSCoordMulDiv(h, ratioISize, ratioBSize);
if (minISize > result) {
result = minISize;
}
if (minISize > minContentSize) {
minContentSize = minISize;
}
}
if (MOZ_UNLIKELY(aFlags & nsLayoutUtils::MIN_INTRINSIC_ISIZE)) {
// This is the 'min-width/height:auto' "transferred size" piece of:
// https://www.w3.org/TR/css-flexbox-1/#min-width-automatic-minimum-size
// https://drafts.csswg.org/css-grid/#min-size-auto
result = std::min(result, minContentSize);
}
}
}
}
if (aFrame->GetType() == nsGkAtoms::tableFrame) {
// Tables can't shrink smaller than their intrinsic minimum width,
// no matter what.
min = aFrame->GetMinISize(aRenderingContext);
}
nsIFrame::IntrinsicISizeOffsetData offsets =
MOZ_LIKELY(aAxis == ourInlineAxis) ? aFrame->IntrinsicISizeOffsets()
: aFrame->IntrinsicBSizeOffsets();
nscoord contentBoxSize = result;
result = AddIntrinsicSizeOffset(aRenderingContext, aFrame, offsets, aType,
boxSizing, result, min, styleISize,
haveFixedMinISize ? &minISize : nullptr,
styleMinISize,
haveFixedMaxISize ? &maxISize : nullptr,
styleMaxISize,
aFlags, aAxis);
nscoord overflow = result - aMarginBoxMinSizeClamp;
if (MOZ_UNLIKELY(overflow > 0)) {
nscoord newContentBoxSize = std::max(nscoord(0), contentBoxSize - overflow);
result -= contentBoxSize - newContentBoxSize;
}
#ifdef DEBUG_INTRINSIC_WIDTH
nsFrame::IndentBy(stderr, gNoiseIndent);
static_cast<nsFrame*>(aFrame)->ListTag(stderr);
printf_stderr(" %s %s intrinsic size for container is %d twips.\n",
aType == MIN_ISIZE ? "min" : "pref",
horizontalAxis ? "horizontal" : "vertical",
result);
#endif
return result;
}
/* static */ nscoord
nsLayoutUtils::IntrinsicForContainer(nsRenderingContext* aRenderingContext,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags)
{
MOZ_ASSERT(aFrame && aFrame->GetParent());
// We want the size aFrame will contribute to its parent's inline-size.
PhysicalAxis axis =
aFrame->GetParent()->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
return IntrinsicForAxis(axis, aRenderingContext, aFrame, aType, aFlags);
}
/* static */ nscoord
nsLayoutUtils::MinSizeContributionForAxis(PhysicalAxis aAxis,
nsRenderingContext* aRC,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags)
{
MOZ_ASSERT(aFrame);
MOZ_ASSERT(aFrame->IsFlexOrGridItem(),
"only grid/flex items have this behavior currently");
#ifdef DEBUG_INTRINSIC_WIDTH
nsFrame::IndentBy(stderr, gNoiseIndent);
static_cast<nsFrame*>(aFrame)->ListTag(stderr);
printf_stderr(" %s min-isize for %s WM:\n",
aType == MIN_ISIZE ? "min" : "pref",
aWM.IsVertical() ? "vertical" : "horizontal");
#endif
// Note: this method is only meant for grid/flex items which always
// include percentages in their intrinsic size.
aFlags |= nsLayoutUtils::ADD_PERCENTS;
const nsStylePosition* const stylePos = aFrame->StylePosition();
const nsStyleCoord* style = aAxis == eAxisHorizontal ? &stylePos->mMinWidth
: &stylePos->mMinHeight;
nscoord minSize;
nscoord* fixedMinSize = nullptr;
auto minSizeUnit = style->GetUnit();
if (minSizeUnit == eStyleUnit_Auto) {
if (aFrame->StyleDisplay()->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE) {
style = aAxis == eAxisHorizontal ? &stylePos->mWidth
: &stylePos->mHeight;
if (GetAbsoluteCoord(*style, minSize)) {
// We have a definite width/height. This is the "specified size" in:
// https://drafts.csswg.org/css-grid/#min-size-auto
fixedMinSize = &minSize;
}
// fall through - the caller will have to deal with "transferred size"
} else {
// min-[width|height]:auto with overflow != visible computes to zero.
minSize = 0;
fixedMinSize = &minSize;
}
} else if (GetAbsoluteCoord(*style, minSize)) {
fixedMinSize = &minSize;
} else if (minSizeUnit != eStyleUnit_Enumerated) {
MOZ_ASSERT(style->HasPercent());
minSize = 0;
fixedMinSize = &minSize;
}
if (!fixedMinSize) {
// Let the caller deal with the "content size" cases.
#ifdef DEBUG_INTRINSIC_WIDTH
nsFrame::IndentBy(stderr, gNoiseIndent);
static_cast<nsFrame*>(aFrame)->ListTag(stderr);
printf_stderr(" %s min-isize is indefinite.\n",
aType == MIN_ISIZE ? "min" : "pref");
#endif
return NS_UNCONSTRAINEDSIZE;
}
// If aFrame is a container for font size inflation, then shrink
// wrapping inside of it should not apply font size inflation.
AutoMaybeDisableFontInflation an(aFrame);
PhysicalAxis ourInlineAxis =
aFrame->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
nsIFrame::IntrinsicISizeOffsetData offsets =
ourInlineAxis == aAxis ? aFrame->IntrinsicISizeOffsets()
: aFrame->IntrinsicBSizeOffsets();
nscoord result = 0;
nscoord min = 0;
const nsStyleCoord& maxISize =
aAxis == eAxisHorizontal ? stylePos->mMaxWidth : stylePos->mMaxHeight;
result = AddIntrinsicSizeOffset(aRC, aFrame, offsets, aType,
stylePos->mBoxSizing,
result, min, *style, fixedMinSize,
*style, nullptr, maxISize, aFlags, aAxis);
#ifdef DEBUG_INTRINSIC_WIDTH
nsFrame::IndentBy(stderr, gNoiseIndent);
static_cast<nsFrame*>(aFrame)->ListTag(stderr);
printf_stderr(" %s min-isize is %d twips.\n",
aType == MIN_ISIZE ? "min" : "pref", result);
#endif
return result;
}
/* static */ nscoord
nsLayoutUtils::ComputeCBDependentValue(nscoord aPercentBasis,
const nsStyleCoord& aCoord)
{
NS_WARNING_ASSERTION(
aPercentBasis != NS_UNCONSTRAINEDSIZE,
"have unconstrained width or height; this should only result from very "
"large sizes, not attempts at intrinsic size calculation");
if (aCoord.IsCoordPercentCalcUnit()) {
return nsRuleNode::ComputeCoordPercentCalc(aCoord, aPercentBasis);
}
NS_ASSERTION(aCoord.GetUnit() == eStyleUnit_None ||
aCoord.GetUnit() == eStyleUnit_Auto,
"unexpected width value");
return 0;
}
/* static */ nscoord
nsLayoutUtils::ComputeBSizeDependentValue(
nscoord aContainingBlockBSize,
const nsStyleCoord& aCoord)
{
// XXXldb Some callers explicitly check aContainingBlockBSize
// against NS_AUTOHEIGHT *and* unit against eStyleUnit_Percent or
// calc()s containing percents before calling this function.
// However, it would be much more likely to catch problems without
// the unit conditions.
// XXXldb Many callers pass a non-'auto' containing block height when
// according to CSS2.1 they should be passing 'auto'.
NS_PRECONDITION(NS_AUTOHEIGHT != aContainingBlockBSize ||
!aCoord.HasPercent(),
"unexpected containing block block-size");
if (aCoord.IsCoordPercentCalcUnit()) {
return nsRuleNode::ComputeCoordPercentCalc(aCoord, aContainingBlockBSize);
}
NS_ASSERTION(aCoord.GetUnit() == eStyleUnit_None ||
aCoord.GetUnit() == eStyleUnit_Auto,
"unexpected block-size value");
return 0;
}
/* static */ void
nsLayoutUtils::MarkDescendantsDirty(nsIFrame *aSubtreeRoot)
{
AutoTArray<nsIFrame*, 4> subtrees;
subtrees.AppendElement(aSubtreeRoot);
// dirty descendants, iterating over subtrees that may include
// additional subtrees associated with placeholders
do {
nsIFrame *subtreeRoot = subtrees.ElementAt(subtrees.Length() - 1);
subtrees.RemoveElementAt(subtrees.Length() - 1);
// Mark all descendants dirty (using an nsTArray stack rather than
// recursion).
// Note that ReflowInput::InitResizeFlags has some similar
// code; see comments there for how and why it differs.
AutoTArray<nsIFrame*, 32> stack;
stack.AppendElement(subtreeRoot);
do {
nsIFrame *f = stack.ElementAt(stack.Length() - 1);
stack.RemoveElementAt(stack.Length() - 1);
f->MarkIntrinsicISizesDirty();
if (f->GetType() == nsGkAtoms::placeholderFrame) {
nsIFrame *oof = nsPlaceholderFrame::GetRealFrameForPlaceholder(f);
if (!nsLayoutUtils::IsProperAncestorFrame(subtreeRoot, oof)) {
// We have another distinct subtree we need to mark.
subtrees.AppendElement(oof);
}
}
nsIFrame::ChildListIterator lists(f);
for (; !lists.IsDone(); lists.Next()) {
nsFrameList::Enumerator childFrames(lists.CurrentList());
for (; !childFrames.AtEnd(); childFrames.Next()) {
nsIFrame* kid = childFrames.get();
stack.AppendElement(kid);
}
}
} while (stack.Length() != 0);
} while (subtrees.Length() != 0);
}
/* static */
void
nsLayoutUtils::MarkIntrinsicISizesDirtyIfDependentOnBSize(nsIFrame* aFrame)
{
AutoTArray<nsIFrame*, 32> stack;
stack.AppendElement(aFrame);
do {
nsIFrame* f = stack.ElementAt(stack.Length() - 1);
stack.RemoveElementAt(stack.Length() - 1);
if (!f->HasAnyStateBits(
NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
continue;
}
f->MarkIntrinsicISizesDirty();
for (nsIFrame::ChildListIterator lists(f); !lists.IsDone(); lists.Next()) {
for (nsIFrame* kid : lists.CurrentList()) {
stack.AppendElement(kid);
}
}
} while (stack.Length() != 0);
}
nsSize
nsLayoutUtils::ComputeAutoSizeWithIntrinsicDimensions(nscoord minWidth, nscoord minHeight,
nscoord maxWidth, nscoord maxHeight,
nscoord tentWidth, nscoord tentHeight)
{
// Now apply min/max-width/height - CSS 2.1 sections 10.4 and 10.7:
if (minWidth > maxWidth)
maxWidth = minWidth;
if (minHeight > maxHeight)
maxHeight = minHeight;
nscoord heightAtMaxWidth, heightAtMinWidth,
widthAtMaxHeight, widthAtMinHeight;
if (tentWidth > 0) {
heightAtMaxWidth = NSCoordMulDiv(maxWidth, tentHeight, tentWidth);
if (heightAtMaxWidth < minHeight)
heightAtMaxWidth = minHeight;
heightAtMinWidth = NSCoordMulDiv(minWidth, tentHeight, tentWidth);
if (heightAtMinWidth > maxHeight)
heightAtMinWidth = maxHeight;
} else {
heightAtMaxWidth = heightAtMinWidth = NS_CSS_MINMAX(tentHeight, minHeight, maxHeight);
}
if (tentHeight > 0) {
widthAtMaxHeight = NSCoordMulDiv(maxHeight, tentWidth, tentHeight);
if (widthAtMaxHeight < minWidth)
widthAtMaxHeight = minWidth;
widthAtMinHeight = NSCoordMulDiv(minHeight, tentWidth, tentHeight);
if (widthAtMinHeight > maxWidth)
widthAtMinHeight = maxWidth;
} else {
widthAtMaxHeight = widthAtMinHeight = NS_CSS_MINMAX(tentWidth, minWidth, maxWidth);
}
// The table at http://www.w3.org/TR/CSS21/visudet.html#min-max-widths :
nscoord width, height;
if (tentWidth > maxWidth) {
if (tentHeight > maxHeight) {
if (int64_t(maxWidth) * int64_t(tentHeight) <=
int64_t(maxHeight) * int64_t(tentWidth)) {
width = maxWidth;
height = heightAtMaxWidth;
} else {
width = widthAtMaxHeight;
height = maxHeight;
}
} else {
// This also covers "(w > max-width) and (h < min-height)" since in
// that case (max-width/w < 1), and with (h < min-height):
// max(max-width * h/w, min-height) == min-height
width = maxWidth;
height = heightAtMaxWidth;
}
} else if (tentWidth < minWidth) {
if (tentHeight < minHeight) {
if (int64_t(minWidth) * int64_t(tentHeight) <=
int64_t(minHeight) * int64_t(tentWidth)) {
width = widthAtMinHeight;
height = minHeight;
} else {
width = minWidth;
height = heightAtMinWidth;
}
} else {
// This also covers "(w < min-width) and (h > max-height)" since in
// that case (min-width/w > 1), and with (h > max-height):
// min(min-width * h/w, max-height) == max-height
width = minWidth;
height = heightAtMinWidth;
}
} else {
if (tentHeight > maxHeight) {
width = widthAtMaxHeight;
height = maxHeight;
} else if (tentHeight < minHeight) {
width = widthAtMinHeight;
height = minHeight;
} else {
width = tentWidth;
height = tentHeight;
}
}
return nsSize(width, height);
}
/* static */ nscoord
nsLayoutUtils::MinISizeFromInline(nsIFrame* aFrame,
nsRenderingContext* aRenderingContext)
{
NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
"should not be container for font size inflation");
nsIFrame::InlineMinISizeData data;
DISPLAY_MIN_WIDTH(aFrame, data.mPrevLines);
aFrame->AddInlineMinISize(aRenderingContext, &data);
data.ForceBreak();
return data.mPrevLines;
}
/* static */ nscoord
nsLayoutUtils::PrefISizeFromInline(nsIFrame* aFrame,
nsRenderingContext* aRenderingContext)
{
NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
"should not be container for font size inflation");
nsIFrame::InlinePrefISizeData data;
DISPLAY_PREF_WIDTH(aFrame, data.mPrevLines);
aFrame->AddInlinePrefISize(aRenderingContext, &data);
data.ForceBreak();
return data.mPrevLines;
}
static nscolor
DarkenColor(nscolor aColor)
{
uint16_t hue, sat, value;
uint8_t alpha;
// convert the RBG to HSV so we can get the lightness (which is the v)
NS_RGB2HSV(aColor, hue, sat, value, alpha);
// The goal here is to send white to black while letting colored
// stuff stay colored... So we adopt the following approach.
// Something with sat = 0 should end up with value = 0. Something
// with a high sat can end up with a high value and it's ok.... At
// the same time, we don't want to make things lighter. Do
// something simple, since it seems to work.
if (value > sat) {
value = sat;
// convert this color back into the RGB color space.
NS_HSV2RGB(aColor, hue, sat, value, alpha);
}
return aColor;
}
// Check whether we should darken text/decoration colors. We need to do this if
// background images and colors are being suppressed, because that means
// light text will not be visible against the (presumed light-colored) background.
static bool
ShouldDarkenColors(nsPresContext* aPresContext)
{
return !aPresContext->GetBackgroundColorDraw() &&
!aPresContext->GetBackgroundImageDraw();
}
nscolor
nsLayoutUtils::DarkenColorIfNeeded(nsIFrame* aFrame, nscolor aColor)
{
if (ShouldDarkenColors(aFrame->PresContext())) {
return DarkenColor(aColor);
}
return aColor;
}
gfxFloat
nsLayoutUtils::GetSnappedBaselineY(nsIFrame* aFrame, gfxContext* aContext,
nscoord aY, nscoord aAscent)
{
gfxFloat appUnitsPerDevUnit = aFrame->PresContext()->AppUnitsPerDevPixel();
gfxFloat baseline = gfxFloat(aY) + aAscent;
gfxRect putativeRect(0, baseline/appUnitsPerDevUnit, 1, 1);
if (!aContext->UserToDevicePixelSnapped(putativeRect, true))
return baseline;
return aContext->DeviceToUser(putativeRect.TopLeft()).y * appUnitsPerDevUnit;
}
gfxFloat
nsLayoutUtils::GetSnappedBaselineX(nsIFrame* aFrame, gfxContext* aContext,
nscoord aX, nscoord aAscent)
{
gfxFloat appUnitsPerDevUnit = aFrame->PresContext()->AppUnitsPerDevPixel();
gfxFloat baseline = gfxFloat(aX) + aAscent;
gfxRect putativeRect(baseline / appUnitsPerDevUnit, 0, 1, 1);
if (!aContext->UserToDevicePixelSnapped(putativeRect, true)) {
return baseline;
}
return aContext->DeviceToUser(putativeRect.TopLeft()).x * appUnitsPerDevUnit;
}
// Hard limit substring lengths to 8000 characters ... this lets us statically
// size the cluster buffer array in FindSafeLength
#define MAX_GFX_TEXT_BUF_SIZE 8000
static int32_t FindSafeLength(const char16_t *aString, uint32_t aLength,
uint32_t aMaxChunkLength)
{
if (aLength <= aMaxChunkLength)
return aLength;
int32_t len = aMaxChunkLength;
// Ensure that we don't break inside a surrogate pair
while (len > 0 && NS_IS_LOW_SURROGATE(aString[len])) {
len--;
}
if (len == 0) {
// We don't want our caller to go into an infinite loop, so don't
// return zero. It's hard to imagine how we could actually get here
// unless there are languages that allow clusters of arbitrary size.
// If there are and someone feeds us a 500+ character cluster, too
// bad.
return aMaxChunkLength;
}
return len;
}
static int32_t GetMaxChunkLength(nsFontMetrics& aFontMetrics)
{
return std::min(aFontMetrics.GetMaxStringLength(), MAX_GFX_TEXT_BUF_SIZE);
}
nscoord
nsLayoutUtils::AppUnitWidthOfString(const char16_t *aString,
uint32_t aLength,
nsFontMetrics& aFontMetrics,
DrawTarget* aDrawTarget)
{
uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
nscoord width = 0;
while (aLength > 0) {
int32_t len = FindSafeLength(aString, aLength, maxChunkLength);
width += aFontMetrics.GetWidth(aString, len, aDrawTarget);
aLength -= len;
aString += len;
}
return width;
}
nscoord
nsLayoutUtils::AppUnitWidthOfStringBidi(const char16_t* aString,
uint32_t aLength,
const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
nsRenderingContext& aContext)
{
nsPresContext* presContext = aFrame->PresContext();
if (presContext->BidiEnabled()) {
nsBidiLevel level =
nsBidiPresUtils::BidiLevelFromStyle(aFrame->StyleContext());
return nsBidiPresUtils::MeasureTextWidth(aString, aLength, level,
presContext, aContext,
aFontMetrics);
}
aFontMetrics.SetTextRunRTL(false);
aFontMetrics.SetVertical(aFrame->GetWritingMode().IsVertical());
aFontMetrics.SetTextOrientation(aFrame->StyleVisibility()->mTextOrientation);
return nsLayoutUtils::AppUnitWidthOfString(aString, aLength, aFontMetrics,
aContext.GetDrawTarget());
}
bool
nsLayoutUtils::StringWidthIsGreaterThan(const nsString& aString,
nsFontMetrics& aFontMetrics,
DrawTarget* aDrawTarget,
nscoord aWidth)
{
const char16_t *string = aString.get();
uint32_t length = aString.Length();
uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
nscoord width = 0;
while (length > 0) {
int32_t len = FindSafeLength(string, length, maxChunkLength);
width += aFontMetrics.GetWidth(string, len, aDrawTarget);
if (width > aWidth) {
return true;
}
length -= len;
string += len;
}
return false;
}
nsBoundingMetrics
nsLayoutUtils::AppUnitBoundsOfString(const char16_t* aString,
uint32_t aLength,
nsFontMetrics& aFontMetrics,
DrawTarget* aDrawTarget)
{
uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
int32_t len = FindSafeLength(aString, aLength, maxChunkLength);
// Assign directly in the first iteration. This ensures that
// negative ascent/descent can be returned and the left bearing
// is properly initialized.
nsBoundingMetrics totalMetrics =
aFontMetrics.GetBoundingMetrics(aString, len, aDrawTarget);
aLength -= len;
aString += len;
while (aLength > 0) {
len = FindSafeLength(aString, aLength, maxChunkLength);
nsBoundingMetrics metrics =
aFontMetrics.GetBoundingMetrics(aString, len, aDrawTarget);
totalMetrics += metrics;
aLength -= len;
aString += len;
}
return totalMetrics;
}
void
nsLayoutUtils::DrawString(const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
nsRenderingContext* aContext,
const char16_t* aString,
int32_t aLength,
nsPoint aPoint,
nsStyleContext* aStyleContext)
{
nsresult rv = NS_ERROR_FAILURE;
// If caller didn't pass a style context, use the frame's.
if (!aStyleContext) {
aStyleContext = aFrame->StyleContext();
}
aFontMetrics.SetVertical(WritingMode(aStyleContext).IsVertical());
aFontMetrics.SetTextOrientation(
aStyleContext->StyleVisibility()->mTextOrientation);
nsPresContext* presContext = aFrame->PresContext();
if (presContext->BidiEnabled()) {
nsBidiLevel level =
nsBidiPresUtils::BidiLevelFromStyle(aStyleContext);
rv = nsBidiPresUtils::RenderText(aString, aLength, level,
presContext, *aContext,
aContext->GetDrawTarget(), aFontMetrics,
aPoint.x, aPoint.y);
}
if (NS_FAILED(rv))
{
aFontMetrics.SetTextRunRTL(false);
DrawUniDirString(aString, aLength, aPoint, aFontMetrics, *aContext);
}
}
void
nsLayoutUtils::DrawUniDirString(const char16_t* aString,
uint32_t aLength,
nsPoint aPoint,
nsFontMetrics& aFontMetrics,
nsRenderingContext& aContext)
{
nscoord x = aPoint.x;
nscoord y = aPoint.y;
uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
if (aLength <= maxChunkLength) {
aFontMetrics.DrawString(aString, aLength, x, y, &aContext,
aContext.GetDrawTarget());
return;
}
bool isRTL = aFontMetrics.GetTextRunRTL();
// If we're drawing right to left, we must start at the end.
if (isRTL) {
x += nsLayoutUtils::AppUnitWidthOfString(aString, aLength, aFontMetrics,
aContext.GetDrawTarget());
}
while (aLength > 0) {
int32_t len = FindSafeLength(aString, aLength, maxChunkLength);
nscoord width = aFontMetrics.GetWidth(aString, len, aContext.GetDrawTarget());
if (isRTL) {
x -= width;
}
aFontMetrics.DrawString(aString, len, x, y, &aContext,
aContext.GetDrawTarget());
if (!isRTL) {
x += width;
}
aLength -= len;
aString += len;
}
}
/* static */ void
nsLayoutUtils::PaintTextShadow(const nsIFrame* aFrame,
nsRenderingContext* aContext,
const nsRect& aTextRect,
const nsRect& aDirtyRect,
const nscolor& aForegroundColor,
TextShadowCallback aCallback,
void* aCallbackData)
{
const nsStyleText* textStyle = aFrame->StyleText();
if (!textStyle->HasTextShadow())
return;
// Text shadow happens with the last value being painted at the back,
// ie. it is painted first.
gfxContext* aDestCtx = aContext->ThebesContext();
for (uint32_t i = textStyle->mTextShadow->Length(); i > 0; --i) {
nsCSSShadowItem* shadowDetails = textStyle->mTextShadow->ShadowAt(i - 1);
nsPoint shadowOffset(shadowDetails->mXOffset,
shadowDetails->mYOffset);
nscoord blurRadius = std::max(shadowDetails->mRadius, 0);
nsRect shadowRect(aTextRect);
shadowRect.MoveBy(shadowOffset);
nsPresContext* presCtx = aFrame->PresContext();
nsContextBoxBlur contextBoxBlur;
gfxContext* shadowContext = contextBoxBlur.Init(shadowRect, 0, blurRadius,
presCtx->AppUnitsPerDevPixel(),
aDestCtx, aDirtyRect, nullptr);
if (!shadowContext)
continue;
nscolor shadowColor;
if (shadowDetails->mHasColor)
shadowColor = shadowDetails->mColor;
else
shadowColor = aForegroundColor;
// Conjure an nsRenderingContext from a gfxContext for drawing the text
// to blur.
nsRenderingContext renderingContext(shadowContext);
aDestCtx->Save();
aDestCtx->NewPath();
aDestCtx->SetColor(Color::FromABGR(shadowColor));
// The callback will draw whatever we want to blur as a shadow.
aCallback(&renderingContext, shadowOffset, shadowColor, aCallbackData);
contextBoxBlur.DoPaint();
aDestCtx->Restore();
}
}
/* static */ nscoord
nsLayoutUtils::GetCenteredFontBaseline(nsFontMetrics* aFontMetrics,
nscoord aLineHeight,
bool aIsInverted)
{
nscoord fontAscent = aIsInverted ? aFontMetrics->MaxDescent()
: aFontMetrics->MaxAscent();
nscoord fontHeight = aFontMetrics->MaxHeight();
nscoord leading = aLineHeight - fontHeight;
return fontAscent + leading/2;
}
/* static */ bool
nsLayoutUtils::GetFirstLineBaseline(WritingMode aWritingMode,
const nsIFrame* aFrame, nscoord* aResult)
{
LinePosition position;
if (!GetFirstLinePosition(aWritingMode, aFrame, &position))
return false;
*aResult = position.mBaseline;
return true;
}
/* static */ bool
nsLayoutUtils::GetFirstLinePosition(WritingMode aWM,
const nsIFrame* aFrame,
LinePosition* aResult)
{
const nsBlockFrame* block = nsLayoutUtils::GetAsBlock(const_cast<nsIFrame*>(aFrame));
if (!block) {
// For the first-line baseline we also have to check for a table, and if
// so, use the baseline of its first row.
nsIAtom* fType = aFrame->GetType();
if (fType == nsGkAtoms::tableWrapperFrame ||
fType == nsGkAtoms::flexContainerFrame ||
fType == nsGkAtoms::gridContainerFrame) {
if ((fType == nsGkAtoms::gridContainerFrame &&
aFrame->HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) ||
(fType == nsGkAtoms::flexContainerFrame &&
aFrame->HasAnyStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE)) ||
(fType == nsGkAtoms::tableWrapperFrame &&
static_cast<const nsTableWrapperFrame*>(aFrame)->GetRowCount() == 0)) {
// empty grid/flex/table container
aResult->mBStart = 0;
aResult->mBaseline = aFrame->SynthesizeBaselineBOffsetFromBorderBox(aWM,
BaselineSharingGroup::eFirst);
aResult->mBEnd = aFrame->BSize(aWM);
return true;
}
aResult->mBStart = 0;
aResult->mBaseline = aFrame->GetLogicalBaseline(aWM);
// This is what we want for the list bullet caller; not sure if
// other future callers will want the same.
aResult->mBEnd = aFrame->BSize(aWM);
return true;
}
// For first-line baselines, we have to consider scroll frames.
if (fType == nsGkAtoms::scrollFrame) {
nsIScrollableFrame *sFrame = do_QueryFrame(const_cast<nsIFrame*>(aFrame));
if (!sFrame) {
NS_NOTREACHED("not scroll frame");
}
LinePosition kidPosition;
if (GetFirstLinePosition(aWM,
sFrame->GetScrolledFrame(), &kidPosition)) {
// Consider only the border and padding that contributes to the
// kid's position, not the scrolling, so we get the initial
// position.
*aResult = kidPosition +
aFrame->GetLogicalUsedBorderAndPadding(aWM).BStart(aWM);
return true;
}
return false;
}
if (fType == nsGkAtoms::fieldSetFrame) {
LinePosition kidPosition;
nsIFrame* kid = aFrame->PrincipalChildList().FirstChild();
// kid might be a legend frame here, but that's ok.
if (GetFirstLinePosition(aWM, kid, &kidPosition)) {
*aResult = kidPosition +
kid->GetLogicalNormalPosition(aWM, aFrame->GetSize()).B(aWM);
return true;
}
return false;
}
// No baseline.
return false;
}
for (nsBlockFrame::ConstLineIterator line = block->LinesBegin(),
line_end = block->LinesEnd();
line != line_end; ++line) {
if (line->IsBlock()) {
nsIFrame *kid = line->mFirstChild;
LinePosition kidPosition;
if (GetFirstLinePosition(aWM, kid, &kidPosition)) {
//XXX Not sure if this is the correct value to use for container
// width here. It will only be used in vertical-rl layout,
// which we don't have full support and testing for yet.
const nsSize& containerSize = line->mContainerSize;
*aResult = kidPosition +
kid->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
return true;
}
} else {
// XXX Is this the right test? We have some bogus empty lines
// floating around, but IsEmpty is perhaps too weak.
if (line->BSize() != 0 || !line->IsEmpty()) {
nscoord bStart = line->BStart();
aResult->mBStart = bStart;
aResult->mBaseline = bStart + line->GetLogicalAscent();
aResult->mBEnd = bStart + line->BSize();
return true;
}
}
}
return false;
}
/* static */ bool
nsLayoutUtils::GetLastLineBaseline(WritingMode aWM,
const nsIFrame* aFrame, nscoord* aResult)
{
const nsBlockFrame* block = nsLayoutUtils::GetAsBlock(const_cast<nsIFrame*>(aFrame));
if (!block)
// No baseline. (We intentionally don't descend into scroll frames.)
return false;
for (nsBlockFrame::ConstReverseLineIterator line = block->LinesRBegin(),
line_end = block->LinesREnd();
line != line_end; ++line) {
if (line->IsBlock()) {
nsIFrame *kid = line->mFirstChild;
nscoord kidBaseline;
const nsSize& containerSize = line->mContainerSize;
if (GetLastLineBaseline(aWM, kid, &kidBaseline)) {
// Ignore relative positioning for baseline calculations
*aResult = kidBaseline +
kid->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
return true;
} else if (kid->GetType() == nsGkAtoms::scrollFrame) {
// Defer to nsFrame::GetLogicalBaseline (which synthesizes a baseline
// from the margin-box).
kidBaseline = kid->GetLogicalBaseline(aWM);
*aResult = kidBaseline +
kid->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
return true;
}
} else {
// XXX Is this the right test? We have some bogus empty lines
// floating around, but IsEmpty is perhaps too weak.
if (line->BSize() != 0 || !line->IsEmpty()) {
*aResult = line->BStart() + line->GetLogicalAscent();
return true;
}
}
}
return false;
}
static nscoord
CalculateBlockContentBEnd(WritingMode aWM, nsBlockFrame* aFrame)
{
NS_PRECONDITION(aFrame, "null ptr");
nscoord contentBEnd = 0;
for (nsBlockFrame::LineIterator line = aFrame->LinesBegin(),
line_end = aFrame->LinesEnd();
line != line_end; ++line) {
if (line->IsBlock()) {
nsIFrame* child = line->mFirstChild;
const nsSize& containerSize = line->mContainerSize;
nscoord offset =
child->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
contentBEnd =
std::max(contentBEnd,
nsLayoutUtils::CalculateContentBEnd(aWM, child) + offset);
}
else {
contentBEnd = std::max(contentBEnd, line->BEnd());
}
}
return contentBEnd;
}
/* static */ nscoord
nsLayoutUtils::CalculateContentBEnd(WritingMode aWM, nsIFrame* aFrame)
{
NS_PRECONDITION(aFrame, "null ptr");
nscoord contentBEnd = aFrame->BSize(aWM);
// We want scrollable overflow rather than visual because this
// calculation is intended to affect layout.
LogicalSize overflowSize(aWM, aFrame->GetScrollableOverflowRect().Size());
if (overflowSize.BSize(aWM) > contentBEnd) {
nsIFrame::ChildListIDs skip(nsIFrame::kOverflowList |
nsIFrame::kExcessOverflowContainersList |
nsIFrame::kOverflowOutOfFlowList);
nsBlockFrame* blockFrame = GetAsBlock(aFrame);
if (blockFrame) {
contentBEnd =
std::max(contentBEnd, CalculateBlockContentBEnd(aWM, blockFrame));
skip |= nsIFrame::kPrincipalList;
}
nsIFrame::ChildListIterator lists(aFrame);
for (; !lists.IsDone(); lists.Next()) {
if (!skip.Contains(lists.CurrentID())) {
nsFrameList::Enumerator childFrames(lists.CurrentList());
for (; !childFrames.AtEnd(); childFrames.Next()) {
nsIFrame* child = childFrames.get();
nscoord offset =
child->GetLogicalNormalPosition(aWM,
aFrame->GetSize()).B(aWM);
contentBEnd = std::max(contentBEnd,
CalculateContentBEnd(aWM, child) + offset);
}
}
}
}
return contentBEnd;
}
/* static */ nsIFrame*
nsLayoutUtils::GetClosestLayer(nsIFrame* aFrame)
{
nsIFrame* layer;
for (layer = aFrame; layer; layer = layer->GetParent()) {
if (layer->IsAbsPosContainingBlock() ||
(layer->GetParent() &&
layer->GetParent()->GetType() == nsGkAtoms::scrollFrame))
break;
}
if (layer)
return layer;
return aFrame->PresContext()->PresShell()->FrameManager()->GetRootFrame();
}
SamplingFilter
nsLayoutUtils::GetSamplingFilterForFrame(nsIFrame* aForFrame)
{
SamplingFilter defaultFilter = SamplingFilter::GOOD;
nsStyleContext *sc;
if (nsCSSRendering::IsCanvasFrame(aForFrame)) {
nsCSSRendering::FindBackground(aForFrame, &sc);
} else {
sc = aForFrame->StyleContext();
}
switch (sc->StyleVisibility()->mImageRendering) {
case NS_STYLE_IMAGE_RENDERING_OPTIMIZESPEED:
return SamplingFilter::POINT;
case NS_STYLE_IMAGE_RENDERING_OPTIMIZEQUALITY:
return SamplingFilter::LINEAR;
case NS_STYLE_IMAGE_RENDERING_CRISPEDGES:
return SamplingFilter::POINT;
default:
return defaultFilter;
}
}
/**
* Given an image being drawn into an appunit coordinate system, and
* a point in that coordinate system, map the point back into image
* pixel space.
* @param aSize the size of the image, in pixels
* @param aDest the rectangle that the image is being mapped into
* @param aPt a point in the same coordinate system as the rectangle
*/
static gfxPoint
MapToFloatImagePixels(const gfxSize& aSize,
const gfxRect& aDest, const gfxPoint& aPt)
{
return gfxPoint(((aPt.x - aDest.X())*aSize.width)/aDest.Width(),
((aPt.y - aDest.Y())*aSize.height)/aDest.Height());
}
/**
* Given an image being drawn into an pixel-based coordinate system, and
* a point in image space, map the point into the pixel-based coordinate
* system.
* @param aSize the size of the image, in pixels
* @param aDest the rectangle that the image is being mapped into
* @param aPt a point in image space
*/
static gfxPoint
MapToFloatUserPixels(const gfxSize& aSize,
const gfxRect& aDest, const gfxPoint& aPt)
{
return gfxPoint(aPt.x*aDest.Width()/aSize.width + aDest.X(),
aPt.y*aDest.Height()/aSize.height + aDest.Y());
}
/* static */ gfxRect
nsLayoutUtils::RectToGfxRect(const nsRect& aRect, int32_t aAppUnitsPerDevPixel)
{
return gfxRect(gfxFloat(aRect.x) / aAppUnitsPerDevPixel,
gfxFloat(aRect.y) / aAppUnitsPerDevPixel,
gfxFloat(aRect.width) / aAppUnitsPerDevPixel,
gfxFloat(aRect.height) / aAppUnitsPerDevPixel);
}
struct SnappedImageDrawingParameters {
// A transform from image space to device space.
gfxMatrix imageSpaceToDeviceSpace;
// The size at which the image should be drawn (which may not be its
// intrinsic size due to, for example, HQ scaling).
nsIntSize size;
// The region in tiled image space which will be drawn, with an associated
// region to which sampling should be restricted.
ImageRegion region;
// The default viewport size for SVG images, which we use unless a different
// one has been explicitly specified. This is the same as |size| except that
// it does not take into account any transformation on the gfxContext we're
// drawing to - for example, CSS transforms are not taken into account.
CSSIntSize svgViewportSize;
// Whether there's anything to draw at all.
bool shouldDraw;
SnappedImageDrawingParameters()
: region(ImageRegion::Empty())
, shouldDraw(false)
{}
SnappedImageDrawingParameters(const gfxMatrix& aImageSpaceToDeviceSpace,
const nsIntSize& aSize,
const ImageRegion& aRegion,
const CSSIntSize& aSVGViewportSize)
: imageSpaceToDeviceSpace(aImageSpaceToDeviceSpace)
, size(aSize)
, region(aRegion)
, svgViewportSize(aSVGViewportSize)
, shouldDraw(true)
{}
};
/**
* Given two axis-aligned rectangles, returns the transformation that maps the
* first onto the second.
*
* @param aFrom The rect to be transformed.
* @param aTo The rect that aFrom should be mapped onto by the transformation.
*/
static gfxMatrix
TransformBetweenRects(const gfxRect& aFrom, const gfxRect& aTo)
{
gfxSize scale(aTo.width / aFrom.width,
aTo.height / aFrom.height);
gfxPoint translation(aTo.x - aFrom.x * scale.width,
aTo.y - aFrom.y * scale.height);
return gfxMatrix(scale.width, 0, 0, scale.height,
translation.x, translation.y);
}
static nsRect
TileNearRect(const nsRect& aAnyTile, const nsRect& aTargetRect)
{
nsPoint distance = aTargetRect.TopLeft() - aAnyTile.TopLeft();
return aAnyTile + nsPoint(distance.x / aAnyTile.width * aAnyTile.width,
distance.y / aAnyTile.height * aAnyTile.height);
}
static gfxFloat
StableRound(gfxFloat aValue)
{
// Values slightly less than 0.5 should round up like 0.5 would; we're
// assuming they were meant to be 0.5.
return floor(aValue + 0.5001);
}
static gfxPoint
StableRound(const gfxPoint& aPoint)
{
return gfxPoint(StableRound(aPoint.x), StableRound(aPoint.y));
}
/**
* Given a set of input parameters, compute certain output parameters
* for drawing an image with the image snapping algorithm.
* See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
*
* @see nsLayoutUtils::DrawImage() for the descriptions of input parameters
*/
static SnappedImageDrawingParameters
ComputeSnappedImageDrawingParameters(gfxContext* aCtx,
int32_t aAppUnitsPerDevPixel,
const nsRect aDest,
const nsRect aFill,
const nsPoint aAnchor,
const nsRect aDirty,
imgIContainer* aImage,
const SamplingFilter aSamplingFilter,
uint32_t aImageFlags,
ExtendMode aExtendMode)
{
if (aDest.IsEmpty() || aFill.IsEmpty())
return SnappedImageDrawingParameters();
// Avoid unnecessarily large offsets.
bool doTile = !aDest.Contains(aFill);
nsRect appUnitDest = doTile ? TileNearRect(aDest, aFill.Intersect(aDirty))
: aDest;
nsPoint anchor = aAnchor + (appUnitDest.TopLeft() - aDest.TopLeft());
gfxRect devPixelDest =
nsLayoutUtils::RectToGfxRect(appUnitDest, aAppUnitsPerDevPixel);
gfxRect devPixelFill =
nsLayoutUtils::RectToGfxRect(aFill, aAppUnitsPerDevPixel);
gfxRect devPixelDirty =
nsLayoutUtils::RectToGfxRect(aDirty, aAppUnitsPerDevPixel);
gfxMatrix currentMatrix = aCtx->CurrentMatrix();
gfxRect fill = devPixelFill;
gfxRect dest = devPixelDest;
bool didSnap;
// Snap even if we have a scale in the context. But don't snap if
// we have something that's not translation+scale, or if the scale flips in
// the X or Y direction, because snapped image drawing can't handle that yet.
if (!currentMatrix.HasNonAxisAlignedTransform() &&
currentMatrix._11 > 0.0 && currentMatrix._22 > 0.0 &&
aCtx->UserToDevicePixelSnapped(fill, true) &&
aCtx->UserToDevicePixelSnapped(dest, true)) {
// We snapped. On this code path, |fill| and |dest| take into account
// currentMatrix's transform.
didSnap = true;
} else {
// We didn't snap. On this code path, |fill| and |dest| do not take into
// account currentMatrix's transform.
didSnap = false;
fill = devPixelFill;
dest = devPixelDest;
}
// If we snapped above, |dest| already takes into account |currentMatrix|'s scale
// and has integer coordinates. If not, we need these properties to compute
// the optimal drawn image size, so compute |snappedDestSize| here.
gfxSize snappedDestSize = dest.Size();
if (!didSnap) {
gfxSize scaleFactors = currentMatrix.ScaleFactors(true);
snappedDestSize.Scale(scaleFactors.width, scaleFactors.height);
snappedDestSize.width = NS_round(snappedDestSize.width);
snappedDestSize.height = NS_round(snappedDestSize.height);
}
// We need to be sure that this is at least one pixel in width and height,
// or we'll end up drawing nothing even if we have a nonempty fill.
snappedDestSize.width = std::max(snappedDestSize.width, 1.0);
snappedDestSize.height = std::max(snappedDestSize.height, 1.0);
// Bail if we're not going to end up drawing anything.
if (fill.IsEmpty() || snappedDestSize.IsEmpty()) {
return SnappedImageDrawingParameters();
}
nsIntSize intImageSize =
aImage->OptimalImageSizeForDest(snappedDestSize,
imgIContainer::FRAME_CURRENT,
aSamplingFilter, aImageFlags);
gfxSize imageSize(intImageSize.width, intImageSize.height);
// XXX(seth): May be buggy; see bug 1151016.
CSSIntSize svgViewportSize = currentMatrix.IsIdentity()
? CSSIntSize(intImageSize.width, intImageSize.height)
: CSSIntSize::Truncate(devPixelDest.width, devPixelDest.height);
// Compute the set of pixels that would be sampled by an ideal rendering
gfxPoint subimageTopLeft =
MapToFloatImagePixels(imageSize, devPixelDest, devPixelFill.TopLeft());
gfxPoint subimageBottomRight =
MapToFloatImagePixels(imageSize, devPixelDest, devPixelFill.BottomRight());
gfxRect subimage;
subimage.MoveTo(NSToIntFloor(subimageTopLeft.x),
NSToIntFloor(subimageTopLeft.y));
subimage.SizeTo(NSToIntCeil(subimageBottomRight.x) - subimage.x,
NSToIntCeil(subimageBottomRight.y) - subimage.y);
if (subimage.IsEmpty()) {
// Bail if the subimage is empty (we're not going to be drawing anything).
return SnappedImageDrawingParameters();
}
gfxMatrix transform;
gfxMatrix invTransform;
bool anchorAtUpperLeft = anchor.x == appUnitDest.x &&
anchor.y == appUnitDest.y;
bool exactlyOneImageCopy = aFill.IsEqualEdges(appUnitDest);
if (anchorAtUpperLeft && exactlyOneImageCopy) {
// The simple case: we can ignore the anchor point and compute the
// transformation from the sampled region (the subimage) to the fill rect.
// This approach is preferable when it works since it tends to produce
// less numerical error.
transform = TransformBetweenRects(subimage, fill);
invTransform = TransformBetweenRects(fill, subimage);
} else {
// The more complicated case: we compute the transformation from the
// image rect positioned at the image space anchor point to the dest rect
// positioned at the device space anchor point.
// Compute the anchor point in both device space and image space. This
// code assumes that pixel-based devices have one pixel per device unit!
gfxPoint anchorPoint(gfxFloat(anchor.x)/aAppUnitsPerDevPixel,
gfxFloat(anchor.y)/aAppUnitsPerDevPixel);
gfxPoint imageSpaceAnchorPoint =
MapToFloatImagePixels(imageSize, devPixelDest, anchorPoint);
if (didSnap) {
imageSpaceAnchorPoint = StableRound(imageSpaceAnchorPoint);
anchorPoint = imageSpaceAnchorPoint;
anchorPoint = MapToFloatUserPixels(imageSize, devPixelDest, anchorPoint);
anchorPoint = currentMatrix.Transform(anchorPoint);
anchorPoint = StableRound(anchorPoint);
}
// Compute an unsnapped version of the dest rect's size. We continue to
// follow the pattern that we take |currentMatrix| into account only if
// |didSnap| is true.
gfxSize unsnappedDestSize
= didSnap ? devPixelDest.Size() * currentMatrix.ScaleFactors(true)
: devPixelDest.Size();
gfxRect anchoredDestRect(anchorPoint, unsnappedDestSize);
gfxRect anchoredImageRect(imageSpaceAnchorPoint, imageSize);
// Calculate anchoredDestRect with snapped fill rect when the devPixelFill rect
// corresponds to just a single tile in that direction
if (fill.Width() != devPixelFill.Width() &&
devPixelDest.x == devPixelFill.x &&
devPixelDest.XMost() == devPixelFill.XMost()) {
anchoredDestRect.width = fill.width;
}
if (fill.Height() != devPixelFill.Height() &&
devPixelDest.y == devPixelFill.y &&
devPixelDest.YMost() == devPixelFill.YMost()) {
anchoredDestRect.height = fill.height;
}
transform = TransformBetweenRects(anchoredImageRect, anchoredDestRect);
invTransform = TransformBetweenRects(anchoredDestRect, anchoredImageRect);
}
// If the transform is not a straight translation by integers, then
// filtering will occur, and restricting the fill rect to the dirty rect
// would change the values computed for edge pixels, which we can't allow.
// Also, if 'didSnap' is false then rounding out 'devPixelDirty' might not
// produce pixel-aligned coordinates, which would also break the values
// computed for edge pixels.
if (didSnap && !invTransform.HasNonIntegerTranslation()) {
// This form of Transform is safe to call since non-axis-aligned
// transforms wouldn't be snapped.
devPixelDirty = currentMatrix.Transform(devPixelDirty);
devPixelDirty.RoundOut();
fill = fill.Intersect(devPixelDirty);
}
if (fill.IsEmpty())
return SnappedImageDrawingParameters();
gfxRect imageSpaceFill(didSnap ? invTransform.Transform(fill)
: invTransform.TransformBounds(fill));
// If we didn't snap, we need to post-multiply the matrix on the context to
// get the final matrix we'll draw with, because we didn't take it into
// account when computing the matrices above.
if (!didSnap) {
transform = transform * currentMatrix;
}
ExtendMode extendMode = (aImageFlags & imgIContainer::FLAG_CLAMP)
? ExtendMode::CLAMP
: aExtendMode;
// We were passed in the default extend mode but need to tile.
if (extendMode == ExtendMode::CLAMP && doTile) {
MOZ_ASSERT(!(aImageFlags & imgIContainer::FLAG_CLAMP));
extendMode = ExtendMode::REPEAT;
}
ImageRegion region =
ImageRegion::CreateWithSamplingRestriction(imageSpaceFill, subimage, extendMode);
return SnappedImageDrawingParameters(transform, intImageSize,
region, svgViewportSize);
}
static DrawResult
DrawImageInternal(gfxContext& aContext,
nsPresContext* aPresContext,
imgIContainer* aImage,
const SamplingFilter aSamplingFilter,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsRect& aDirty,
const SVGImageContext* aSVGContext,
uint32_t aImageFlags,
ExtendMode aExtendMode = ExtendMode::CLAMP,
float aOpacity = 1.0)
{
DrawResult result = DrawResult::SUCCESS;
aImageFlags |= imgIContainer::FLAG_ASYNC_NOTIFY;
if (aPresContext->Type() == nsPresContext::eContext_Print) {
// We want vector images to be passed on as vector commands, not a raster
// image.
aImageFlags |= imgIContainer::FLAG_BYPASS_SURFACE_CACHE;
}
if (aDest.Contains(aFill)) {
aImageFlags |= imgIContainer::FLAG_CLAMP;
}
int32_t appUnitsPerDevPixel =
aPresContext->AppUnitsPerDevPixel();
SnappedImageDrawingParameters params =
ComputeSnappedImageDrawingParameters(&aContext, appUnitsPerDevPixel, aDest,
aFill, aAnchor, aDirty, aImage,
aSamplingFilter, aImageFlags, aExtendMode);
if (!params.shouldDraw) {
return result;
}
{
gfxContextMatrixAutoSaveRestore contextMatrixRestorer(&aContext);
RefPtr<gfxContext> destCtx = &aContext;
destCtx->SetMatrix(params.imageSpaceToDeviceSpace);
Maybe<SVGImageContext> svgContext = ToMaybe(aSVGContext);
if (!svgContext) {
// Use the default viewport.
svgContext = Some(SVGImageContext(params.svgViewportSize, Nothing()));
}
result = aImage->Draw(destCtx, params.size, params.region,
imgIContainer::FRAME_CURRENT, aSamplingFilter,
svgContext, aImageFlags, aOpacity);
}
return result;
}
/* static */ DrawResult
nsLayoutUtils::DrawSingleUnscaledImage(gfxContext& aContext,
nsPresContext* aPresContext,
imgIContainer* aImage,
const SamplingFilter aSamplingFilter,
const nsPoint& aDest,
const nsRect* aDirty,
uint32_t aImageFlags,
const nsRect* aSourceArea)
{
CSSIntSize imageSize;
aImage->GetWidth(&imageSize.width);
aImage->GetHeight(&imageSize.height);
if (imageSize.width < 1 || imageSize.height < 1) {
NS_WARNING("Image width or height is non-positive");
return DrawResult::TEMPORARY_ERROR;
}
nsSize size(CSSPixel::ToAppUnits(imageSize));
nsRect source;
if (aSourceArea) {
source = *aSourceArea;
} else {
source.SizeTo(size);
}
nsRect dest(aDest - source.TopLeft(), size);
nsRect fill(aDest, source.Size());
// Ensure that only a single image tile is drawn. If aSourceArea extends
// outside the image bounds, we want to honor the aSourceArea-to-aDest
// translation but we don't want to actually tile the image.
fill.IntersectRect(fill, dest);
return DrawImageInternal(aContext, aPresContext,
aImage, aSamplingFilter,
dest, fill, aDest, aDirty ? *aDirty : dest,
nullptr, aImageFlags);
}
/* static */ DrawResult
nsLayoutUtils::DrawSingleImage(gfxContext& aContext,
nsPresContext* aPresContext,
imgIContainer* aImage,
const SamplingFilter aSamplingFilter,
const nsRect& aDest,
const nsRect& aDirty,
const SVGImageContext* aSVGContext,
uint32_t aImageFlags,
const nsPoint* aAnchorPoint,
const nsRect* aSourceArea)
{
nscoord appUnitsPerCSSPixel = nsDeviceContext::AppUnitsPerCSSPixel();
CSSIntSize pixelImageSize(ComputeSizeForDrawingWithFallback(aImage, aDest.Size()));
if (pixelImageSize.width < 1 || pixelImageSize.height < 1) {
NS_WARNING("Image width or height is non-positive");
return DrawResult::TEMPORARY_ERROR;
}
nsSize imageSize(CSSPixel::ToAppUnits(pixelImageSize));
nsRect source;
nsCOMPtr<imgIContainer> image;
if (aSourceArea) {
source = *aSourceArea;
nsIntRect subRect(source.x, source.y, source.width, source.height);
subRect.ScaleInverseRoundOut(appUnitsPerCSSPixel);
image = ImageOps::Clip(aImage, subRect);
nsRect imageRect;
imageRect.SizeTo(imageSize);
nsRect clippedSource = imageRect.Intersect(source);
source -= clippedSource.TopLeft();
imageSize = clippedSource.Size();
} else {
source.SizeTo(imageSize);
image = aImage;
}
nsRect dest = GetWholeImageDestination(imageSize, source, aDest);
// Ensure that only a single image tile is drawn. If aSourceArea extends
// outside the image bounds, we want to honor the aSourceArea-to-aDest
// transform but we don't want to actually tile the image.
nsRect fill;
fill.IntersectRect(aDest, dest);
return DrawImageInternal(aContext, aPresContext, image,
aSamplingFilter, dest, fill,
aAnchorPoint ? *aAnchorPoint : fill.TopLeft(),
aDirty, aSVGContext, aImageFlags);
}
/* static */ void
nsLayoutUtils::ComputeSizeForDrawing(imgIContainer *aImage,
CSSIntSize& aImageSize, /*outparam*/
nsSize& aIntrinsicRatio, /*outparam*/
bool& aGotWidth, /*outparam*/
bool& aGotHeight /*outparam*/)
{
aGotWidth = NS_SUCCEEDED(aImage->GetWidth(&aImageSize.width));
aGotHeight = NS_SUCCEEDED(aImage->GetHeight(&aImageSize.height));
bool gotRatio = NS_SUCCEEDED(aImage->GetIntrinsicRatio(&aIntrinsicRatio));
if (!(aGotWidth && aGotHeight) && !gotRatio) {
// We hit an error (say, because the image failed to load or couldn't be
// decoded) and should return zero size.
aGotWidth = aGotHeight = true;
aImageSize = CSSIntSize(0, 0);
aIntrinsicRatio = nsSize(0, 0);
}
}
/* static */ CSSIntSize
nsLayoutUtils::ComputeSizeForDrawingWithFallback(imgIContainer* aImage,
const nsSize& aFallbackSize)
{
CSSIntSize imageSize;
nsSize imageRatio;
bool gotHeight, gotWidth;
ComputeSizeForDrawing(aImage, imageSize, imageRatio, gotWidth, gotHeight);
// If we didn't get both width and height, try to compute them using the
// intrinsic ratio of the image.
if (gotWidth != gotHeight) {
if (!gotWidth) {
if (imageRatio.height != 0) {
imageSize.width =
NSCoordSaturatingNonnegativeMultiply(imageSize.height,
float(imageRatio.width) /
float(imageRatio.height));
gotWidth = true;
}
} else {
if (imageRatio.width != 0) {
imageSize.height =
NSCoordSaturatingNonnegativeMultiply(imageSize.width,
float(imageRatio.height) /
float(imageRatio.width));
gotHeight = true;
}
}
}
// If we still don't have a width or height, just use the fallback size the
// caller provided.
if (!gotWidth) {
imageSize.width = nsPresContext::AppUnitsToIntCSSPixels(aFallbackSize.width);
}
if (!gotHeight) {
imageSize.height = nsPresContext::AppUnitsToIntCSSPixels(aFallbackSize.height);
}
return imageSize;
}
/* static */ DrawResult
nsLayoutUtils::DrawBackgroundImage(gfxContext& aContext,
nsPresContext* aPresContext,
imgIContainer* aImage,
const CSSIntSize& aImageSize,
SamplingFilter aSamplingFilter,
const nsRect& aDest,
const nsRect& aFill,
const nsSize& aRepeatSize,
const nsPoint& aAnchor,
const nsRect& aDirty,
uint32_t aImageFlags,
ExtendMode aExtendMode,
float aOpacity)
{
PROFILER_LABEL("layout", "nsLayoutUtils::DrawBackgroundImage",
js::ProfileEntry::Category::GRAPHICS);
SVGImageContext svgContext(aImageSize, Nothing());
/* Fast path when there is no need for image spacing */
if (aRepeatSize.width == aDest.width && aRepeatSize.height == aDest.height) {
return DrawImageInternal(aContext, aPresContext, aImage,
aSamplingFilter, aDest, aFill, aAnchor,
aDirty, &svgContext, aImageFlags, aExtendMode,
aOpacity);
}
nsPoint firstTilePos = aDest.TopLeft() +
nsPoint(NSToIntFloor(float(aFill.x - aDest.x) / aRepeatSize.width) * aRepeatSize.width,
NSToIntFloor(float(aFill.y - aDest.y) / aRepeatSize.height) * aRepeatSize.height);
for (int32_t i = firstTilePos.x; i < aFill.XMost(); i += aRepeatSize.width) {
for (int32_t j = firstTilePos.y; j < aFill.YMost(); j += aRepeatSize.height) {
nsRect dest(i, j, aDest.width, aDest.height);
DrawResult result = DrawImageInternal(aContext, aPresContext, aImage, aSamplingFilter,
dest, dest, aAnchor, aDirty, &svgContext,
aImageFlags, ExtendMode::CLAMP,
aOpacity);
if (result != DrawResult::SUCCESS) {
return result;
}
}
}
return DrawResult::SUCCESS;
}
/* static */ DrawResult
nsLayoutUtils::DrawImage(gfxContext& aContext,
nsPresContext* aPresContext,
imgIContainer* aImage,
const SamplingFilter aSamplingFilter,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsRect& aDirty,
uint32_t aImageFlags,
float aOpacity)
{
return DrawImageInternal(aContext, aPresContext, aImage,
aSamplingFilter, aDest, aFill, aAnchor,
aDirty, nullptr, aImageFlags, ExtendMode::CLAMP,
aOpacity);
}
/* static */ nsRect
nsLayoutUtils::GetWholeImageDestination(const nsSize& aWholeImageSize,
const nsRect& aImageSourceArea,
const nsRect& aDestArea)
{
double scaleX = double(aDestArea.width)/aImageSourceArea.width;
double scaleY = double(aDestArea.height)/aImageSourceArea.height;
nscoord destOffsetX = NSToCoordRound(aImageSourceArea.x*scaleX);
nscoord destOffsetY = NSToCoordRound(aImageSourceArea.y*scaleY);
nscoord wholeSizeX = NSToCoordRound(aWholeImageSize.width*scaleX);
nscoord wholeSizeY = NSToCoordRound(aWholeImageSize.height*scaleY);
return nsRect(aDestArea.TopLeft() - nsPoint(destOffsetX, destOffsetY),
nsSize(wholeSizeX, wholeSizeY));
}
/* static */ already_AddRefed<imgIContainer>
nsLayoutUtils::OrientImage(imgIContainer* aContainer,
const nsStyleImageOrientation& aOrientation)
{
MOZ_ASSERT(aContainer, "Should have an image container");
nsCOMPtr<imgIContainer> img(aContainer);
if (aOrientation.IsFromImage()) {
img = ImageOps::Orient(img, img->GetOrientation());
} else if (!aOrientation.IsDefault()) {
Angle angle = aOrientation.Angle();
Flip flip = aOrientation.IsFlipped() ? Flip::Horizontal
: Flip::Unflipped;
img = ImageOps::Orient(img, Orientation(angle, flip));
}
return img.forget();
}
static bool NonZeroStyleCoord(const nsStyleCoord& aCoord)
{
if (aCoord.IsCoordPercentCalcUnit()) {
// Since negative results are clamped to 0, check > 0.
return nsRuleNode::ComputeCoordPercentCalc(aCoord, nscoord_MAX) > 0 ||
nsRuleNode::ComputeCoordPercentCalc(aCoord, 0) > 0;
}
return true;
}
/* static */ bool
nsLayoutUtils::HasNonZeroCorner(const nsStyleCorners& aCorners)
{
NS_FOR_CSS_HALF_CORNERS(corner) {
if (NonZeroStyleCoord(aCorners.Get(corner)))
return true;
}
return false;
}
// aCorner is a "full corner" value, i.e. NS_CORNER_TOP_LEFT etc
static bool IsCornerAdjacentToSide(uint8_t aCorner, Side aSide)
{
static_assert((int)eSideTop == eCornerTopLeft, "Check for Full Corner");
static_assert((int)eSideRight == eCornerTopRight, "Check for Full Corner");
static_assert((int)eSideBottom == eCornerBottomRight, "Check for Full Corner");
static_assert((int)eSideLeft == eCornerBottomLeft, "Check for Full Corner");
static_assert((int)eSideTop == ((eCornerTopRight - 1)&3), "Check for Full Corner");
static_assert((int)eSideRight == ((eCornerBottomRight - 1)&3), "Check for Full Corner");
static_assert((int)eSideBottom == ((eCornerBottomLeft - 1)&3), "Check for Full Corner");
static_assert((int)eSideLeft == ((eCornerTopLeft - 1)&3), "Check for Full Corner");
return aSide == aCorner || aSide == ((aCorner - 1)&3);
}
/* static */ bool
nsLayoutUtils::HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
Side aSide)
{
static_assert(eCornerTopLeftX/2 == eCornerTopLeft, "Check for Non Zero on side");
static_assert(eCornerTopLeftY/2 == eCornerTopLeft, "Check for Non Zero on side");
static_assert(eCornerTopRightX/2 == eCornerTopRight, "Check for Non Zero on side");
static_assert(eCornerTopRightY/2 == eCornerTopRight, "Check for Non Zero on side");
static_assert(eCornerBottomRightX/2 == eCornerBottomRight, "Check for Non Zero on side");
static_assert(eCornerBottomRightY/2 == eCornerBottomRight, "Check for Non Zero on side");
static_assert(eCornerBottomLeftX/2 == eCornerBottomLeft, "Check for Non Zero on side");
static_assert(eCornerBottomLeftY/2 == eCornerBottomLeft, "Check for Non Zero on side");
NS_FOR_CSS_HALF_CORNERS(corner) {
// corner is a "half corner" value, so dividing by two gives us a
// "full corner" value.
if (NonZeroStyleCoord(aCorners.Get(corner)) &&
IsCornerAdjacentToSide(corner/2, aSide))
return true;
}
return false;
}
/* static */ nsTransparencyMode
nsLayoutUtils::GetFrameTransparency(nsIFrame* aBackgroundFrame,
nsIFrame* aCSSRootFrame) {
if (aCSSRootFrame->StyleEffects()->mOpacity < 1.0f)
return eTransparencyTransparent;
if (HasNonZeroCorner(aCSSRootFrame->StyleBorder()->mBorderRadius))
return eTransparencyTransparent;
if (aCSSRootFrame->StyleDisplay()->mAppearance == NS_THEME_WIN_GLASS)
return eTransparencyGlass;
if (aCSSRootFrame->StyleDisplay()->mAppearance == NS_THEME_WIN_BORDERLESS_GLASS)
return eTransparencyBorderlessGlass;
nsITheme::Transparency transparency;
if (aCSSRootFrame->IsThemed(&transparency))
return transparency == nsITheme::eTransparent
? eTransparencyTransparent
: eTransparencyOpaque;
// We need an uninitialized window to be treated as opaque because
// doing otherwise breaks window display effects on some platforms,
// specifically Vista. (bug 450322)
if (aBackgroundFrame->GetType() == nsGkAtoms::viewportFrame &&
!aBackgroundFrame->PrincipalChildList().FirstChild()) {
return eTransparencyOpaque;
}
nsStyleContext* bgSC;
if (!nsCSSRendering::FindBackground(aBackgroundFrame, &bgSC)) {
return eTransparencyTransparent;
}
const nsStyleBackground* bg = bgSC->StyleBackground();
if (NS_GET_A(bg->BackgroundColor(bgSC)) < 255 ||
// bottom layer's clip is used for the color
bg->BottomLayer().mClip != StyleGeometryBox::Border)
return eTransparencyTransparent;
return eTransparencyOpaque;
}
static bool IsPopupFrame(nsIFrame* aFrame)
{
// aFrame is a popup it's the list control frame dropdown for a combobox.
nsIAtom* frameType = aFrame->GetType();
if (frameType == nsGkAtoms::listControlFrame) {
nsListControlFrame* lcf = static_cast<nsListControlFrame*>(aFrame);
return lcf->IsInDropDownMode();
}
// ... or if it's a XUL menupopup frame.
return frameType == nsGkAtoms::menuPopupFrame;
}
/* static */ bool
nsLayoutUtils::IsPopup(nsIFrame* aFrame)
{
// Optimization: the frame can't possibly be a popup if it has no view.
if (!aFrame->HasView()) {
NS_ASSERTION(!IsPopupFrame(aFrame), "popup frame must have a view");
return false;
}
return IsPopupFrame(aFrame);
}
/* static */ nsIFrame*
nsLayoutUtils::GetDisplayRootFrame(nsIFrame* aFrame)
{
// We could use GetRootPresContext() here if the
// NS_FRAME_IN_POPUP frame bit is set.
nsIFrame* f = aFrame;
for (;;) {
if (!f->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
f = f->PresContext()->FrameManager()->GetRootFrame();
} else if (IsPopup(f)) {
return f;
}
nsIFrame* parent = GetCrossDocParentFrame(f);
if (!parent)
return f;
f = parent;
}
}
/* static */ nsIFrame*
nsLayoutUtils::GetReferenceFrame(nsIFrame* aFrame)
{
nsIFrame *f = aFrame;
for (;;) {
if (f->IsTransformed() || f->IsPreserve3DLeaf() || IsPopup(f)) {
return f;
}
nsIFrame* parent = GetCrossDocParentFrame(f);
if (!parent) {
return f;
}
f = parent;
}
}
/* static */ uint32_t
nsLayoutUtils::GetTextRunFlagsForStyle(nsStyleContext* aStyleContext,
const nsStyleFont* aStyleFont,
const nsStyleText* aStyleText,
nscoord aLetterSpacing)
{
uint32_t result = 0;
if (aLetterSpacing != 0) {
result |= gfxTextRunFactory::TEXT_DISABLE_OPTIONAL_LIGATURES;
}
if (aStyleText->mControlCharacterVisibility == NS_STYLE_CONTROL_CHARACTER_VISIBILITY_HIDDEN) {
result |= gfxTextRunFactory::TEXT_HIDE_CONTROL_CHARACTERS;
}
switch (aStyleContext->StyleText()->mTextRendering) {
case NS_STYLE_TEXT_RENDERING_OPTIMIZESPEED:
result |= gfxTextRunFactory::TEXT_OPTIMIZE_SPEED;
break;
case NS_STYLE_TEXT_RENDERING_AUTO:
if (aStyleFont->mFont.size <
aStyleContext->PresContext()->GetAutoQualityMinFontSize()) {
result |= gfxTextRunFactory::TEXT_OPTIMIZE_SPEED;
}
break;
default:
break;
}
return result | GetTextRunOrientFlagsForStyle(aStyleContext);
}
/* static */ uint32_t
nsLayoutUtils::GetTextRunOrientFlagsForStyle(nsStyleContext* aStyleContext)
{
uint8_t writingMode = aStyleContext->StyleVisibility()->mWritingMode;
switch (writingMode) {
case NS_STYLE_WRITING_MODE_HORIZONTAL_TB:
return gfxTextRunFactory::TEXT_ORIENT_HORIZONTAL;
case NS_STYLE_WRITING_MODE_VERTICAL_LR:
case NS_STYLE_WRITING_MODE_VERTICAL_RL:
switch (aStyleContext->StyleVisibility()->mTextOrientation) {
case NS_STYLE_TEXT_ORIENTATION_MIXED:
return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_MIXED;
case NS_STYLE_TEXT_ORIENTATION_UPRIGHT:
return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_UPRIGHT;
case NS_STYLE_TEXT_ORIENTATION_SIDEWAYS:
return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
default:
NS_NOTREACHED("unknown text-orientation");
return 0;
}
case NS_STYLE_WRITING_MODE_SIDEWAYS_LR:
return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT;
case NS_STYLE_WRITING_MODE_SIDEWAYS_RL:
return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
default:
NS_NOTREACHED("unknown writing-mode");
return 0;
}
}
/* static */ void
nsLayoutUtils::GetRectDifferenceStrips(const nsRect& aR1, const nsRect& aR2,
nsRect* aHStrip, nsRect* aVStrip) {
NS_ASSERTION(aR1.TopLeft() == aR2.TopLeft(),
"expected rects at the same position");
nsRect unionRect(aR1.x, aR1.y, std::max(aR1.width, aR2.width),
std::max(aR1.height, aR2.height));
nscoord VStripStart = std::min(aR1.width, aR2.width);
nscoord HStripStart = std::min(aR1.height, aR2.height);
*aVStrip = unionRect;
aVStrip->x += VStripStart;
aVStrip->width -= VStripStart;
*aHStrip = unionRect;
aHStrip->y += HStripStart;
aHStrip->height -= HStripStart;
}
nsDeviceContext*
nsLayoutUtils::GetDeviceContextForScreenInfo(nsPIDOMWindowOuter* aWindow)
{
if (!aWindow) {
return nullptr;
}
nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
while (docShell) {
// Now make sure our size is up to date. That will mean that the device
// context does the right thing on multi-monitor systems when we return it to
// the caller. It will also make sure that our prescontext has been created,
// if we're supposed to have one.
nsCOMPtr<nsPIDOMWindowOuter> win = docShell->GetWindow();
if (!win) {
// No reason to go on
return nullptr;
}
win->EnsureSizeUpToDate();
RefPtr<nsPresContext> presContext;
docShell->GetPresContext(getter_AddRefs(presContext));
if (presContext) {
nsDeviceContext* context = presContext->DeviceContext();
if (context) {
return context;
}
}
nsCOMPtr<nsIDocShellTreeItem> parentItem;
docShell->GetParent(getter_AddRefs(parentItem));
docShell = do_QueryInterface(parentItem);
}
return nullptr;
}
/* static */ bool
nsLayoutUtils::IsReallyFixedPos(nsIFrame* aFrame)
{
NS_PRECONDITION(aFrame->GetParent(),
"IsReallyFixedPos called on frame not in tree");
NS_PRECONDITION(aFrame->StyleDisplay()->mPosition ==
NS_STYLE_POSITION_FIXED,
"IsReallyFixedPos called on non-'position:fixed' frame");
nsIAtom *parentType = aFrame->GetParent()->GetType();
return parentType == nsGkAtoms::viewportFrame ||
parentType == nsGkAtoms::pageContentFrame;
}
nsLayoutUtils::SurfaceFromElementResult
nsLayoutUtils::SurfaceFromOffscreenCanvas(OffscreenCanvas* aOffscreenCanvas,
uint32_t aSurfaceFlags,
RefPtr<DrawTarget>& aTarget)
{
SurfaceFromElementResult result;
bool* isPremultiplied = nullptr;
if (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) {
isPremultiplied = &result.mIsPremultiplied;
}
nsIntSize size = aOffscreenCanvas->GetWidthHeight();
result.mSourceSurface = aOffscreenCanvas->GetSurfaceSnapshot(isPremultiplied);
if (!result.mSourceSurface) {
// If the element doesn't have a context then we won't get a snapshot. The canvas spec wants us to not error and just
// draw nothing, so return an empty surface.
DrawTarget *ref = aTarget ? aTarget.get() : gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
RefPtr<DrawTarget> dt = ref->CreateSimilarDrawTarget(IntSize(size.width, size.height),
SurfaceFormat::B8G8R8A8);
if (dt) {
result.mSourceSurface = dt->Snapshot();
}
} else if (aTarget) {
RefPtr<SourceSurface> opt = aTarget->OptimizeSourceSurface(result.mSourceSurface);
if (opt) {
result.mSourceSurface = opt;
}
}
result.mHasSize = true;
result.mSize = size;
result.mIsWriteOnly = aOffscreenCanvas->IsWriteOnly();
return result;
}
nsLayoutUtils::SurfaceFromElementResult
nsLayoutUtils::SurfaceFromElement(nsIImageLoadingContent* aElement,
uint32_t aSurfaceFlags,
RefPtr<DrawTarget>& aTarget)
{
SurfaceFromElementResult result;
nsresult rv;
nsCOMPtr<imgIRequest> imgRequest;
rv = aElement->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
getter_AddRefs(imgRequest));
if (NS_FAILED(rv)) {
return result;
}
if (!imgRequest) {
// There's no image request. This is either because a request for
// a non-empty URI failed, or the URI is the empty string.
nsCOMPtr<nsIURI> currentURI;
aElement->GetCurrentURI(getter_AddRefs(currentURI));
if (!currentURI) {
// Treat the empty URI as available instead of broken state.
result.mHasSize = true;
}
return result;
}
uint32_t status;
imgRequest->GetImageStatus(&status);
result.mHasSize = status & imgIRequest::STATUS_SIZE_AVAILABLE;
if ((status & imgIRequest::STATUS_LOAD_COMPLETE) == 0) {
// Spec says to use GetComplete, but that only works on
// nsIDOMHTMLImageElement, and we support all sorts of other stuff
// here. Do this for now pending spec clarification.
result.mIsStillLoading = (status & imgIRequest::STATUS_ERROR) == 0;
return result;
}
nsCOMPtr<nsIPrincipal> principal;
rv = imgRequest->GetImagePrincipal(getter_AddRefs(principal));
if (NS_FAILED(rv)) {
return result;
}
nsCOMPtr<imgIContainer> imgContainer;
rv = imgRequest->GetImage(getter_AddRefs(imgContainer));
if (NS_FAILED(rv)) {
return result;
}
uint32_t noRasterize = aSurfaceFlags & SFE_NO_RASTERIZING_VECTORS;
uint32_t whichFrame = (aSurfaceFlags & SFE_WANT_FIRST_FRAME)
? (uint32_t) imgIContainer::FRAME_FIRST
: (uint32_t) imgIContainer::FRAME_CURRENT;
uint32_t frameFlags = imgIContainer::FLAG_SYNC_DECODE
| imgIContainer::FLAG_ASYNC_NOTIFY;
if (aSurfaceFlags & SFE_NO_COLORSPACE_CONVERSION)
frameFlags |= imgIContainer::FLAG_DECODE_NO_COLORSPACE_CONVERSION;
if (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) {
frameFlags |= imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA;
result.mIsPremultiplied = false;
}
int32_t imgWidth, imgHeight;
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
HTMLImageElement* element = HTMLImageElement::FromContentOrNull(content);
if (aSurfaceFlags & SFE_USE_ELEMENT_SIZE_IF_VECTOR &&
element &&
imgContainer->GetType() == imgIContainer::TYPE_VECTOR) {
imgWidth = element->Width();
imgHeight = element->Height();
} else {
rv = imgContainer->GetWidth(&imgWidth);
nsresult rv2 = imgContainer->GetHeight(&imgHeight);
if (NS_FAILED(rv) || NS_FAILED(rv2))
return result;
}
result.mSize = IntSize(imgWidth, imgHeight);
if (!noRasterize || imgContainer->GetType() == imgIContainer::TYPE_RASTER) {
if (aSurfaceFlags & SFE_WANT_IMAGE_SURFACE) {
frameFlags |= imgIContainer::FLAG_WANT_DATA_SURFACE;
}
result.mSourceSurface = imgContainer->GetFrameAtSize(result.mSize, whichFrame, frameFlags);
if (!result.mSourceSurface) {
return result;
}
// The surface we return is likely to be cached. We don't want to have to
// convert to a surface that's compatible with aTarget each time it's used
// (that would result in terrible performance), so we convert once here
// upfront if aTarget is specified.
if (aTarget) {
RefPtr<SourceSurface> optSurface =
aTarget->OptimizeSourceSurface(result.mSourceSurface);
if (optSurface) {
result.mSourceSurface = optSurface;
}
}
} else {
result.mDrawInfo.mImgContainer = imgContainer;
result.mDrawInfo.mWhichFrame = whichFrame;
result.mDrawInfo.mDrawingFlags = frameFlags;
}
int32_t corsmode;
if (NS_SUCCEEDED(imgRequest->GetCORSMode(&corsmode))) {
result.mCORSUsed = (corsmode != imgIRequest::CORS_NONE);
}
result.mPrincipal = principal.forget();
// no images, including SVG images, can load content from another domain.
result.mIsWriteOnly = false;
result.mImageRequest = imgRequest.forget();
return result;
}
nsLayoutUtils::SurfaceFromElementResult
nsLayoutUtils::SurfaceFromElement(HTMLImageElement *aElement,
uint32_t aSurfaceFlags,
RefPtr<DrawTarget>& aTarget)
{
return SurfaceFromElement(static_cast<nsIImageLoadingContent*>(aElement),
aSurfaceFlags, aTarget);
}
nsLayoutUtils::SurfaceFromElementResult
nsLayoutUtils::SurfaceFromElement(HTMLCanvasElement* aElement,
uint32_t aSurfaceFlags,
RefPtr<DrawTarget>& aTarget)
{
SurfaceFromElementResult result;
bool* isPremultiplied = nullptr;
if (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) {
isPremultiplied = &result.mIsPremultiplied;
}
IntSize size = aElement->GetSize();
result.mSourceSurface = aElement->GetSurfaceSnapshot(isPremultiplied);
if (!result.mSourceSurface) {
// If the element doesn't have a context then we won't get a snapshot. The canvas spec wants us to not error and just
// draw nothing, so return an empty surface.
DrawTarget *ref = aTarget ? aTarget.get() : gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
RefPtr<DrawTarget> dt = ref->CreateSimilarDrawTarget(IntSize(size.width, size.height),
SurfaceFormat::B8G8R8A8);
if (dt) {
result.mSourceSurface = dt->Snapshot();
}
} else if (aTarget) {
RefPtr<SourceSurface> opt = aTarget->OptimizeSourceSurface(result.mSourceSurface);
if (opt) {
result.mSourceSurface = opt;
}
}
// Ensure that any future changes to the canvas trigger proper invalidation,
// in case this is being used by -moz-element()
aElement->MarkContextClean();
result.mHasSize = true;
result.mSize = size;
result.mPrincipal = aElement->NodePrincipal();
result.mIsWriteOnly = aElement->IsWriteOnly();
return result;
}
nsLayoutUtils::SurfaceFromElementResult
nsLayoutUtils::SurfaceFromElement(HTMLVideoElement* aElement,
uint32_t aSurfaceFlags,
RefPtr<DrawTarget>& aTarget)
{
SurfaceFromElementResult result;
NS_WARNING_ASSERTION(
(aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) == 0,
"We can't support non-premultiplied alpha for video!");
if (aElement->ContainsRestrictedContent()) {
return result;
}
uint16_t readyState;
if (NS_SUCCEEDED(aElement->GetReadyState(&readyState)) &&
(readyState == nsIDOMHTMLMediaElement::HAVE_NOTHING ||
readyState == nsIDOMHTMLMediaElement::HAVE_METADATA)) {
result.mIsStillLoading = true;
return result;
}
// If it doesn't have a principal, just bail
nsCOMPtr<nsIPrincipal> principal = aElement->GetCurrentVideoPrincipal();
if (!principal)
return result;
ImageContainer* container = aElement->GetImageContainer();
if (!container)
return result;
AutoLockImage lockImage(container);
result.mLayersImage = lockImage.GetImage();
if (!result.mLayersImage)
return result;
if (aTarget) {
// They gave us a DrawTarget to optimize for, so even though we have a layers::Image,
// we should unconditionally grab a SourceSurface and try to optimize it.
result.mSourceSurface = result.mLayersImage->GetAsSourceSurface();
if (!result.mSourceSurface)
return result;
RefPtr<SourceSurface> opt = aTarget->OptimizeSourceSurface(result.mSourceSurface);
if (opt) {
result.mSourceSurface = opt;
}
}
result.mCORSUsed = aElement->GetCORSMode() != CORS_NONE;
result.mHasSize = true;
result.mSize = result.mLayersImage->GetSize();
result.mPrincipal = principal.forget();
result.mIsWriteOnly = false;
return result;
}
nsLayoutUtils::SurfaceFromElementResult
nsLayoutUtils::SurfaceFromElement(dom::Element* aElement,
uint32_t aSurfaceFlags,
RefPtr<DrawTarget>& aTarget)
{
// If it's a <canvas>, we may be able to just grab its internal surface
if (HTMLCanvasElement* canvas =
HTMLCanvasElement::FromContentOrNull(aElement)) {
return SurfaceFromElement(canvas, aSurfaceFlags, aTarget);
}
// Maybe it's <video>?
if (HTMLVideoElement* video =
HTMLVideoElement::FromContentOrNull(aElement)) {
return SurfaceFromElement(video, aSurfaceFlags, aTarget);
}
// Finally, check if it's a normal image
nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(aElement);
if (!imageLoader) {
return SurfaceFromElementResult();
}
return SurfaceFromElement(imageLoader, aSurfaceFlags, aTarget);
}
/* static */
nsIContent*
nsLayoutUtils::GetEditableRootContentByContentEditable(nsIDocument* aDocument)
{
// If the document is in designMode we should return nullptr.
if (!aDocument || aDocument->HasFlag(NODE_IS_EDITABLE)) {
return nullptr;
}
// contenteditable only works with HTML document.
// Note: Use nsIDOMHTMLDocument rather than nsIHTMLDocument for getting the
// body node because nsIDOMHTMLDocument::GetBody() does something
// additional work for some cases and EditorBase uses them.
nsCOMPtr<nsIDOMHTMLDocument> domHTMLDoc = do_QueryInterface(aDocument);
if (!domHTMLDoc) {
return nullptr;
}
Element* rootElement = aDocument->GetRootElement();
if (rootElement && rootElement->IsEditable()) {
return rootElement;
}
// If there are no editable root element, check its <body> element.
// Note that the body element could be <frameset> element.
nsCOMPtr<nsIDOMHTMLElement> body;
nsresult rv = domHTMLDoc->GetBody(getter_AddRefs(body));
nsCOMPtr<nsIContent> content = do_QueryInterface(body);
if (NS_SUCCEEDED(rv) && content && content->IsEditable()) {
return content;
}
return nullptr;
}
#ifdef DEBUG
/* static */ void
nsLayoutUtils::AssertNoDuplicateContinuations(nsIFrame* aContainer,
const nsFrameList& aFrameList)
{
for (nsIFrame* f : aFrameList) {
// Check only later continuations of f; we deal with checking the
// earlier continuations when we hit those earlier continuations in
// the frame list.
for (nsIFrame *c = f; (c = c->GetNextInFlow());) {
NS_ASSERTION(c->GetParent() != aContainer ||
!aFrameList.ContainsFrame(c),
"Two continuations of the same frame in the same "
"frame list");
}
}
}
// Is one of aFrame's ancestors a letter frame?
static bool
IsInLetterFrame(nsIFrame *aFrame)
{
for (nsIFrame *f = aFrame->GetParent(); f; f = f->GetParent()) {
if (f->GetType() == nsGkAtoms::letterFrame) {
return true;
}
}
return false;
}
/* static */ void
nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(nsIFrame *aSubtreeRoot)
{
NS_ASSERTION(aSubtreeRoot->GetPrevInFlow(),
"frame tree not empty, but caller reported complete status");
// Also assert that text frames map no text.
int32_t start, end;
nsresult rv = aSubtreeRoot->GetOffsets(start, end);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetOffsets failed");
// In some cases involving :first-letter, we'll partially unlink a
// continuation in the middle of a continuation chain from its
// previous and next continuations before destroying it, presumably so
// that we don't also destroy the later continuations. Once we've
// done this, GetOffsets returns incorrect values.
// For examples, see list of tests in
// https://bugzilla.mozilla.org/show_bug.cgi?id=619021#c29
NS_ASSERTION(start == end || IsInLetterFrame(aSubtreeRoot),
"frame tree not empty, but caller reported complete status");
nsIFrame::ChildListIterator lists(aSubtreeRoot);
for (; !lists.IsDone(); lists.Next()) {
nsFrameList::Enumerator childFrames(lists.CurrentList());
for (; !childFrames.AtEnd(); childFrames.Next()) {
nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(childFrames.get());
}
}
}
#endif
static void
GetFontFacesForFramesInner(nsIFrame* aFrame, nsFontFaceList* aFontFaceList)
{
NS_PRECONDITION(aFrame, "NULL frame pointer");
if (aFrame->GetType() == nsGkAtoms::textFrame) {
if (!aFrame->GetPrevContinuation()) {
nsLayoutUtils::GetFontFacesForText(aFrame, 0, INT32_MAX, true,
aFontFaceList);
}
return;
}
nsIFrame::ChildListID childLists[] = { nsIFrame::kPrincipalList,
nsIFrame::kPopupList };
for (size_t i = 0; i < ArrayLength(childLists); ++i) {
nsFrameList children(aFrame->GetChildList(childLists[i]));
for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
nsIFrame* child = e.get();
child = nsPlaceholderFrame::GetRealFrameFor(child);
GetFontFacesForFramesInner(child, aFontFaceList);
}
}
}
/* static */
nsresult
nsLayoutUtils::GetFontFacesForFrames(nsIFrame* aFrame,
nsFontFaceList* aFontFaceList)
{
NS_PRECONDITION(aFrame, "NULL frame pointer");
while (aFrame) {
GetFontFacesForFramesInner(aFrame, aFontFaceList);
aFrame = GetNextContinuationOrIBSplitSibling(aFrame);
}
return NS_OK;
}
/* static */
nsresult
nsLayoutUtils::GetFontFacesForText(nsIFrame* aFrame,
int32_t aStartOffset, int32_t aEndOffset,
bool aFollowContinuations,
nsFontFaceList* aFontFaceList)
{
NS_PRECONDITION(aFrame, "NULL frame pointer");
if (aFrame->GetType() != nsGkAtoms::textFrame) {
return NS_OK;
}
nsTextFrame* curr = static_cast<nsTextFrame*>(aFrame);
do {
int32_t fstart = std::max(curr->GetContentOffset(), aStartOffset);
int32_t fend = std::min(curr->GetContentEnd(), aEndOffset);
if (fstart >= fend) {
curr = static_cast<nsTextFrame*>(curr->GetNextContinuation());
continue;
}
// curr is overlapping with the offset we want
gfxSkipCharsIterator iter = curr->EnsureTextRun(nsTextFrame::eInflated);
gfxTextRun* textRun = curr->GetTextRun(nsTextFrame::eInflated);
NS_ENSURE_TRUE(textRun, NS_ERROR_OUT_OF_MEMORY);
// include continuations in the range that share the same textrun
nsTextFrame* next = nullptr;
if (aFollowContinuations && fend < aEndOffset) {
next = static_cast<nsTextFrame*>(curr->GetNextContinuation());
while (next && next->GetTextRun(nsTextFrame::eInflated) == textRun) {
fend = std::min(next->GetContentEnd(), aEndOffset);
next = fend < aEndOffset ?
static_cast<nsTextFrame*>(next->GetNextContinuation()) : nullptr;
}
}
uint32_t skipStart = iter.ConvertOriginalToSkipped(fstart);
uint32_t skipEnd = iter.ConvertOriginalToSkipped(fend);
aFontFaceList->AddFontsFromTextRun(textRun, skipStart, skipEnd - skipStart);
curr = next;
} while (aFollowContinuations && curr);
return NS_OK;
}
/* static */
size_t
nsLayoutUtils::SizeOfTextRunsForFrames(nsIFrame* aFrame,
MallocSizeOf aMallocSizeOf,
bool clear)
{
NS_PRECONDITION(aFrame, "NULL frame pointer");
size_t total = 0;
if (aFrame->GetType() == nsGkAtoms::textFrame) {
nsTextFrame* textFrame = static_cast<nsTextFrame*>(aFrame);
for (uint32_t i = 0; i < 2; ++i) {
gfxTextRun *run = textFrame->GetTextRun(
(i != 0) ? nsTextFrame::eInflated : nsTextFrame::eNotInflated);
if (run) {
if (clear) {
run->ResetSizeOfAccountingFlags();
} else {
total += run->MaybeSizeOfIncludingThis(aMallocSizeOf);
}
}
}
return total;
}
AutoTArray<nsIFrame::ChildList,4> childListArray;
aFrame->GetChildLists(&childListArray);
for (nsIFrame::ChildListArrayIterator childLists(childListArray);
!childLists.IsDone(); childLists.Next()) {
for (nsFrameList::Enumerator e(childLists.CurrentList());
!e.AtEnd(); e.Next()) {
total += SizeOfTextRunsForFrames(e.get(), aMallocSizeOf, clear);
}
}
return total;
}
struct PrefCallbacks
{
const char* name;
PrefChangedFunc func;
};
static const PrefCallbacks kPrefCallbacks[] = {
{ GRID_ENABLED_PREF_NAME,
GridEnabledPrefChangeCallback },
{ WEBKIT_PREFIXES_ENABLED_PREF_NAME,
WebkitPrefixEnabledPrefChangeCallback },
{ TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME,
TextAlignUnsafeEnabledPrefChangeCallback },
{ DISPLAY_FLOW_ROOT_ENABLED_PREF_NAME,
DisplayFlowRootEnabledPrefChangeCallback },
{ FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME,
FloatLogicalValuesEnabledPrefChangeCallback },
{ BG_CLIP_TEXT_ENABLED_PREF_NAME,
BackgroundClipTextEnabledPrefChangeCallback },
};
/* static */
void
nsLayoutUtils::Initialize()
{
Preferences::AddUintVarCache(&sFontSizeInflationMaxRatio,
"font.size.inflation.maxRatio");
Preferences::AddUintVarCache(&sFontSizeInflationEmPerLine,
"font.size.inflation.emPerLine");
Preferences::AddUintVarCache(&sFontSizeInflationMinTwips,
"font.size.inflation.minTwips");
Preferences::AddUintVarCache(&sFontSizeInflationLineThreshold,
"font.size.inflation.lineThreshold");
Preferences::AddIntVarCache(&sFontSizeInflationMappingIntercept,
"font.size.inflation.mappingIntercept");
Preferences::AddBoolVarCache(&sFontSizeInflationForceEnabled,
"font.size.inflation.forceEnabled");
Preferences::AddBoolVarCache(&sFontSizeInflationDisabledInMasterProcess,
"font.size.inflation.disabledInMasterProcess");
Preferences::AddBoolVarCache(&sInvalidationDebuggingIsEnabled,
"nglayout.debug.invalidation");
Preferences::AddBoolVarCache(&sCSSVariablesEnabled,
"layout.css.variables.enabled");
Preferences::AddBoolVarCache(&sInterruptibleReflowEnabled,
"layout.interruptible-reflow.enabled");
Preferences::AddBoolVarCache(&sSVGTransformBoxEnabled,
"svg.transform-box.enabled");
Preferences::AddBoolVarCache(&sTextCombineUprightDigitsEnabled,
"layout.css.text-combine-upright-digits.enabled");
#ifdef MOZ_STYLO
Preferences::AddBoolVarCache(&sStyloEnabled,
"layout.css.servo.enabled");
#endif
Preferences::AddUintVarCache(&sIdlePeriodDeadlineLimit,
"layout.idle_period.time_limit",
DEFAULT_IDLE_PERIOD_TIME_LIMIT);
Preferences::AddUintVarCache(&sQuiescentFramesBeforeIdlePeriod,
"layout.idle_period.required_quiescent_frames",
DEFAULT_QUIESCENT_FRAMES);
for (auto& callback : kPrefCallbacks) {
Preferences::RegisterCallbackAndCall(callback.func, callback.name);
}
nsComputedDOMStyle::RegisterPrefChangeCallbacks();
}
/* static */
void
nsLayoutUtils::Shutdown()
{
if (sContentMap) {
delete sContentMap;
sContentMap = nullptr;
}
for (auto& callback : kPrefCallbacks) {
Preferences::UnregisterCallback(callback.func, callback.name);
}
nsComputedDOMStyle::UnregisterPrefChangeCallbacks();
// so the cached initial quotes array doesn't appear to be a leak
nsStyleList::Shutdown();
}
/* static */
void
nsLayoutUtils::RegisterImageRequest(nsPresContext* aPresContext,
imgIRequest* aRequest,
bool* aRequestRegistered)
{
if (!aPresContext) {
return;
}
if (aRequestRegistered && *aRequestRegistered) {
// Our request is already registered with the refresh driver, so
// no need to register it again.
return;
}
if (aRequest) {
if (!aPresContext->RefreshDriver()->AddImageRequest(aRequest)) {
NS_WARNING("Unable to add image request");
return;
}
if (aRequestRegistered) {
*aRequestRegistered = true;
}
}
}
/* static */
void
nsLayoutUtils::RegisterImageRequestIfAnimated(nsPresContext* aPresContext,
imgIRequest* aRequest,
bool* aRequestRegistered)
{
if (!aPresContext) {
return;
}
if (aRequestRegistered && *aRequestRegistered) {
// Our request is already registered with the refresh driver, so
// no need to register it again.
return;
}
if (aRequest) {
nsCOMPtr<imgIContainer> image;
if (NS_SUCCEEDED(aRequest->GetImage(getter_AddRefs(image)))) {
// Check to verify that the image is animated. If so, then add it to the
// list of images tracked by the refresh driver.
bool isAnimated = false;
nsresult rv = image->GetAnimated(&isAnimated);
if (NS_SUCCEEDED(rv) && isAnimated) {
if (!aPresContext->RefreshDriver()->AddImageRequest(aRequest)) {
NS_WARNING("Unable to add image request");
return;
}
if (aRequestRegistered) {
*aRequestRegistered = true;
}
}
}
}
}
/* static */
void
nsLayoutUtils::DeregisterImageRequest(nsPresContext* aPresContext,
imgIRequest* aRequest,
bool* aRequestRegistered)
{
if (!aPresContext) {
return;
}
// Deregister our imgIRequest with the refresh driver to
// complete tear-down, but only if it has been registered
if (aRequestRegistered && !*aRequestRegistered) {
return;
}
if (aRequest) {
nsCOMPtr<imgIContainer> image;
if (NS_SUCCEEDED(aRequest->GetImage(getter_AddRefs(image)))) {
aPresContext->RefreshDriver()->RemoveImageRequest(aRequest);
if (aRequestRegistered) {
*aRequestRegistered = false;
}
}
}
}
/* static */
void
nsLayoutUtils::PostRestyleEvent(Element* aElement,
nsRestyleHint aRestyleHint,
nsChangeHint aMinChangeHint)
{
nsIDocument* doc = aElement->GetComposedDoc();
if (doc) {
nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
if (presShell) {
presShell->GetPresContext()->RestyleManager()->PostRestyleEvent(
aElement, aRestyleHint, aMinChangeHint);
}
}
}
nsSetAttrRunnable::nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,
const nsAString& aValue)
: mContent(aContent),
mAttrName(aAttrName),
mValue(aValue)
{
NS_ASSERTION(aContent && aAttrName, "Missing stuff, prepare to crash");
}
nsSetAttrRunnable::nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,
int32_t aValue)
: mContent(aContent),
mAttrName(aAttrName)
{
NS_ASSERTION(aContent && aAttrName, "Missing stuff, prepare to crash");
mValue.AppendInt(aValue);
}
NS_IMETHODIMP
nsSetAttrRunnable::Run()
{
return mContent->SetAttr(kNameSpaceID_None, mAttrName, mValue, true);
}
nsUnsetAttrRunnable::nsUnsetAttrRunnable(nsIContent* aContent,
nsIAtom* aAttrName)
: mContent(aContent),
mAttrName(aAttrName)
{
NS_ASSERTION(aContent && aAttrName, "Missing stuff, prepare to crash");
}
NS_IMETHODIMP
nsUnsetAttrRunnable::Run()
{
return mContent->UnsetAttr(kNameSpaceID_None, mAttrName, true);
}
/**
* Compute the minimum font size inside of a container with the given
* width, such that **when the user zooms the container to fill the full
* width of the device**, the fonts satisfy our minima.
*/
static nscoord
MinimumFontSizeFor(nsPresContext* aPresContext, WritingMode aWritingMode,
nscoord aContainerISize)
{
nsIPresShell* presShell = aPresContext->PresShell();
uint32_t emPerLine = presShell->FontSizeInflationEmPerLine();
uint32_t minTwips = presShell->FontSizeInflationMinTwips();
if (emPerLine == 0 && minTwips == 0) {
return 0;
}
// Clamp the container width to the device dimensions
nscoord iFrameISize = aWritingMode.IsVertical()
? aPresContext->GetVisibleArea().height
: aPresContext->GetVisibleArea().width;
nscoord effectiveContainerISize = std::min(iFrameISize, aContainerISize);
nscoord byLine = 0, byInch = 0;
if (emPerLine != 0) {
byLine = effectiveContainerISize / emPerLine;
}
if (minTwips != 0) {
// REVIEW: Is this giving us app units and sizes *not* counting
// viewport scaling?
gfxSize screenSize = aPresContext->ScreenSizeInchesForFontInflation();
float deviceISizeInches = aWritingMode.IsVertical()
? screenSize.height : screenSize.width;
byInch = NSToCoordRound(effectiveContainerISize /
(deviceISizeInches * 1440 /
minTwips ));
}
return std::max(byLine, byInch);
}
/* static */ float
nsLayoutUtils::FontSizeInflationInner(const nsIFrame *aFrame,
nscoord aMinFontSize)
{
// Note that line heights should be inflated by the same ratio as the
// font size of the same text; thus we operate only on the font size
// even when we're scaling a line height.
nscoord styleFontSize = aFrame->StyleFont()->mFont.size;
if (styleFontSize <= 0) {
// Never scale zero font size.
return 1.0;
}
if (aMinFontSize <= 0) {
// No need to scale.
return 1.0;
}
// If between this current frame and its font inflation container there is a
// non-inline element with fixed width or height, then we should not inflate
// fonts for this frame.
for (const nsIFrame* f = aFrame;
f && !f->IsContainerForFontSizeInflation();
f = f->GetParent()) {
nsIContent* content = f->GetContent();
nsIAtom* fType = f->GetType();
nsIFrame* parent = f->GetParent();
// Also, if there is more than one frame corresponding to a single
// content node, we want the outermost one.
if (!(parent && parent->GetContent() == content) &&
// ignore width/height on inlines since they don't apply
fType != nsGkAtoms::inlineFrame &&
// ignore width on radios and checkboxes since we enlarge them and
// they have width/height in ua.css
fType != nsGkAtoms::formControlFrame) {
// ruby annotations should have the same inflation as its
// grandparent, which is the ruby frame contains the annotation.
if (fType == nsGkAtoms::rubyTextFrame) {
MOZ_ASSERT(parent &&
parent->GetType() == nsGkAtoms::rubyTextContainerFrame);
nsIFrame* grandparent = parent->GetParent();
MOZ_ASSERT(grandparent &&
grandparent->GetType() == nsGkAtoms::rubyFrame);
return FontSizeInflationFor(grandparent);
}
nsStyleCoord stylePosWidth = f->StylePosition()->mWidth;
nsStyleCoord stylePosHeight = f->StylePosition()->mHeight;
if (stylePosWidth.GetUnit() != eStyleUnit_Auto ||
stylePosHeight.GetUnit() != eStyleUnit_Auto) {
return 1.0;
}
}
}
int32_t interceptParam = nsLayoutUtils::FontSizeInflationMappingIntercept();
float maxRatio = (float)nsLayoutUtils::FontSizeInflationMaxRatio() / 100.0f;
float ratio = float(styleFontSize) / float(aMinFontSize);
float inflationRatio;
// Given a minimum inflated font size m, a specified font size s, we want to
// find the inflated font size i and then return the ratio of i to s (i/s).
if (interceptParam >= 0) {
// Since the mapping intercept parameter P is greater than zero, we use it
// to determine the point where our mapping function intersects the i=s
// line. This means that we have an equation of the form:
//
// i = m + s·(P/2)/(1 + P/2), if s <= (1 + P/2)·m
// i = s, if s >= (1 + P/2)·m
float intercept = 1 + float(interceptParam)/2.0f;
if (ratio >= intercept) {
// If we're already at 1+P/2 or more times the minimum, don't scale.
return 1.0;
}
// The point (intercept, intercept) is where the part of the i vs. s graph
// that's not slope 1 meets the i=s line. (This part of the
// graph is a line from (0, m), to that point). We calculate the
// intersection point to be ((1+P/2)m, (1+P/2)m), where P is the
// intercept parameter above. We then need to return i/s.
inflationRatio = (1.0f + (ratio * (intercept - 1) / intercept)) / ratio;
} else {
// This is the case where P is negative. We essentially want to implement
// the case for P=infinity here, so we make i = s + m, which means that
// i/s = s/s + m/s = 1 + 1/ratio
inflationRatio = 1 + 1.0f / ratio;
}
if (maxRatio > 1.0 && inflationRatio > maxRatio) {
return maxRatio;
} else {
return inflationRatio;
}
}
static bool
ShouldInflateFontsForContainer(const nsIFrame *aFrame)
{
// We only want to inflate fonts for text that is in a place
// with room to expand. The question is what the best heuristic for
// that is...
// For now, we're going to use NS_FRAME_IN_CONSTRAINED_BSIZE, which
// indicates whether the frame is inside something with a constrained
// block-size (propagating down the tree), but the propagation stops when
// we hit overflow-y [or -x, for vertical mode]: scroll or auto.
const nsStyleText* styleText = aFrame->StyleText();
return styleText->mTextSizeAdjust != NS_STYLE_TEXT_SIZE_ADJUST_NONE &&
!(aFrame->GetStateBits() & NS_FRAME_IN_CONSTRAINED_BSIZE) &&
// We also want to disable font inflation for containers that have
// preformatted text.
// MathML cells need special treatment. See bug 1002526 comment 56.
(styleText->WhiteSpaceCanWrap(aFrame) ||
aFrame->IsFrameOfType(nsIFrame::eMathML));
}
nscoord
nsLayoutUtils::InflationMinFontSizeFor(const nsIFrame *aFrame)
{
nsPresContext *presContext = aFrame->PresContext();
if (!FontSizeInflationEnabled(presContext) ||
presContext->mInflationDisabledForShrinkWrap) {
return 0;
}
for (const nsIFrame *f = aFrame; f; f = f->GetParent()) {
if (f->IsContainerForFontSizeInflation()) {
if (!ShouldInflateFontsForContainer(f)) {
return 0;
}
nsFontInflationData *data =
nsFontInflationData::FindFontInflationDataFor(aFrame);
// FIXME: The need to null-check here is sort of a bug, and might
// lead to incorrect results.
if (!data || !data->InflationEnabled()) {
return 0;
}
return MinimumFontSizeFor(aFrame->PresContext(),
aFrame->GetWritingMode(),
data->EffectiveISize());
}
}
MOZ_ASSERT(false, "root should always be container");
return 0;
}
float
nsLayoutUtils::FontSizeInflationFor(const nsIFrame *aFrame)
{
if (aFrame->IsSVGText()) {
const nsIFrame* container = aFrame;
while (container->GetType() != nsGkAtoms::svgTextFrame) {
container = container->GetParent();
}
NS_ASSERTION(container, "expected to find an ancestor SVGTextFrame");
return
static_cast<const SVGTextFrame*>(container)->GetFontSizeScaleFactor();
}
if (!FontSizeInflationEnabled(aFrame->PresContext())) {
return 1.0f;
}
return FontSizeInflationInner(aFrame, InflationMinFontSizeFor(aFrame));
}
/* static */ bool
nsLayoutUtils::FontSizeInflationEnabled(nsPresContext *aPresContext)
{
nsIPresShell* presShell = aPresContext->GetPresShell();
if (!presShell) {
return false;
}
return presShell->FontSizeInflationEnabled();
}
/* static */ nsRect
nsLayoutUtils::GetBoxShadowRectForFrame(nsIFrame* aFrame,
const nsSize& aFrameSize)
{
nsCSSShadowArray* boxShadows = aFrame->StyleEffects()->mBoxShadow;
if (!boxShadows) {
return nsRect();
}
bool nativeTheme;
const nsStyleDisplay* styleDisplay = aFrame->StyleDisplay();
nsITheme::Transparency transparency;
if (aFrame->IsThemed(styleDisplay, &transparency)) {
// For opaque (rectangular) theme widgets we can take the generic
// border-box path with border-radius disabled.
nativeTheme = transparency != nsITheme::eOpaque;
} else {
nativeTheme = false;
}
nsRect frameRect = nativeTheme ?
aFrame->GetVisualOverflowRectRelativeToSelf() :
nsRect(nsPoint(0, 0), aFrameSize);
nsRect shadows;
int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
for (uint32_t i = 0; i < boxShadows->Length(); ++i) {
nsRect tmpRect = frameRect;
nsCSSShadowItem* shadow = boxShadows->ShadowAt(i);
// inset shadows are never painted outside the frame
if (shadow->mInset)
continue;
tmpRect.MoveBy(nsPoint(shadow->mXOffset, shadow->mYOffset));
tmpRect.Inflate(shadow->mSpread);
tmpRect.Inflate(
nsContextBoxBlur::GetBlurRadiusMargin(shadow->mRadius, A2D));
shadows.UnionRect(shadows, tmpRect);
}
return shadows;
}
/* static */ bool
nsLayoutUtils::GetContentViewerSize(nsPresContext* aPresContext,
LayoutDeviceIntSize& aOutSize)
{
nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
if (!docShell) {
return false;
}
nsCOMPtr<nsIContentViewer> cv;
docShell->GetContentViewer(getter_AddRefs(cv));
if (!cv) {
return false;
}
nsIntRect bounds;
cv->GetBounds(bounds);
aOutSize = LayoutDeviceIntRect::FromUnknownRect(bounds).Size();
return true;
}
static bool
UpdateCompositionBoundsForRCDRSF(ParentLayerRect& aCompBounds,
nsPresContext* aPresContext,
bool aScaleContentViewerSize)
{
nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame();
if (!rootFrame) {
return false;
}
#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_UIKIT)
nsIWidget* widget = rootFrame->GetNearestWidget();
#else
nsView* view = rootFrame->GetView();
nsIWidget* widget = view ? view->GetWidget() : nullptr;
#endif
if (widget) {
LayoutDeviceIntRect widgetBounds = widget->GetBounds();
widgetBounds.MoveTo(0, 0);
aCompBounds = ParentLayerRect(
ViewAs<ParentLayerPixel>(
widgetBounds,
PixelCastJustification::LayoutDeviceIsParentLayerForRCDRSF));
return true;
}
LayoutDeviceIntSize contentSize;
if (nsLayoutUtils::GetContentViewerSize(aPresContext, contentSize)) {
LayoutDeviceToParentLayerScale scale;
if (aScaleContentViewerSize && aPresContext->GetParentPresContext()) {
scale = LayoutDeviceToParentLayerScale(
aPresContext->GetParentPresContext()->PresShell()->GetCumulativeResolution());
}
aCompBounds.SizeTo(contentSize * scale);
return true;
}
return false;
}
/* static */ nsMargin
nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(nsIFrame* aScrollFrame)
{
if (!aScrollFrame || !aScrollFrame->GetScrollTargetFrame()) {
return nsMargin();
}
nsPresContext* presContext = aScrollFrame->PresContext();
nsIPresShell* presShell = presContext->GetPresShell();
if (!presShell) {
return nsMargin();
}
bool isRootScrollFrame = aScrollFrame == presShell->GetRootScrollFrame();
bool isRootContentDocRootScrollFrame = isRootScrollFrame
&& presContext->IsRootContentDocument();
if (!isRootContentDocRootScrollFrame) {
return nsMargin();
}
if (LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars)) {
return nsMargin();
}
nsIScrollableFrame* scrollableFrame = aScrollFrame->GetScrollTargetFrame();
if (!scrollableFrame) {
return nsMargin();
}
return scrollableFrame->GetActualScrollbarSizes();
}
/* static */ nsSize
nsLayoutUtils::CalculateCompositionSizeForFrame(nsIFrame* aFrame, bool aSubtractScrollbars)
{
// If we have a scrollable frame, restrict the composition bounds to its
// scroll port. The scroll port excludes the frame borders and the scroll
// bars, which we don't want to be part of the composition bounds.
nsIScrollableFrame* scrollableFrame = aFrame->GetScrollTargetFrame();
nsRect rect = scrollableFrame ? scrollableFrame->GetScrollPortRect() : aFrame->GetRect();
nsSize size = rect.Size();
nsPresContext* presContext = aFrame->PresContext();
nsIPresShell* presShell = presContext->PresShell();
bool isRootContentDocRootScrollFrame = presContext->IsRootContentDocument()
&& aFrame == presShell->GetRootScrollFrame();
if (isRootContentDocRootScrollFrame) {
ParentLayerRect compBounds;
if (UpdateCompositionBoundsForRCDRSF(compBounds, presContext, false)) {
int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
size = nsSize(compBounds.width * auPerDevPixel, compBounds.height * auPerDevPixel);
}
}
if (aSubtractScrollbars) {
nsMargin margins = ScrollbarAreaToExcludeFromCompositionBoundsFor(aFrame);
size.width -= margins.LeftRight();
size.height -= margins.TopBottom();
}
return size;
}
/* static */ CSSSize
nsLayoutUtils::CalculateRootCompositionSize(nsIFrame* aFrame,
bool aIsRootContentDocRootScrollFrame,
const FrameMetrics& aMetrics)
{
if (aIsRootContentDocRootScrollFrame) {
return ViewAs<LayerPixel>(aMetrics.GetCompositionBounds().Size(),
PixelCastJustification::ParentLayerToLayerForRootComposition)
* LayerToScreenScale(1.0f)
/ aMetrics.DisplayportPixelsPerCSSPixel();
}
nsPresContext* presContext = aFrame->PresContext();
ScreenSize rootCompositionSize;
nsPresContext* rootPresContext =
presContext->GetToplevelContentDocumentPresContext();
if (!rootPresContext) {
rootPresContext = presContext->GetRootPresContext();
}
nsIPresShell* rootPresShell = nullptr;
if (rootPresContext) {
rootPresShell = rootPresContext->PresShell();
if (nsIFrame* rootFrame = rootPresShell->GetRootFrame()) {
LayoutDeviceToLayerScale2D cumulativeResolution(
rootPresShell->GetCumulativeResolution()
* nsLayoutUtils::GetTransformToAncestorScale(rootFrame));
ParentLayerRect compBounds;
if (UpdateCompositionBoundsForRCDRSF(compBounds, rootPresContext, true)) {
rootCompositionSize = ViewAs<ScreenPixel>(compBounds.Size(),
PixelCastJustification::ScreenIsParentLayerForRoot);
} else {
int32_t rootAUPerDevPixel = rootPresContext->AppUnitsPerDevPixel();
LayerSize frameSize =
(LayoutDeviceRect::FromAppUnits(rootFrame->GetRect(), rootAUPerDevPixel)
* cumulativeResolution).Size();
rootCompositionSize = frameSize * LayerToScreenScale(1.0f);
}
}
} else {
nsIWidget* widget = aFrame->GetNearestWidget();
LayoutDeviceIntRect widgetBounds = widget->GetBounds();
rootCompositionSize = ScreenSize(
ViewAs<ScreenPixel>(widgetBounds.Size(),
PixelCastJustification::LayoutDeviceIsScreenForBounds));
}
// Adjust composition size for the size of scroll bars.
nsIFrame* rootRootScrollFrame = rootPresShell ? rootPresShell->GetRootScrollFrame() : nullptr;
nsMargin scrollbarMargins = ScrollbarAreaToExcludeFromCompositionBoundsFor(rootRootScrollFrame);
LayoutDeviceMargin margins = LayoutDeviceMargin::FromAppUnits(scrollbarMargins,
rootPresContext->AppUnitsPerDevPixel());
// Scrollbars are not subject to resolution scaling, so LD pixels = layer pixels for them.
rootCompositionSize.width -= margins.LeftRight();
rootCompositionSize.height -= margins.TopBottom();
return rootCompositionSize / aMetrics.DisplayportPixelsPerCSSPixel();
}
/* static */ nsRect
nsLayoutUtils::CalculateScrollableRectForFrame(nsIScrollableFrame* aScrollableFrame, nsIFrame* aRootFrame)
{
nsRect contentBounds;
if (aScrollableFrame) {
contentBounds = aScrollableFrame->GetScrollRange();
nsPoint scrollPosition = aScrollableFrame->GetScrollPosition();
if (aScrollableFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_HIDDEN) {
contentBounds.y = scrollPosition.y;
contentBounds.height = 0;
}
if (aScrollableFrame->GetScrollbarStyles().mHorizontal == NS_STYLE_OVERFLOW_HIDDEN) {
contentBounds.x = scrollPosition.x;
contentBounds.width = 0;
}
contentBounds.width += aScrollableFrame->GetScrollPortRect().width;
contentBounds.height += aScrollableFrame->GetScrollPortRect().height;
} else {
contentBounds = aRootFrame->GetRect();
}
return contentBounds;
}
/* static */ nsRect
nsLayoutUtils::CalculateExpandedScrollableRect(nsIFrame* aFrame)
{
nsRect scrollableRect =
CalculateScrollableRectForFrame(aFrame->GetScrollTargetFrame(),
aFrame->PresContext()->PresShell()->GetRootFrame());
nsSize compSize = CalculateCompositionSizeForFrame(aFrame);
if (aFrame == aFrame->PresContext()->PresShell()->GetRootScrollFrame()) {
// the composition size for the root scroll frame does not include the
// local resolution, so we adjust.
float res = aFrame->PresContext()->PresShell()->GetResolution();
compSize.width = NSToCoordRound(compSize.width / res);
compSize.height = NSToCoordRound(compSize.height / res);
}
if (scrollableRect.width < compSize.width) {
scrollableRect.x = std::max(0,
scrollableRect.x - (compSize.width - scrollableRect.width));
scrollableRect.width = compSize.width;
}
if (scrollableRect.height < compSize.height) {
scrollableRect.y = std::max(0,
scrollableRect.y - (compSize.height - scrollableRect.height));
scrollableRect.height = compSize.height;
}
return scrollableRect;
}
/* static */ void
nsLayoutUtils::DoLogTestDataForPaint(LayerManager* aManager,
ViewID aScrollId,
const std::string& aKey,
const std::string& aValue)
{
if (ClientLayerManager* mgr = aManager->AsClientLayerManager()) {
mgr->LogTestDataForCurrentPaint(aScrollId, aKey, aValue);
}
}
/* static */ bool
nsLayoutUtils::IsAPZTestLoggingEnabled()
{
return gfxPrefs::APZTestLoggingEnabled();
}
////////////////////////////////////////
// SurfaceFromElementResult
nsLayoutUtils::SurfaceFromElementResult::SurfaceFromElementResult()
// Use safe default values here
: mIsWriteOnly(true)
, mIsStillLoading(false)
, mHasSize(false)
, mCORSUsed(false)
, mIsPremultiplied(true)
{
}
const RefPtr<mozilla::gfx::SourceSurface>&
nsLayoutUtils::SurfaceFromElementResult::GetSourceSurface()
{
if (!mSourceSurface && mLayersImage) {
mSourceSurface = mLayersImage->GetAsSourceSurface();
}
return mSourceSurface;
}
////////////////////////////////////////
bool
nsLayoutUtils::IsNonWrapperBlock(nsIFrame* aFrame)
{
return GetAsBlock(aFrame) && !aFrame->IsBlockWrapper();
}
bool
nsLayoutUtils::NeedsPrintPreviewBackground(nsPresContext* aPresContext)
{
return aPresContext->IsRootPaginatedDocument() &&
(aPresContext->Type() == nsPresContext::eContext_PrintPreview ||
aPresContext->Type() == nsPresContext::eContext_PageLayout);
}
AutoMaybeDisableFontInflation::AutoMaybeDisableFontInflation(nsIFrame *aFrame)
{
// FIXME: Now that inflation calculations are based on the flow
// root's NCA's (nearest common ancestor of its inflatable
// descendants) width, we could probably disable inflation in
// fewer cases than we currently do.
// MathML cells need special treatment. See bug 1002526 comment 56.
if (aFrame->IsContainerForFontSizeInflation() &&
!aFrame->IsFrameOfType(nsIFrame::eMathML)) {
mPresContext = aFrame->PresContext();
mOldValue = mPresContext->mInflationDisabledForShrinkWrap;
mPresContext->mInflationDisabledForShrinkWrap = true;
} else {
// indicate we have nothing to restore
mPresContext = nullptr;
}
}
AutoMaybeDisableFontInflation::~AutoMaybeDisableFontInflation()
{
if (mPresContext) {
mPresContext->mInflationDisabledForShrinkWrap = mOldValue;
}
}
namespace mozilla {
Rect NSRectToRect(const nsRect& aRect, double aAppUnitsPerPixel)
{
// Note that by making aAppUnitsPerPixel a double we're doing floating-point
// division using a larger type and avoiding rounding error.
return Rect(Float(aRect.x / aAppUnitsPerPixel),
Float(aRect.y / aAppUnitsPerPixel),
Float(aRect.width / aAppUnitsPerPixel),
Float(aRect.height / aAppUnitsPerPixel));
}
Rect NSRectToSnappedRect(const nsRect& aRect, double aAppUnitsPerPixel,
const gfx::DrawTarget& aSnapDT)
{
// Note that by making aAppUnitsPerPixel a double we're doing floating-point
// division using a larger type and avoiding rounding error.
Rect rect(Float(aRect.x / aAppUnitsPerPixel),
Float(aRect.y / aAppUnitsPerPixel),
Float(aRect.width / aAppUnitsPerPixel),
Float(aRect.height / aAppUnitsPerPixel));
MaybeSnapToDevicePixels(rect, aSnapDT, true);
return rect;
}
// Similar to a snapped rect, except an axis is left unsnapped if the snapping
// process results in a length of 0.
Rect NSRectToNonEmptySnappedRect(const nsRect& aRect, double aAppUnitsPerPixel,
const gfx::DrawTarget& aSnapDT)
{
// Note that by making aAppUnitsPerPixel a double we're doing floating-point
// division using a larger type and avoiding rounding error.
Rect rect(Float(aRect.x / aAppUnitsPerPixel),
Float(aRect.y / aAppUnitsPerPixel),
Float(aRect.width / aAppUnitsPerPixel),
Float(aRect.height / aAppUnitsPerPixel));
MaybeSnapToDevicePixels(rect, aSnapDT, true, false);
return rect;
}
void StrokeLineWithSnapping(const nsPoint& aP1, const nsPoint& aP2,
int32_t aAppUnitsPerDevPixel,
DrawTarget& aDrawTarget,
const Pattern& aPattern,
const StrokeOptions& aStrokeOptions,
const DrawOptions& aDrawOptions)
{
Point p1 = NSPointToPoint(aP1, aAppUnitsPerDevPixel);
Point p2 = NSPointToPoint(aP2, aAppUnitsPerDevPixel);
SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget,
aStrokeOptions.mLineWidth);
aDrawTarget.StrokeLine(p1, p2, aPattern, aStrokeOptions, aDrawOptions);
}
namespace layout {
void
MaybeSetupTransactionIdAllocator(layers::LayerManager* aManager, nsView* aView)
{
if (aManager->GetBackendType() == layers::LayersBackend::LAYERS_CLIENT) {
layers::ClientLayerManager *manager = static_cast<layers::ClientLayerManager*>(aManager);
nsRefreshDriver *refresh = aView->GetViewManager()->GetPresShell()->GetPresContext()->RefreshDriver();
manager->SetTransactionIdAllocator(refresh);
}
}
} // namespace layout
} // namespace mozilla
/* static */ bool
nsLayoutUtils::IsOutlineStyleAutoEnabled()
{
static bool sOutlineStyleAutoEnabled;
static bool sOutlineStyleAutoPrefCached = false;
if (!sOutlineStyleAutoPrefCached) {
sOutlineStyleAutoPrefCached = true;
Preferences::AddBoolVarCache(&sOutlineStyleAutoEnabled,
"layout.css.outline-style-auto.enabled",
false);
}
return sOutlineStyleAutoEnabled;
}
/* static */ void
nsLayoutUtils::SetBSizeFromFontMetrics(const nsIFrame* aFrame,
ReflowOutput& aMetrics,
const LogicalMargin& aFramePadding,
WritingMode aLineWM,
WritingMode aFrameWM)
{
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
if (fm) {
// Compute final height of the frame.
//
// Do things the standard css2 way -- though it's hard to find it
// in the css2 spec! It's actually found in the css1 spec section
// 4.4 (you will have to read between the lines to really see
// it).
//
// The height of our box is the sum of our font size plus the top
// and bottom border and padding. The height of children do not
// affect our height.
aMetrics.SetBlockStartAscent(aLineWM.IsLineInverted() ? fm->MaxDescent()
: fm->MaxAscent());
aMetrics.BSize(aLineWM) = fm->MaxHeight();
} else {
NS_WARNING("Cannot get font metrics - defaulting sizes to 0");
aMetrics.SetBlockStartAscent(aMetrics.BSize(aLineWM) = 0);
}
aMetrics.SetBlockStartAscent(aMetrics.BlockStartAscent() +
aFramePadding.BStart(aFrameWM));
aMetrics.BSize(aLineWM) += aFramePadding.BStartEnd(aFrameWM);
}
/* static */ bool
nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(nsIPresShell* aShell)
{
if (nsIDocument* doc = aShell->GetDocument()) {
WidgetEvent event(true, eVoidEvent);
nsTArray<EventTarget*> targets;
nsresult rv = EventDispatcher::Dispatch(doc, nullptr, &event, nullptr,
nullptr, nullptr, &targets);
NS_ENSURE_SUCCESS(rv, false);
for (size_t i = 0; i < targets.Length(); i++) {
if (targets[i]->IsApzAware()) {
return true;
}
}
}
return false;
}
static void
MaybeReflowForInflationScreenSizeChange(nsPresContext *aPresContext)
{
if (aPresContext) {
nsIPresShell* presShell = aPresContext->GetPresShell();
bool fontInflationWasEnabled = presShell->FontSizeInflationEnabled();
presShell->NotifyFontSizeInflationEnabledIsDirty();
bool changed = false;
if (presShell && presShell->FontSizeInflationEnabled() &&
presShell->FontSizeInflationMinTwips() != 0) {
aPresContext->ScreenSizeInchesForFontInflation(&changed);
}
changed = changed ||
(fontInflationWasEnabled != presShell->FontSizeInflationEnabled());
if (changed) {
nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
if (docShell) {
nsCOMPtr<nsIContentViewer> cv;
docShell->GetContentViewer(getter_AddRefs(cv));
if (cv) {
nsTArray<nsCOMPtr<nsIContentViewer> > array;
cv->AppendSubtree(array);
for (uint32_t i = 0, iEnd = array.Length(); i < iEnd; ++i) {
nsCOMPtr<nsIPresShell> shell;
nsCOMPtr<nsIContentViewer> cv = array[i];
cv->GetPresShell(getter_AddRefs(shell));
if (shell) {
nsIFrame *rootFrame = shell->GetRootFrame();
if (rootFrame) {
shell->FrameNeedsReflow(rootFrame,
nsIPresShell::eStyleChange,
NS_FRAME_IS_DIRTY);
}
}
}
}
}
}
}
}
/* static */ void
nsLayoutUtils::SetScrollPositionClampingScrollPortSize(nsIPresShell* aPresShell, CSSSize aSize)
{
MOZ_ASSERT(aSize.width >= 0.0 && aSize.height >= 0.0);
aPresShell->SetScrollPositionClampingScrollPortSize(
nsPresContext::CSSPixelsToAppUnits(aSize.width),
nsPresContext::CSSPixelsToAppUnits(aSize.height));
// When the "font.size.inflation.minTwips" preference is set, the
// layout depends on the size of the screen. Since when the size
// of the screen changes, the scroll position clamping scroll port
// size also changes, we hook in the needed updates here rather
// than adding a separate notification just for this change.
nsPresContext* presContext = aPresShell->GetPresContext();
MaybeReflowForInflationScreenSizeChange(presContext);
}
/* static */ bool
nsLayoutUtils::CanScrollOriginClobberApz(nsIAtom* aScrollOrigin)
{
return aScrollOrigin != nullptr
&& aScrollOrigin != nsGkAtoms::apz
&& aScrollOrigin != nsGkAtoms::restore;
}
/* static */ ScrollMetadata
nsLayoutUtils::ComputeScrollMetadata(nsIFrame* aForFrame,
nsIFrame* aScrollFrame,
nsIContent* aContent,
const nsIFrame* aReferenceFrame,
Layer* aLayer,
ViewID aScrollParentId,
const nsRect& aViewport,
const Maybe<nsRect>& aClipRect,
bool aIsRootContent,
const ContainerLayerParameters& aContainerParameters)
{
nsPresContext* presContext = aForFrame->PresContext();
int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
nsIPresShell* presShell = presContext->GetPresShell();
ScrollMetadata metadata;
FrameMetrics& metrics = metadata.GetMetrics();
metrics.SetViewport(CSSRect::FromAppUnits(aViewport));
ViewID scrollId = FrameMetrics::NULL_SCROLL_ID;
if (aContent) {
if (void* paintRequestTime = aContent->GetProperty(nsGkAtoms::paintRequestTime)) {
metrics.SetPaintRequestTime(*static_cast<TimeStamp*>(paintRequestTime));
aContent->DeleteProperty(nsGkAtoms::paintRequestTime);
}
scrollId = nsLayoutUtils::FindOrCreateIDFor(aContent);
nsRect dp;
if (nsLayoutUtils::GetDisplayPort(aContent, &dp)) {
metrics.SetDisplayPort(CSSRect::FromAppUnits(dp));
nsLayoutUtils::LogTestDataForPaint(aLayer->Manager(), scrollId, "displayport",
metrics.GetDisplayPort());
}
if (nsLayoutUtils::GetCriticalDisplayPort(aContent, &dp)) {
metrics.SetCriticalDisplayPort(CSSRect::FromAppUnits(dp));
nsLayoutUtils::LogTestDataForPaint(aLayer->Manager(), scrollId,
"criticalDisplayport", metrics.GetCriticalDisplayPort());
}
DisplayPortMarginsPropertyData* marginsData =
static_cast<DisplayPortMarginsPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
if (marginsData) {
metrics.SetDisplayPortMargins(marginsData->mMargins);
}
}
nsIScrollableFrame* scrollableFrame = nullptr;
if (aScrollFrame)
scrollableFrame = aScrollFrame->GetScrollTargetFrame();
metrics.SetScrollableRect(CSSRect::FromAppUnits(
nsLayoutUtils::CalculateScrollableRectForFrame(scrollableFrame, aForFrame)));
if (scrollableFrame) {
nsPoint scrollPosition = scrollableFrame->GetScrollPosition();
metrics.SetScrollOffset(CSSPoint::FromAppUnits(scrollPosition));
nsPoint smoothScrollPosition = scrollableFrame->LastScrollDestination();
metrics.SetSmoothScrollOffset(CSSPoint::FromAppUnits(smoothScrollPosition));
// If the frame was scrolled since the last layers update, and by something
// that is higher priority than APZ, we want to tell the APZ to update
// its scroll offset. We want to distinguish the case where the scroll offset
// was "restored" because in that case the restored scroll position should
// not overwrite a user-driven scroll.
if (scrollableFrame->LastScrollOrigin() == nsGkAtoms::restore) {
metrics.SetScrollOffsetRestored(scrollableFrame->CurrentScrollGeneration());
} else if (CanScrollOriginClobberApz(scrollableFrame->LastScrollOrigin())) {
metrics.SetScrollOffsetUpdated(scrollableFrame->CurrentScrollGeneration());
}
scrollableFrame->AllowScrollOriginDowngrade();
nsIAtom* lastSmoothScrollOrigin = scrollableFrame->LastSmoothScrollOrigin();
if (lastSmoothScrollOrigin) {
metrics.SetSmoothScrollOffsetUpdated(scrollableFrame->CurrentScrollGeneration());
}
nsSize lineScrollAmount = scrollableFrame->GetLineScrollAmount();
LayoutDeviceIntSize lineScrollAmountInDevPixels =
LayoutDeviceIntSize::FromAppUnitsRounded(lineScrollAmount, presContext->AppUnitsPerDevPixel());
metadata.SetLineScrollAmount(lineScrollAmountInDevPixels);
nsSize pageScrollAmount = scrollableFrame->GetPageScrollAmount();
LayoutDeviceIntSize pageScrollAmountInDevPixels =
LayoutDeviceIntSize::FromAppUnitsRounded(pageScrollAmount, presContext->AppUnitsPerDevPixel());
metadata.SetPageScrollAmount(pageScrollAmountInDevPixels);
if (!aScrollFrame->GetParent() ||
EventStateManager::CanVerticallyScrollFrameWithWheel(aScrollFrame->GetParent()))
{
metadata.SetAllowVerticalScrollWithWheel(true);
}
metadata.SetUsesContainerScrolling(scrollableFrame->UsesContainerScrolling());
metadata.SetSnapInfo(scrollableFrame->GetScrollSnapInfo());
}
// If we have the scrollparent being the same as the scroll id, the
// compositor-side code could get into an infinite loop while building the
// overscroll handoff chain.
MOZ_ASSERT(aScrollParentId == FrameMetrics::NULL_SCROLL_ID || scrollId != aScrollParentId);
metrics.SetScrollId(scrollId);
metrics.SetIsRootContent(aIsRootContent);
metadata.SetScrollParentId(aScrollParentId);
if (scrollId != FrameMetrics::NULL_SCROLL_ID && !presContext->GetParentPresContext()) {
if ((aScrollFrame && (aScrollFrame == presShell->GetRootScrollFrame())) ||
aContent == presShell->GetDocument()->GetDocumentElement()) {
metadata.SetIsLayersIdRoot(true);
}
}
// Only the root scrollable frame for a given presShell should pick up
// the presShell's resolution. All the other frames are 1.0.
if (aScrollFrame == presShell->GetRootScrollFrame()) {
metrics.SetPresShellResolution(presShell->GetResolution());
} else {
metrics.SetPresShellResolution(1.0f);
}
// The cumulative resolution is the resolution at which the scroll frame's
// content is actually rendered. It includes the pres shell resolutions of
// all the pres shells from here up to the root, as well as any css-driven
// resolution. We don't need to compute it as it's already stored in the
// container parameters.
metrics.SetCumulativeResolution(aContainerParameters.Scale());
LayoutDeviceToScreenScale2D resolutionToScreen(
presShell->GetCumulativeResolution()
* nsLayoutUtils::GetTransformToAncestorScale(aScrollFrame ? aScrollFrame : aForFrame));
metrics.SetExtraResolution(metrics.GetCumulativeResolution() / resolutionToScreen);
metrics.SetDevPixelsPerCSSPixel(presContext->CSSToDevPixelScale());
// Initially, AsyncPanZoomController should render the content to the screen
// at the painted resolution.
const LayerToParentLayerScale layerToParentLayerScale(1.0f);
metrics.SetZoom(metrics.GetCumulativeResolution() * metrics.GetDevPixelsPerCSSPixel()
* layerToParentLayerScale);
// Calculate the composition bounds as the size of the scroll frame and
// its origin relative to the reference frame.
// If aScrollFrame is null, we are in a document without a root scroll frame,
// so it's a xul document. In this case, use the size of the viewport frame.
nsIFrame* frameForCompositionBoundsCalculation = aScrollFrame ? aScrollFrame : aForFrame;
nsRect compositionBounds(frameForCompositionBoundsCalculation->GetOffsetToCrossDoc(aReferenceFrame),
frameForCompositionBoundsCalculation->GetSize());
if (scrollableFrame) {
// If we have a scrollable frame, restrict the composition bounds to its
// scroll port. The scroll port excludes the frame borders and the scroll
// bars, which we don't want to be part of the composition bounds.
nsRect scrollPort = scrollableFrame->GetScrollPortRect();
compositionBounds = nsRect(compositionBounds.TopLeft() + scrollPort.TopLeft(),
scrollPort.Size());
}
ParentLayerRect frameBounds = LayoutDeviceRect::FromAppUnits(compositionBounds, auPerDevPixel)
* metrics.GetCumulativeResolution()
* layerToParentLayerScale;
if (aClipRect) {
ParentLayerRect rect = LayoutDeviceRect::FromAppUnits(*aClipRect, auPerDevPixel)
* metrics.GetCumulativeResolution()
* layerToParentLayerScale;
metadata.SetScrollClip(Some(LayerClip(RoundedToInt(rect))));
}
// For the root scroll frame of the root content document (RCD-RSF), the above calculation
// will yield the size of the viewport frame as the composition bounds, which
// doesn't actually correspond to what is visible when
// nsIDOMWindowUtils::setCSSViewport has been called to modify the visible area of
// the prescontext that the viewport frame is reflowed into. In that case if our
// document has a widget then the widget's bounds will correspond to what is
// visible. If we don't have a widget the root view's bounds correspond to what
// would be visible because they don't get modified by setCSSViewport.
bool isRootScrollFrame = aScrollFrame == presShell->GetRootScrollFrame();
bool isRootContentDocRootScrollFrame = isRootScrollFrame
&& presContext->IsRootContentDocument();
if (isRootContentDocRootScrollFrame) {
UpdateCompositionBoundsForRCDRSF(frameBounds, presContext, true);
}
nsMargin sizes = ScrollbarAreaToExcludeFromCompositionBoundsFor(aScrollFrame);
// Scrollbars are not subject to resolution scaling, so LD pixels = layer pixels for them.
ParentLayerMargin boundMargins = LayoutDeviceMargin::FromAppUnits(sizes, auPerDevPixel)
* LayoutDeviceToParentLayerScale(1.0f);
frameBounds.Deflate(boundMargins);
metrics.SetCompositionBounds(frameBounds);
metrics.SetRootCompositionSize(
nsLayoutUtils::CalculateRootCompositionSize(aScrollFrame ? aScrollFrame : aForFrame,
isRootContentDocRootScrollFrame, metrics));
if (gfxPrefs::APZPrintTree() || gfxPrefs::APZTestLoggingEnabled()) {
if (nsIContent* content = frameForCompositionBoundsCalculation->GetContent()) {
nsAutoString contentDescription;
content->Describe(contentDescription);
metadata.SetContentDescription(NS_LossyConvertUTF16toASCII(contentDescription));
nsLayoutUtils::LogTestDataForPaint(aLayer->Manager(), scrollId, "contentDescription",
metadata.GetContentDescription().get());
}
}
metrics.SetPresShellId(presShell->GetPresShellId());
// If the scroll frame's content is marked 'scrollgrab', record this
// in the FrameMetrics so APZ knows to provide the scroll grabbing
// behaviour.
if (aScrollFrame && nsContentUtils::HasScrollgrab(aScrollFrame->GetContent())) {
metadata.SetHasScrollgrab(true);
}
// Also compute and set the background color.
// This is needed for APZ overscrolling support.
if (aScrollFrame) {
if (isRootScrollFrame) {
metadata.SetBackgroundColor(Color::FromABGR(
presShell->GetCanvasBackground()));
} else {
nsStyleContext* backgroundStyle;
if (nsCSSRendering::FindBackground(aScrollFrame, &backgroundStyle)) {
nscolor backgroundColor = backgroundStyle->
StyleBackground()->BackgroundColor(backgroundStyle);
metadata.SetBackgroundColor(Color::FromABGR(backgroundColor));
}
}
}
if (ShouldDisableApzForElement(aContent)) {
metadata.SetForceDisableApz(true);
}
return metadata;
}
/* static */ bool
nsLayoutUtils::ContainsMetricsWithId(const Layer* aLayer, const ViewID& aScrollId)
{
for (uint32_t i = aLayer->GetScrollMetadataCount(); i > 0; i--) {
if (aLayer->GetFrameMetrics(i-1).GetScrollId() == aScrollId) {
return true;
}
}
for (Layer* child = aLayer->GetFirstChild(); child; child = child->GetNextSibling()) {
if (ContainsMetricsWithId(child, aScrollId)) {
return true;
}
}
return false;
}
/* static */ uint32_t
nsLayoutUtils::GetTouchActionFromFrame(nsIFrame* aFrame)
{
// If aFrame is null then return default value
if (!aFrame) {
return NS_STYLE_TOUCH_ACTION_AUTO;
}
// The touch-action CSS property applies to: all elements except:
// non-replaced inline elements, table rows, row groups, table columns, and column groups
bool isNonReplacedInlineElement = aFrame->IsFrameOfType(nsIFrame::eLineParticipant);
if (isNonReplacedInlineElement) {
return NS_STYLE_TOUCH_ACTION_AUTO;
}
const nsStyleDisplay* disp = aFrame->StyleDisplay();
bool isTableElement = disp->IsInnerTableStyle() &&
disp->mDisplay != StyleDisplay::TableCell &&
disp->mDisplay != StyleDisplay::TableCaption;
if (isTableElement) {
return NS_STYLE_TOUCH_ACTION_AUTO;
}
return disp->mTouchAction;
}
/* static */ void
nsLayoutUtils::TransformToAncestorAndCombineRegions(
const nsRegion& aRegion,
nsIFrame* aFrame,
const nsIFrame* aAncestorFrame,
nsRegion* aPreciseTargetDest,
nsRegion* aImpreciseTargetDest,
Maybe<Matrix4x4>* aMatrixCache)
{
if (aRegion.IsEmpty()) {
return;
}
bool isPrecise;
RegionBuilder<nsRegion> transformedRegion;
for (nsRegion::RectIterator it = aRegion.RectIter(); !it.Done(); it.Next()) {
nsRect transformed = TransformFrameRectToAncestor(
aFrame, it.Get(), aAncestorFrame, &isPrecise, aMatrixCache);
transformedRegion.OrWith(transformed);
}
nsRegion* dest = isPrecise ? aPreciseTargetDest : aImpreciseTargetDest;
dest->OrWith(transformedRegion.ToRegion());
}
/* static */ bool
nsLayoutUtils::ShouldUseNoScriptSheet(nsIDocument* aDocument)
{
// also handle the case where print is done from print preview
// see bug #342439 for more details
if (aDocument->IsStaticDocument()) {
aDocument = aDocument->GetOriginalDocument();
}
return aDocument->IsScriptEnabled();
}
/* static */ bool
nsLayoutUtils::ShouldUseNoFramesSheet(nsIDocument* aDocument)
{
bool allowSubframes = true;
nsIDocShell* docShell = aDocument->GetDocShell();
if (docShell) {
docShell->GetAllowSubframes(&allowSubframes);
}
return !allowSubframes;
}
/* static */ void
nsLayoutUtils::GetFrameTextContent(nsIFrame* aFrame, nsAString& aResult)
{
aResult.Truncate();
AppendFrameTextContent(aFrame, aResult);
}
/* static */ void
nsLayoutUtils::AppendFrameTextContent(nsIFrame* aFrame, nsAString& aResult)
{
if (aFrame->GetType() == nsGkAtoms::textFrame) {
auto textFrame = static_cast<nsTextFrame*>(aFrame);
auto offset = textFrame->GetContentOffset();
auto length = textFrame->GetContentLength();
textFrame->GetContent()->
GetText()->AppendTo(aResult, offset, length);
} else {
for (nsIFrame* child : aFrame->PrincipalChildList()) {
AppendFrameTextContent(child, aResult);
}
}
}
/* static */
nsRect
nsLayoutUtils::GetSelectionBoundingRect(Selection* aSel)
{
nsRect res;
// Bounding client rect may be empty after calling GetBoundingClientRect
// when range is collapsed. So we get caret's rect when range is
// collapsed.
if (aSel->IsCollapsed()) {
nsIFrame* frame = nsCaret::GetGeometry(aSel, &res);
if (frame) {
nsIFrame* relativeTo = GetContainingBlockForClientRect(frame);
res = TransformFrameRectToAncestor(frame, res, relativeTo);
}
} else {
int32_t rangeCount = aSel->RangeCount();
RectAccumulator accumulator;
for (int32_t idx = 0; idx < rangeCount; ++idx) {
nsRange* range = aSel->GetRangeAt(idx);
nsRange::CollectClientRectsAndText(&accumulator, nullptr, range,
range->GetStartParent(), range->StartOffset(),
range->GetEndParent(), range->EndOffset(),
true, false);
}
res = accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect :
accumulator.mResultRect;
}
return res;
}
/* static */ nsBlockFrame*
nsLayoutUtils::GetFloatContainingBlock(nsIFrame* aFrame)
{
nsIFrame* ancestor = aFrame->GetParent();
while (ancestor && !ancestor->IsFloatContainingBlock()) {
ancestor = ancestor->GetParent();
}
MOZ_ASSERT(!ancestor || GetAsBlock(ancestor),
"Float containing block can only be block frame");
return static_cast<nsBlockFrame*>(ancestor);
}
// The implementation of this calculation is adapted from
// Element::GetBoundingClientRect().
/* static */ CSSRect
nsLayoutUtils::GetBoundingContentRect(const nsIContent* aContent,
const nsIScrollableFrame* aRootScrollFrame) {
CSSRect result;
if (nsIFrame* frame = aContent->GetPrimaryFrame()) {
nsIFrame* relativeTo = aRootScrollFrame->GetScrolledFrame();
result = CSSRect::FromAppUnits(
nsLayoutUtils::GetAllInFlowRectsUnion(
frame,
relativeTo,
nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS));
// If the element is contained in a scrollable frame that is not
// the root scroll frame, make sure to clip the result so that it is
// not larger than the containing scrollable frame's bounds.
nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetNearestScrollableFrame(frame);
if (scrollFrame && scrollFrame != aRootScrollFrame) {
nsIFrame* subFrame = do_QueryFrame(scrollFrame);
MOZ_ASSERT(subFrame);
// Get the bounds of the scroll frame in the same coordinate space
// as |result|.
CSSRect subFrameRect = CSSRect::FromAppUnits(
nsLayoutUtils::TransformFrameRectToAncestor(
subFrame,
subFrame->GetRectRelativeToSelf(),
relativeTo));
result = subFrameRect.Intersect(result);
}
}
return result;
}
static already_AddRefed<nsIPresShell>
GetPresShell(const nsIContent* aContent)
{
nsCOMPtr<nsIPresShell> result;
if (nsIDocument* doc = aContent->GetComposedDoc()) {
result = doc->GetShell();
}
return result.forget();
}
static void UpdateDisplayPortMarginsForPendingMetrics(FrameMetrics& aMetrics) {
nsIContent* content = nsLayoutUtils::FindContentFor(aMetrics.GetScrollId());
if (!content) {
return;
}
nsCOMPtr<nsIPresShell> shell = GetPresShell(content);
if (!shell) {
return;
}
MOZ_ASSERT(aMetrics.GetUseDisplayPortMargins());
if (gfxPrefs::APZAllowZooming() && aMetrics.IsRootContent()) {
// See APZCCallbackHelper::UpdateRootFrame for details.
float presShellResolution = shell->GetResolution();
if (presShellResolution != aMetrics.GetPresShellResolution()) {
return;
}
}
nsIScrollableFrame* frame = nsLayoutUtils::FindScrollableFrameFor(aMetrics.GetScrollId());
if (!frame) {
return;
}
if (APZCCallbackHelper::IsScrollInProgress(frame)) {
// If these conditions are true, then the UpdateFrame
// message may be ignored by the main-thread, so we
// shouldn't update the displayport based on it.
return;
}
DisplayPortMarginsPropertyData* currentData =
static_cast<DisplayPortMarginsPropertyData*>(content->GetProperty(nsGkAtoms::DisplayPortMargins));
if (!currentData) {
return;
}
CSSPoint frameScrollOffset = CSSPoint::FromAppUnits(frame->GetScrollPosition());
APZCCallbackHelper::AdjustDisplayPortForScrollDelta(aMetrics, frameScrollOffset);
nsLayoutUtils::SetDisplayPortMargins(content, shell,
aMetrics.GetDisplayPortMargins(), 0);
}
/* static */ void
nsLayoutUtils::UpdateDisplayPortMarginsFromPendingMessages()
{
if (mozilla::dom::ContentChild::GetSingleton() &&
mozilla::dom::ContentChild::GetSingleton()->GetIPCChannel()) {
CompositorBridgeChild::Get()->GetIPCChannel()->PeekMessages(
[](const IPC::Message& aMsg) -> bool {
if (aMsg.type() == mozilla::layers::PAPZ::Msg_RequestContentRepaint__ID) {
PickleIterator iter(aMsg);
FrameMetrics frame;
if (!IPC::ReadParam(&aMsg, &iter, &frame)) {
MOZ_ASSERT(false);
return true;
}
UpdateDisplayPortMarginsForPendingMetrics(frame);
}
return true;
});
}
}
/* static */ bool
nsLayoutUtils::IsTransformed(nsIFrame* aForFrame, nsIFrame* aTopFrame)
{
for (nsIFrame* f = aForFrame; f != aTopFrame; f = f->GetParent()) {
if (f->IsTransformed()) {
return true;
}
}
return false;
}
/*static*/ CSSPoint
nsLayoutUtils::GetCumulativeApzCallbackTransform(nsIFrame* aFrame)
{
CSSPoint delta;
if (!aFrame) {
return delta;
}
nsIFrame* frame = aFrame;
nsCOMPtr<nsIContent> content = frame->GetContent();
nsCOMPtr<nsIContent> lastContent;
while (frame) {
if (content && (content != lastContent)) {
void* property = content->GetProperty(nsGkAtoms::apzCallbackTransform);
if (property) {
delta += *static_cast<CSSPoint*>(property);
}
}
frame = GetCrossDocParentFrame(frame);
lastContent = content;
content = frame ? frame->GetContent() : nullptr;
}
return delta;
}
/* static */ bool
nsLayoutUtils::SupportsServoStyleBackend(nsIDocument* aDocument)
{
return StyloEnabled() &&
aDocument->IsHTMLOrXHTML() &&
static_cast<nsDocument*>(aDocument)->IsContentDocument();
}
static
bool
LineHasNonEmptyContentWorker(nsIFrame* aFrame)
{
// Look for non-empty frames, but ignore inline and br frames.
// For inline frames, descend into the children, if any.
if (aFrame->GetType() == nsGkAtoms::inlineFrame) {
for (nsIFrame* child : aFrame->PrincipalChildList()) {
if (LineHasNonEmptyContentWorker(child)) {
return true;
}
}
} else {
if (aFrame->GetType() != nsGkAtoms::brFrame &&
!aFrame->IsEmpty()) {
return true;
}
}
return false;
}
static
bool
LineHasNonEmptyContent(nsLineBox* aLine)
{
int32_t count = aLine->GetChildCount();
for (nsIFrame* frame = aLine->mFirstChild; count > 0;
--count, frame = frame->GetNextSibling()) {
if (LineHasNonEmptyContentWorker(frame)) {
return true;
}
}
return false;
}
/* static */ bool
nsLayoutUtils::IsInvisibleBreak(nsINode* aNode, nsIFrame** aNextLineFrame)
{
if (aNextLineFrame) {
*aNextLineFrame = nullptr;
}
if (!aNode->IsElement() || !aNode->IsEditable()) {
return false;
}
nsIFrame* frame = aNode->AsElement()->GetPrimaryFrame();
if (!frame || frame->GetType() != nsGkAtoms::brFrame) {
return false;
}
nsContainerFrame* f = frame->GetParent();
while (f && f->IsFrameOfType(nsBox::eLineParticipant)) {
f = f->GetParent();
}
nsBlockFrame* blockAncestor = do_QueryFrame(f);
if (!blockAncestor) {
// The container frame doesn't support line breaking.
return false;
}
bool valid = false;
nsBlockInFlowLineIterator iter(blockAncestor, frame, &valid);
if (!valid) {
return false;
}
bool lineNonEmpty = LineHasNonEmptyContent(iter.GetLine());
if (!lineNonEmpty) {
return false;
}
while (iter.Next()) {
auto currentLine = iter.GetLine();
// Completely skip empty lines.
if (!currentLine->IsEmpty()) {
// If we come across an inline line, the BR has caused a visible line break.
if (currentLine->IsInline()) {
if (aNextLineFrame) {
*aNextLineFrame = currentLine->mFirstChild;
}
return false;
}
break;
}
}
return lineNonEmpty;
}
static nsRect
ComputeSVGReferenceRect(nsIFrame* aFrame,
StyleGeometryBox aGeometryBox)
{
MOZ_ASSERT(aFrame->GetContent()->IsSVGElement());
nsRect r;
// For SVG elements without associated CSS layout box, the used value for
// content-box, padding-box, border-box and margin-box is fill-box.
switch (aGeometryBox) {
case StyleGeometryBox::Stroke: {
// XXX Bug 1299876
// The size of srtoke-box is not correct if this graphic element has
// specific stroke-linejoin or stroke-linecap.
gfxRect bbox = nsSVGUtils::GetBBox(aFrame,
nsSVGUtils::eBBoxIncludeFill | nsSVGUtils::eBBoxIncludeStroke);
r = nsLayoutUtils::RoundGfxRectToAppRect(bbox,
nsPresContext::AppUnitsPerCSSPixel());
break;
}
case StyleGeometryBox::View: {
nsIContent* content = aFrame->GetContent();
nsSVGElement* element = static_cast<nsSVGElement*>(content);
SVGSVGElement* svgElement = element->GetCtx();
MOZ_ASSERT(svgElement);
if (svgElement && svgElement->HasViewBoxRect()) {
// If a ‘viewBox‘ attribute is specified for the SVG viewport creating
// element:
// 1. The reference box is positioned at the origin of the coordinate
// system established by the ‘viewBox‘ attribute.
// 2. The dimension of the reference box is set to the width and height
// values of the ‘viewBox‘ attribute.
nsSVGViewBox* viewBox = svgElement->GetViewBox();
const nsSVGViewBoxRect& value = viewBox->GetAnimValue();
r = nsRect(nsPresContext::CSSPixelsToAppUnits(value.x),
nsPresContext::CSSPixelsToAppUnits(value.y),
nsPresContext::CSSPixelsToAppUnits(value.width),
nsPresContext::CSSPixelsToAppUnits(value.height));
} else {
// No viewBox is specified, uses the nearest SVG viewport as reference
// box.
svgFloatSize viewportSize = svgElement->GetViewportSize();
r = nsRect(0, 0,
nsPresContext::CSSPixelsToAppUnits(viewportSize.width),
nsPresContext::CSSPixelsToAppUnits(viewportSize.height));
}
break;
}
case StyleGeometryBox::NoBox:
case StyleGeometryBox::Border:
case StyleGeometryBox::Content:
case StyleGeometryBox::Padding:
case StyleGeometryBox::Margin:
case StyleGeometryBox::Fill: {
gfxRect bbox = nsSVGUtils::GetBBox(aFrame,
nsSVGUtils::eBBoxIncludeFill);
r = nsLayoutUtils::RoundGfxRectToAppRect(bbox,
nsPresContext::AppUnitsPerCSSPixel());
break;
}
default:{
MOZ_ASSERT_UNREACHABLE("unknown StyleGeometryBox type");
gfxRect bbox = nsSVGUtils::GetBBox(aFrame,
nsSVGUtils::eBBoxIncludeFill);
r = nsLayoutUtils::RoundGfxRectToAppRect(bbox,
nsPresContext::AppUnitsPerCSSPixel());
break;
}
}
return r;
}
static nsRect
ComputeHTMLReferenceRect(nsIFrame* aFrame,
StyleGeometryBox aGeometryBox)
{
nsRect r;
// For elements with associated CSS layout box, the used value for fill-box,
// stroke-box and view-box is border-box.
switch (aGeometryBox) {
case StyleGeometryBox::Content:
r = aFrame->GetContentRectRelativeToSelf();
break;
case StyleGeometryBox::Padding:
r = aFrame->GetPaddingRectRelativeToSelf();
break;
case StyleGeometryBox::Margin:
r = aFrame->GetMarginRectRelativeToSelf();
break;
case StyleGeometryBox::NoBox:
case StyleGeometryBox::Border:
case StyleGeometryBox::Fill:
case StyleGeometryBox::Stroke:
case StyleGeometryBox::View:
r = aFrame->GetRectRelativeToSelf();
break;
default:
MOZ_ASSERT_UNREACHABLE("unknown StyleGeometryBox type");
r = aFrame->GetRectRelativeToSelf();
break;
}
return r;
}
/* static */ nsRect
nsLayoutUtils::ComputeGeometryBox(nsIFrame* aFrame,
StyleGeometryBox aGeometryBox)
{
// We use ComputeSVGReferenceRect for all SVG elements, except <svg>
// element, which does have an associated CSS layout box. In this case we
// should still use ComputeHTMLReferenceRect for region computing.
nsRect r = aFrame->IsFrameOfType(nsIFrame::eSVG) &&
(aFrame->GetType() != nsGkAtoms::svgOuterSVGFrame)
? ComputeSVGReferenceRect(aFrame, aGeometryBox)
: ComputeHTMLReferenceRect(aFrame, aGeometryBox);
return r;
}
Reference in New Issue View Git Blame Copy Permalink