зеркало из https://github.com/mozilla/gecko-dev.git
10116 строки
373 KiB
C++
10116 строки
373 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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 <algorithm>
|
|
#include <limits>
|
|
|
|
#include "ActiveLayerTracker.h"
|
|
#include "DisplayItemClip.h"
|
|
#include "gfx2DGlue.h"
|
|
#include "gfxContext.h"
|
|
#include "gfxDrawable.h"
|
|
#include "gfxEnv.h"
|
|
#include "gfxMatrix.h"
|
|
#include "gfxPlatform.h"
|
|
#include "gfxRect.h"
|
|
#include "gfxTypes.h"
|
|
#include "gfxUtils.h"
|
|
#include "ImageContainer.h"
|
|
#include "ImageOps.h"
|
|
#include "ImageRegion.h"
|
|
#include "imgIContainer.h"
|
|
#include "imgIRequest.h"
|
|
#include "LayoutLogging.h"
|
|
#include "MobileViewportManager.h"
|
|
#include "mozilla/AccessibleCaretEventHub.h"
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/Baseline.h"
|
|
#include "mozilla/BasicEvents.h"
|
|
#include "mozilla/ClearOnShutdown.h"
|
|
#include "mozilla/DisplayPortUtils.h"
|
|
#include "mozilla/glean/GleanMetrics.h"
|
|
#include "mozilla/dom/AnonymousContent.h"
|
|
#include "mozilla/dom/BrowserChild.h"
|
|
#include "mozilla/dom/CanvasUtils.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/dom/DocumentInlines.h"
|
|
#include "mozilla/dom/DOMRect.h"
|
|
#include "mozilla/dom/DOMStringList.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/HTMLBodyElement.h"
|
|
#include "mozilla/dom/HTMLCanvasElement.h"
|
|
#include "mozilla/dom/HTMLImageElement.h"
|
|
#include "mozilla/dom/HTMLMediaElementBinding.h"
|
|
#include "mozilla/dom/HTMLVideoElement.h"
|
|
#include "mozilla/dom/InspectorFontFace.h"
|
|
#include "mozilla/dom/ImageBitmap.h"
|
|
#include "mozilla/dom/KeyframeEffect.h"
|
|
#include "mozilla/dom/SVGViewportElement.h"
|
|
#include "mozilla/dom/UIEvent.h"
|
|
#include "mozilla/dom/VideoFrame.h"
|
|
#include "mozilla/dom/VideoFrameBinding.h"
|
|
#include "mozilla/intl/BidiEmbeddingLevel.h"
|
|
#include "mozilla/EffectCompositor.h"
|
|
#include "mozilla/EffectSet.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventStateManager.h"
|
|
#include "mozilla/FloatingPoint.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/gfx/gfxVars.h"
|
|
#include "mozilla/gfx/PathHelpers.h"
|
|
#include "mozilla/gfx/DataSurfaceHelpers.h"
|
|
#include "mozilla/IntegerRange.h"
|
|
#include "mozilla/layers/APZCCallbackHelper.h"
|
|
#include "mozilla/layers/APZPublicUtils.h" // for apz::CalculatePendingDisplayPort
|
|
#include "mozilla/layers/CompositorBridgeChild.h"
|
|
#include "mozilla/layers/PAPZ.h"
|
|
#include "mozilla/layers/StackingContextHelper.h"
|
|
#include "mozilla/layers/WebRenderLayerManager.h"
|
|
#include "mozilla/Likely.h"
|
|
#include "mozilla/LookAndFeel.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/PerfStats.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/ProfilerLabels.h"
|
|
#include "mozilla/ProfilerMarkers.h"
|
|
#include "mozilla/RestyleManager.h"
|
|
#include "mozilla/ScopeExit.h"
|
|
#include "mozilla/ScrollOrigin.h"
|
|
#include "mozilla/ServoStyleSet.h"
|
|
#include "mozilla/ServoStyleSetInlines.h"
|
|
#include "mozilla/StaticPrefs_apz.h"
|
|
#include "mozilla/StaticPrefs_browser.h"
|
|
#include "mozilla/StaticPrefs_dom.h"
|
|
#include "mozilla/StaticPrefs_font.h"
|
|
#include "mozilla/StaticPrefs_general.h"
|
|
#include "mozilla/StaticPrefs_gfx.h"
|
|
#include "mozilla/StaticPrefs_image.h"
|
|
#include "mozilla/StaticPrefs_layers.h"
|
|
#include "mozilla/StaticPrefs_layout.h"
|
|
#include "mozilla/StaticPtr.h"
|
|
#include "mozilla/StyleAnimationValue.h"
|
|
#include "mozilla/SVGImageContext.h"
|
|
#include "mozilla/SVGIntegrationUtils.h"
|
|
#include "mozilla/SVGTextFrame.h"
|
|
#include "mozilla/SVGUtils.h"
|
|
#include "mozilla/Telemetry.h"
|
|
#include "mozilla/ToString.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/ViewportFrame.h"
|
|
#include "mozilla/ViewportUtils.h"
|
|
#include "mozilla/WheelHandlingHelper.h" // for WheelHandlingUtils
|
|
#include "nsAnimationManager.h"
|
|
#include "nsAtom.h"
|
|
#include "nsBidiPresUtils.h"
|
|
#include "nsBlockFrame.h"
|
|
#include "nsCanvasFrame.h"
|
|
#include "nsCaret.h"
|
|
#include "nsCharTraits.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsComputedDOMStyle.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCSSAnonBoxes.h"
|
|
#include "nsCSSColorUtils.h"
|
|
#include "nsCSSFrameConstructor.h"
|
|
#include "nsCSSProps.h"
|
|
#include "nsCSSPseudoElements.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsFieldSetFrame.h"
|
|
#include "nsFlexContainerFrame.h"
|
|
#include "nsFontInflationData.h"
|
|
#include "nsFontMetrics.h"
|
|
#include "nsFrameList.h"
|
|
#include "nsFrameSelection.h"
|
|
#include "nsGenericHTMLElement.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsICanvasRenderingContextInternal.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIContentInlines.h"
|
|
#include "nsIContentViewer.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIFrameInlines.h"
|
|
#include "nsIImageLoadingContent.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIScrollableFrame.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsListControlFrame.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsPlaceholderFrame.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsPresContextInlines.h"
|
|
#include "nsRefreshDriver.h"
|
|
#include "nsRegion.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsStyleStructInlines.h"
|
|
#include "nsStyleTransformMatrix.h"
|
|
#include "nsSubDocumentFrame.h"
|
|
#include "nsTableWrapperFrame.h"
|
|
#include "nsTArray.h"
|
|
#include "nsTextFragment.h"
|
|
#include "nsTextFrame.h"
|
|
#include "nsTHashMap.h"
|
|
#include "nsTransitionManager.h"
|
|
#include "nsView.h"
|
|
#include "nsViewManager.h"
|
|
#include "prenv.h"
|
|
#include "RegionBuilder.h"
|
|
#include "RetainedDisplayListBuilder.h"
|
|
#include "TextDrawTarget.h"
|
|
#include "UnitTransforms.h"
|
|
#include "ViewportFrame.h"
|
|
|
|
#include "nsXULPopupManager.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;
|
|
using mozilla::dom::HTMLMediaElement_Binding::HAVE_METADATA;
|
|
using mozilla::dom::HTMLMediaElement_Binding::HAVE_NOTHING;
|
|
|
|
#ifdef DEBUG
|
|
// TODO: remove, see bug 598468.
|
|
bool nsLayoutUtils::gPreventAssertInCompareTreePosition = false;
|
|
#endif // DEBUG
|
|
|
|
typedef ScrollableLayerGuid::ViewID ViewID;
|
|
typedef nsStyleTransformMatrix::TransformReferenceBox TransformReferenceBox;
|
|
|
|
static ViewID sScrollIdCounter = ScrollableLayerGuid::START_SCROLL_ID;
|
|
|
|
typedef nsTHashMap<nsUint64HashKey, nsIContent*> ContentMap;
|
|
static StaticAutoPtr<ContentMap> sContentMap;
|
|
|
|
static ContentMap& GetContentMap() {
|
|
if (!sContentMap) {
|
|
sContentMap = new ContentMap();
|
|
}
|
|
return *sContentMap;
|
|
}
|
|
|
|
template <typename TestType>
|
|
static bool HasMatchingAnimations(EffectSet& aEffects, TestType&& aTest) {
|
|
for (KeyframeEffect* effect : aEffects) {
|
|
if (!effect->GetAnimation() || !effect->GetAnimation()->IsRelevant()) {
|
|
continue;
|
|
}
|
|
|
|
if (aTest(*effect, aEffects)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template <typename TestType>
|
|
static bool HasMatchingAnimations(const nsIFrame* aFrame,
|
|
const nsCSSPropertyIDSet& aPropertySet,
|
|
TestType&& aTest) {
|
|
MOZ_ASSERT(aFrame);
|
|
|
|
if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::OpacityProperties()) &&
|
|
!aFrame->MayHaveOpacityAnimation()) {
|
|
return false;
|
|
}
|
|
|
|
if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::TransformLikeProperties()) &&
|
|
!aFrame->MayHaveTransformAnimation()) {
|
|
return false;
|
|
}
|
|
|
|
EffectSet* effectSet = EffectSet::GetForFrame(aFrame, aPropertySet);
|
|
if (!effectSet) {
|
|
return false;
|
|
}
|
|
|
|
return HasMatchingAnimations(*effectSet, aTest);
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::HasAnimationOfPropertySet(
|
|
const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet) {
|
|
return HasMatchingAnimations(
|
|
aFrame, aPropertySet,
|
|
[&aPropertySet](KeyframeEffect& aEffect, const EffectSet&) {
|
|
return aEffect.HasAnimationOfPropertySet(aPropertySet);
|
|
});
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::HasAnimationOfPropertySet(
|
|
const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet,
|
|
EffectSet* aEffectSet) {
|
|
MOZ_ASSERT(
|
|
!aEffectSet || EffectSet::GetForFrame(aFrame, aPropertySet) == aEffectSet,
|
|
"The EffectSet, if supplied, should match what we would otherwise fetch");
|
|
|
|
if (!aEffectSet) {
|
|
return nsLayoutUtils::HasAnimationOfPropertySet(aFrame, aPropertySet);
|
|
}
|
|
|
|
if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::TransformLikeProperties()) &&
|
|
!aEffectSet->MayHaveTransformAnimation()) {
|
|
return false;
|
|
}
|
|
|
|
if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::OpacityProperties()) &&
|
|
!aEffectSet->MayHaveOpacityAnimation()) {
|
|
return false;
|
|
}
|
|
|
|
return HasMatchingAnimations(
|
|
*aEffectSet,
|
|
[&aPropertySet](KeyframeEffect& aEffect, const EffectSet& aEffectSet) {
|
|
return aEffect.HasAnimationOfPropertySet(aPropertySet);
|
|
});
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::HasAnimationOfTransformAndMotionPath(
|
|
const nsIFrame* aFrame) {
|
|
return nsLayoutUtils::HasAnimationOfPropertySet(
|
|
aFrame,
|
|
nsCSSPropertyIDSet{eCSSProperty_transform, eCSSProperty_translate,
|
|
eCSSProperty_rotate, eCSSProperty_scale,
|
|
eCSSProperty_offset_path}) ||
|
|
(!aFrame->StyleDisplay()->mOffsetPath.IsNone() &&
|
|
nsLayoutUtils::HasAnimationOfPropertySet(
|
|
aFrame, nsCSSPropertyIDSet::MotionPathProperties()));
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::HasEffectiveAnimation(
|
|
const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet) {
|
|
return HasMatchingAnimations(
|
|
aFrame, aPropertySet,
|
|
[&aPropertySet](KeyframeEffect& aEffect, const EffectSet& aEffectSet) {
|
|
return aEffect.HasEffectiveAnimationOfPropertySet(aPropertySet,
|
|
aEffectSet);
|
|
});
|
|
}
|
|
|
|
/* static */
|
|
nsCSSPropertyIDSet nsLayoutUtils::GetAnimationPropertiesForCompositor(
|
|
const nsIFrame* aStyleFrame) {
|
|
nsCSSPropertyIDSet properties;
|
|
|
|
// We fetch the effects for the style frame here since this method is called
|
|
// by RestyleManager::AddLayerChangesForAnimation which takes care to apply
|
|
// the relevant hints to the primary frame as needed.
|
|
EffectSet* effects = EffectSet::GetForStyleFrame(aStyleFrame);
|
|
if (!effects) {
|
|
return properties;
|
|
}
|
|
|
|
AnimationPerformanceWarning::Type warning;
|
|
if (!EffectCompositor::AllowCompositorAnimationsOnFrame(aStyleFrame,
|
|
warning)) {
|
|
return properties;
|
|
}
|
|
|
|
for (const KeyframeEffect* effect : *effects) {
|
|
properties |= effect->GetPropertiesForCompositor(*effects, aStyleFrame);
|
|
}
|
|
|
|
// If properties only have motion-path properties, we have to make sure they
|
|
// have effects. i.e. offset-path is not none or we have offset-path
|
|
// animations.
|
|
if (properties.IsSubsetOf(nsCSSPropertyIDSet::MotionPathProperties()) &&
|
|
!properties.HasProperty(eCSSProperty_offset_path) &&
|
|
aStyleFrame->StyleDisplay()->mOffsetPath.IsNone()) {
|
|
properties.Empty();
|
|
}
|
|
|
|
return properties;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// The first value in this pair is the min scale, and the second one is the max
|
|
// scale.
|
|
using MinAndMaxScale = std::pair<MatrixScales, MatrixScales>;
|
|
|
|
static inline void UpdateMinMaxScale(const nsIFrame* aFrame,
|
|
const AnimationValue& aValue,
|
|
MinAndMaxScale& aMinAndMaxScale) {
|
|
MatrixScales size = aValue.GetScaleValue(aFrame);
|
|
MatrixScales& minScale = aMinAndMaxScale.first;
|
|
MatrixScales& maxScale = aMinAndMaxScale.second;
|
|
|
|
minScale = Min(minScale, size);
|
|
maxScale = Max(maxScale, size);
|
|
}
|
|
|
|
// The final transform matrix is calculated by merging the final results of each
|
|
// transform-like properties, so do the scale factors. In other words, the
|
|
// potential min/max scales could be gotten by multiplying the max/min scales of
|
|
// each properties.
|
|
//
|
|
// For example, there is an animation:
|
|
// from { "transform: scale(1, 1)", "scale: 3, 3" };
|
|
// to { "transform: scale(2, 2)", "scale: 1, 1" };
|
|
//
|
|
// the min scale is (1, 1) * (1, 1) = (1, 1), and
|
|
// The max scale is (2, 2) * (3, 3) = (6, 6).
|
|
// This means we multiply the min/max scale factor of transform property and the
|
|
// min/max scale factor of scale property to get the final max/min scale factor.
|
|
static Array<MinAndMaxScale, 2> GetMinAndMaxScaleForAnimationProperty(
|
|
const nsIFrame* aFrame,
|
|
const nsTArray<RefPtr<dom::Animation>>& aAnimations) {
|
|
// We use a fixed array to store the min/max scales for each property.
|
|
// The first element in the array is for eCSSProperty_transform, and the
|
|
// second one is for eCSSProperty_scale.
|
|
const MinAndMaxScale defaultValue =
|
|
std::make_pair(MatrixScales(std::numeric_limits<float>::max(),
|
|
std::numeric_limits<float>::max()),
|
|
MatrixScales(std::numeric_limits<float>::min(),
|
|
std::numeric_limits<float>::min()));
|
|
Array<MinAndMaxScale, 2> minAndMaxScales(defaultValue, defaultValue);
|
|
|
|
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());
|
|
|
|
const dom::KeyframeEffect* effect =
|
|
anim->GetEffect() ? anim->GetEffect()->AsKeyframeEffect() : nullptr;
|
|
MOZ_ASSERT(effect, "A playing animation should have a keyframe effect");
|
|
for (const AnimationProperty& prop : effect->Properties()) {
|
|
if (prop.mProperty != eCSSProperty_transform &&
|
|
prop.mProperty != eCSSProperty_scale) {
|
|
continue;
|
|
}
|
|
|
|
// 0: eCSSProperty_transform.
|
|
// 1: eCSSProperty_scale.
|
|
MinAndMaxScale& scales =
|
|
minAndMaxScales[prop.mProperty == eCSSProperty_transform ? 0 : 1];
|
|
|
|
// We need to factor in the scale of the base style if the base style
|
|
// will be used on the compositor.
|
|
const AnimationValue& baseStyle = effect->BaseStyle(prop.mProperty);
|
|
if (!baseStyle.IsNull()) {
|
|
UpdateMinMaxScale(aFrame, baseStyle, scales);
|
|
}
|
|
|
|
for (const AnimationPropertySegment& segment : prop.mSegments) {
|
|
// In case of add or accumulate composite, StyleAnimationValue does
|
|
// not have a valid value.
|
|
if (segment.HasReplaceableFromValue()) {
|
|
UpdateMinMaxScale(aFrame, segment.mFromValue, scales);
|
|
}
|
|
|
|
if (segment.HasReplaceableToValue()) {
|
|
UpdateMinMaxScale(aFrame, segment.mToValue, scales);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return minAndMaxScales;
|
|
}
|
|
|
|
MatrixScales nsLayoutUtils::ComputeSuitableScaleForAnimation(
|
|
const nsIFrame* aFrame, const nsSize& aVisibleSize,
|
|
const nsSize& aDisplaySize) {
|
|
const nsTArray<RefPtr<dom::Animation>> compositorAnimations =
|
|
EffectCompositor::GetAnimationsForCompositor(
|
|
aFrame,
|
|
nsCSSPropertyIDSet{eCSSProperty_transform, eCSSProperty_scale});
|
|
|
|
if (compositorAnimations.IsEmpty()) {
|
|
return MatrixScales();
|
|
}
|
|
|
|
const Array<MinAndMaxScale, 2> minAndMaxScales =
|
|
GetMinAndMaxScaleForAnimationProperty(aFrame, compositorAnimations);
|
|
|
|
// This might cause an issue if users use std::numeric_limits<float>::min()
|
|
// (or max()) as the scale value. However, in this case, we may render an
|
|
// extreme small (or large) element, so this may not be a problem. If so,
|
|
// please fix this.
|
|
MatrixScales maxScale(std::numeric_limits<float>::min(),
|
|
std::numeric_limits<float>::min());
|
|
MatrixScales minScale(std::numeric_limits<float>::max(),
|
|
std::numeric_limits<float>::max());
|
|
|
|
auto isUnset = [](const MatrixScales& aMax, const MatrixScales& aMin) {
|
|
return aMax.xScale == std::numeric_limits<float>::min() &&
|
|
aMax.yScale == std::numeric_limits<float>::min() &&
|
|
aMin.xScale == std::numeric_limits<float>::max() &&
|
|
aMin.yScale == std::numeric_limits<float>::max();
|
|
};
|
|
|
|
// Iterate the slots to get the final scale value.
|
|
for (const auto& pair : minAndMaxScales) {
|
|
const MatrixScales& currMinScale = pair.first;
|
|
const MatrixScales& currMaxScale = pair.second;
|
|
|
|
if (isUnset(currMaxScale, currMinScale)) {
|
|
// We don't have this animation property, so skip.
|
|
continue;
|
|
}
|
|
|
|
if (isUnset(maxScale, minScale)) {
|
|
// Initialize maxScale and minScale.
|
|
maxScale = currMaxScale;
|
|
minScale = currMinScale;
|
|
} else {
|
|
// The scale factors of each transform-like property should be multiplied
|
|
// by others because we merge their sampled values as a final matrix by
|
|
// matrix multiplication, so here we multiply the scale factors by the
|
|
// previous one to get the possible max and min scale factors.
|
|
maxScale = maxScale * currMaxScale;
|
|
minScale = minScale * currMinScale;
|
|
}
|
|
}
|
|
|
|
if (isUnset(maxScale, minScale)) {
|
|
// We didn't encounter any transform-like property.
|
|
return MatrixScales();
|
|
}
|
|
|
|
return MatrixScales(
|
|
GetSuitableScale(maxScale.xScale, minScale.xScale, aVisibleSize.width,
|
|
aDisplaySize.width),
|
|
GetSuitableScale(maxScale.yScale, minScale.yScale, aVisibleSize.height,
|
|
aDisplaySize.height));
|
|
}
|
|
|
|
bool nsLayoutUtils::AreAsyncAnimationsEnabled() {
|
|
return StaticPrefs::layers_offmainthreadcomposition_async_animations() &&
|
|
gfxPlatform::OffMainThreadCompositingEnabled();
|
|
}
|
|
|
|
bool nsLayoutUtils::AreRetainedDisplayListsEnabled() {
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
return StaticPrefs::layout_display_list_retain();
|
|
#else
|
|
if (XRE_IsContentProcess()) {
|
|
return StaticPrefs::layout_display_list_retain();
|
|
}
|
|
|
|
if (XRE_IsE10sParentProcess()) {
|
|
return StaticPrefs::layout_display_list_retain_chrome();
|
|
}
|
|
|
|
// Retained display lists require e10s.
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool nsLayoutUtils::DisplayRootHasRetainedDisplayListBuilder(nsIFrame* aFrame) {
|
|
return GetRetainedDisplayListBuilder(aFrame) != nullptr;
|
|
}
|
|
|
|
RetainedDisplayListBuilder* nsLayoutUtils::GetRetainedDisplayListBuilder(
|
|
nsIFrame* aFrame) {
|
|
MOZ_ASSERT(aFrame);
|
|
MOZ_ASSERT(aFrame->PresShell());
|
|
|
|
// Use the pres shell root frame to get the display root frame. This skips
|
|
// the early exit in |nsLayoutUtils::GetDisplayRootFrame()| for popup frames.
|
|
const nsIFrame* rootFrame = aFrame->PresShell()->GetRootFrame();
|
|
if (!rootFrame) {
|
|
return nullptr;
|
|
}
|
|
|
|
const nsIFrame* displayRootFrame = GetDisplayRootFrame(rootFrame);
|
|
MOZ_ASSERT(displayRootFrame);
|
|
|
|
return displayRootFrame->GetProperty(RetainedDisplayListBuilder::Cached());
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
void nsLayoutUtils::UnionChildOverflow(nsIFrame* aFrame,
|
|
OverflowAreas& aOverflowAreas,
|
|
FrameChildListIDs aSkipChildLists) {
|
|
// Iterate over all children except pop-ups.
|
|
FrameChildListIDs skip(aSkipChildLists);
|
|
skip += FrameChildListID::Popup;
|
|
|
|
for (const auto& [list, listID] : aFrame->ChildLists()) {
|
|
if (skip.contains(listID)) {
|
|
continue;
|
|
}
|
|
for (nsIFrame* child : list) {
|
|
aOverflowAreas.UnionWith(
|
|
child->GetActualAndNormalOverflowAreasRelativeToParent());
|
|
}
|
|
}
|
|
}
|
|
|
|
static void DestroyViewID(void* aObject, nsAtom* 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().InsertOrUpdate(scrollId, aContent);
|
|
}
|
|
|
|
return scrollId;
|
|
}
|
|
|
|
nsIContent* nsLayoutUtils::FindContentFor(ViewID aId) {
|
|
MOZ_ASSERT(aId != ScrollableLayerGuid::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* nsLayoutUtils::GetScrollFrameFromContent(nsIContent* aContent) {
|
|
nsIFrame* frame = aContent->GetPrimaryFrame();
|
|
if (aContent->OwnerDoc()->GetRootElement() == aContent) {
|
|
PresShell* presShell = frame ? frame->PresShell() : nullptr;
|
|
if (!presShell) {
|
|
presShell = aContent->OwnerDoc()->GetPresShell();
|
|
}
|
|
// 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(
|
|
nsIContent* aContent) {
|
|
nsIFrame* scrollFrame = GetScrollFrameFromContent(aContent);
|
|
return scrollFrame ? scrollFrame->GetScrollTargetFrame() : nullptr;
|
|
}
|
|
|
|
nsIScrollableFrame* nsLayoutUtils::FindScrollableFrameFor(ViewID aId) {
|
|
nsIContent* content = FindContentFor(aId);
|
|
if (!content) {
|
|
return nullptr;
|
|
}
|
|
|
|
return FindScrollableFrameFor(content);
|
|
}
|
|
|
|
ViewID nsLayoutUtils::FindIDForScrollableFrame(
|
|
nsIScrollableFrame* aScrollable) {
|
|
if (!aScrollable) {
|
|
return ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
}
|
|
|
|
nsIFrame* scrollFrame = do_QueryFrame(aScrollable);
|
|
nsIContent* scrollContent = scrollFrame->GetContent();
|
|
|
|
ScrollableLayerGuid::ViewID scrollId;
|
|
if (scrollContent && nsLayoutUtils::FindIDFor(scrollContent, &scrollId)) {
|
|
return scrollId;
|
|
}
|
|
|
|
return ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
}
|
|
|
|
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(const 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;
|
|
}
|
|
|
|
const nsIFrame* frame = nsLayoutUtils::GetDisplayRootFrame(aFrame);
|
|
nsIWidget* widget = frame->GetNearestWidget();
|
|
if (!widget) {
|
|
return false;
|
|
}
|
|
return widget->AsyncPanZoomEnabled();
|
|
}
|
|
|
|
bool nsLayoutUtils::AllowZoomingForDocument(
|
|
const mozilla::dom::Document* aDocument) {
|
|
if (aDocument->GetPresShell() &&
|
|
!aDocument->GetPresShell()->AsyncPanZoomEnabled()) {
|
|
return false;
|
|
}
|
|
// True if we allow zooming for all documents on this platform, or if we are
|
|
// in RDM and handling meta viewports, which force zoom under some
|
|
// circumstances.
|
|
BrowsingContext* bc = aDocument ? aDocument->GetBrowsingContext() : nullptr;
|
|
return StaticPrefs::apz_allow_zooming() ||
|
|
(bc && bc->InRDMPane() &&
|
|
nsLayoutUtils::ShouldHandleMetaViewport(aDocument));
|
|
}
|
|
|
|
static bool HasVisibleAnonymousContents(Document* aDoc) {
|
|
for (RefPtr<AnonymousContent>& ac : aDoc->GetAnonymousContents()) {
|
|
// We check to see if the anonymous content node has a frame. If it doesn't,
|
|
// that means that's not visible to the user because e.g. it's display:none.
|
|
// For now we assume that if it has a frame, it is visible. We might be able
|
|
// to refine this further by adding complexity if it turns out this
|
|
// condition results in a lot of false positives.
|
|
if (ac->Host()->GetPrimaryFrame()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool nsLayoutUtils::ShouldDisableApzForElement(nsIContent* aContent) {
|
|
if (!aContent) {
|
|
return false;
|
|
}
|
|
|
|
if (aContent->GetProperty(nsGkAtoms::apzDisabled)) {
|
|
return true;
|
|
}
|
|
|
|
Document* doc = aContent->GetComposedDoc();
|
|
if (PresShell* rootPresShell =
|
|
APZCCallbackHelper::GetRootContentDocumentPresShellForContent(
|
|
aContent)) {
|
|
if (Document* rootDoc = rootPresShell->GetDocument()) {
|
|
nsIContent* rootContent =
|
|
rootPresShell->GetRootScrollFrame()
|
|
? rootPresShell->GetRootScrollFrame()->GetContent()
|
|
: rootDoc->GetDocumentElement();
|
|
// For the AccessibleCaret and other anonymous contents: disable APZ on
|
|
// any scrollable subframes that are not the root scrollframe of a
|
|
// document, if the document has any visible anonymous contents.
|
|
//
|
|
// If we find this is triggering in too many scenarios then we might
|
|
// want to tighten this check further. The main use cases for which we
|
|
// want to disable APZ as of this writing are listed in bug 1316318.
|
|
if (aContent != rootContent && HasVisibleAnonymousContents(rootDoc)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!doc) {
|
|
return false;
|
|
}
|
|
|
|
if (PresShell* presShell = doc->GetPresShell()) {
|
|
if (RefPtr<AccessibleCaretEventHub> eventHub =
|
|
presShell->GetAccessibleCaretEventHub()) {
|
|
// Disable APZ for all elements if AccessibleCaret tells us to do so.
|
|
if (eventHub->ShouldDisableApz()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return StaticPrefs::apz_disable_for_scroll_linked_effects() &&
|
|
doc->HasScrollLinkedEffect();
|
|
}
|
|
|
|
void nsLayoutUtils::NotifyPaintSkipTransaction(ViewID aScrollId) {
|
|
if (nsIScrollableFrame* scrollFrame =
|
|
nsLayoutUtils::FindScrollableFrameFor(aScrollId)) {
|
|
#ifdef DEBUG
|
|
nsIFrame* f = do_QueryFrame(scrollFrame);
|
|
MOZ_ASSERT(f && f->PresShell() && !f->PresShell()->IsResolutionUpdated());
|
|
#endif
|
|
scrollFrame->NotifyApzTransaction();
|
|
}
|
|
}
|
|
|
|
nsContainerFrame* nsLayoutUtils::LastContinuationWithChild(
|
|
nsContainerFrame* aFrame) {
|
|
MOZ_ASSERT(aFrame, "NULL frame pointer");
|
|
for (auto f = aFrame->LastContinuation(); f; f = f->GetPrevContinuation()) {
|
|
for (const auto& childList : f->ChildLists()) {
|
|
if (MOZ_LIKELY(!childList.mList.IsEmpty())) {
|
|
return static_cast<nsContainerFrame*>(f);
|
|
}
|
|
}
|
|
}
|
|
return aFrame;
|
|
}
|
|
|
|
// static
|
|
FrameChildListID nsLayoutUtils::GetChildListNameFor(nsIFrame* aChildFrame) {
|
|
FrameChildListID id = FrameChildListID::Principal;
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!aChildFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW));
|
|
|
|
if (aChildFrame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
|
|
nsIFrame* pif = aChildFrame->GetPrevInFlow();
|
|
if (pif->GetParent() == aChildFrame->GetParent()) {
|
|
id = FrameChildListID::ExcessOverflowContainers;
|
|
} else {
|
|
id = FrameChildListID::OverflowContainers;
|
|
}
|
|
} else {
|
|
LayoutFrameType childType = aChildFrame->Type();
|
|
if (LayoutFrameType::TableColGroup == childType) {
|
|
id = FrameChildListID::ColGroup;
|
|
} else if (aChildFrame->IsTableCaption()) {
|
|
id = FrameChildListID::Caption;
|
|
} else {
|
|
id = FrameChildListID::Principal;
|
|
}
|
|
}
|
|
|
|
#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) {
|
|
found = parent->GetChildList(FrameChildListID::Overflow)
|
|
.ContainsFrame(aChildFrame);
|
|
MOZ_ASSERT(found, "not in child list");
|
|
}
|
|
#endif
|
|
|
|
return id;
|
|
}
|
|
|
|
static Element* GetPseudo(const nsIContent* aContent, nsAtom* aPseudoProperty) {
|
|
MOZ_ASSERT(aPseudoProperty == nsGkAtoms::beforePseudoProperty ||
|
|
aPseudoProperty == nsGkAtoms::afterPseudoProperty ||
|
|
aPseudoProperty == nsGkAtoms::markerPseudoProperty);
|
|
if (!aContent->MayHaveAnonymousChildren()) {
|
|
return nullptr;
|
|
}
|
|
return static_cast<Element*>(aContent->GetProperty(aPseudoProperty));
|
|
}
|
|
|
|
/*static*/
|
|
Element* nsLayoutUtils::GetBeforePseudo(const nsIContent* aContent) {
|
|
return GetPseudo(aContent, nsGkAtoms::beforePseudoProperty);
|
|
}
|
|
|
|
/*static*/
|
|
nsIFrame* nsLayoutUtils::GetBeforeFrame(const nsIContent* aContent) {
|
|
Element* pseudo = GetBeforePseudo(aContent);
|
|
return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
|
|
}
|
|
|
|
/*static*/
|
|
Element* nsLayoutUtils::GetAfterPseudo(const nsIContent* aContent) {
|
|
return GetPseudo(aContent, nsGkAtoms::afterPseudoProperty);
|
|
}
|
|
|
|
/*static*/
|
|
nsIFrame* nsLayoutUtils::GetAfterFrame(const nsIContent* aContent) {
|
|
Element* pseudo = GetAfterPseudo(aContent);
|
|
return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
|
|
}
|
|
|
|
/*static*/
|
|
Element* nsLayoutUtils::GetMarkerPseudo(const nsIContent* aContent) {
|
|
return GetPseudo(aContent, nsGkAtoms::markerPseudoProperty);
|
|
}
|
|
|
|
/*static*/
|
|
nsIFrame* nsLayoutUtils::GetMarkerFrame(const nsIContent* aContent) {
|
|
Element* pseudo = GetMarkerPseudo(aContent);
|
|
return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
|
|
}
|
|
|
|
#ifdef ACCESSIBILITY
|
|
void nsLayoutUtils::GetMarkerSpokenText(const nsIContent* aContent,
|
|
nsAString& aText) {
|
|
MOZ_ASSERT(aContent && aContent->IsGeneratedContentContainerForMarker());
|
|
|
|
aText.Truncate();
|
|
|
|
nsIFrame* frame = aContent->GetPrimaryFrame();
|
|
if (!frame) {
|
|
return;
|
|
}
|
|
|
|
if (frame->StyleContent()->ContentCount() > 0) {
|
|
for (nsIFrame* child : frame->PrincipalChildList()) {
|
|
nsIFrame::RenderedText text = child->GetRenderedText();
|
|
aText += text.mString;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!frame->StyleList()->mListStyleImage.IsNone()) {
|
|
// ::marker is an image, so use default bullet character.
|
|
static const char16_t kDiscMarkerString[] = {0x2022, ' ', 0};
|
|
aText.AssignLiteral(kDiscMarkerString);
|
|
return;
|
|
}
|
|
|
|
frame->PresContext()
|
|
->FrameConstructor()
|
|
->GetContainStyleScopeManager()
|
|
.GetSpokenCounterText(frame, aText);
|
|
}
|
|
#endif
|
|
|
|
// static
|
|
nsIFrame* nsLayoutUtils::GetClosestFrameOfType(nsIFrame* aFrame,
|
|
LayoutFrameType aFrameType,
|
|
nsIFrame* aStopAt) {
|
|
for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
|
|
if (frame->Type() == aFrameType) {
|
|
return frame;
|
|
}
|
|
if (frame == aStopAt) {
|
|
break;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/* static */
|
|
nsIFrame* nsLayoutUtils::GetPageFrame(nsIFrame* aFrame) {
|
|
return GetClosestFrameOfType(aFrame, LayoutFrameType::Page);
|
|
}
|
|
|
|
/* static */
|
|
nsIFrame* nsLayoutUtils::GetStyleFrame(nsIFrame* aPrimaryFrame) {
|
|
MOZ_ASSERT(aPrimaryFrame);
|
|
if (aPrimaryFrame->IsTableWrapperFrame()) {
|
|
nsIFrame* inner = aPrimaryFrame->PrincipalChildList().FirstChild();
|
|
// inner may be null, if aPrimaryFrame is mid-destruction
|
|
return inner;
|
|
}
|
|
|
|
return aPrimaryFrame;
|
|
}
|
|
|
|
const nsIFrame* nsLayoutUtils::GetStyleFrame(const nsIFrame* aPrimaryFrame) {
|
|
return nsLayoutUtils::GetStyleFrame(const_cast<nsIFrame*>(aPrimaryFrame));
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetStyleFrame(const nsIContent* aContent) {
|
|
nsIFrame* frame = aContent->GetPrimaryFrame();
|
|
if (!frame) {
|
|
return nullptr;
|
|
}
|
|
|
|
return nsLayoutUtils::GetStyleFrame(frame);
|
|
}
|
|
|
|
CSSIntCoord nsLayoutUtils::UnthemedScrollbarSize(StyleScrollbarWidth aWidth) {
|
|
switch (aWidth) {
|
|
case StyleScrollbarWidth::Auto:
|
|
return 12;
|
|
case StyleScrollbarWidth::Thin:
|
|
return 6;
|
|
case StyleScrollbarWidth::None:
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* static */
|
|
nsIFrame* nsLayoutUtils::GetPrimaryFrameFromStyleFrame(nsIFrame* aStyleFrame) {
|
|
nsIFrame* parent = aStyleFrame->GetParent();
|
|
return parent && parent->IsTableWrapperFrame() ? parent : aStyleFrame;
|
|
}
|
|
|
|
/* static */
|
|
const nsIFrame* nsLayoutUtils::GetPrimaryFrameFromStyleFrame(
|
|
const nsIFrame* aStyleFrame) {
|
|
return nsLayoutUtils::GetPrimaryFrameFromStyleFrame(
|
|
const_cast<nsIFrame*>(aStyleFrame));
|
|
}
|
|
|
|
/*static*/
|
|
bool nsLayoutUtils::IsPrimaryStyleFrame(const nsIFrame* aFrame) {
|
|
if (aFrame->IsTableWrapperFrame()) {
|
|
return false;
|
|
}
|
|
|
|
const nsIFrame* parent = aFrame->GetParent();
|
|
if (parent && parent->IsTableWrapperFrame()) {
|
|
return parent->PrincipalChildList().FirstChild() == aFrame;
|
|
}
|
|
|
|
return aFrame->IsPrimaryFrame();
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetFloatFromPlaceholder(nsIFrame* aFrame) {
|
|
NS_ASSERTION(aFrame->IsPlaceholderFrame(), "Must have a placeholder here");
|
|
if (aFrame->HasAnyStateBits(PLACEHOLDER_FOR_FLOAT)) {
|
|
nsIFrame* outOfFlowFrame =
|
|
nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame);
|
|
NS_ASSERTION(outOfFlowFrame && outOfFlowFrame->IsFloating(),
|
|
"How did that happen?");
|
|
return outOfFlowFrame;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// static
|
|
nsIFrame* nsLayoutUtils::GetCrossDocParentFrameInProcess(
|
|
const nsIFrame* aFrame, nsPoint* aCrossDocOffset) {
|
|
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;
|
|
}
|
|
v = v->GetParent(); // subdocumentframe's view
|
|
if (!v) {
|
|
return nullptr;
|
|
}
|
|
|
|
p = v->GetFrame();
|
|
if (p && aCrossDocOffset) {
|
|
nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(p);
|
|
MOZ_ASSERT(subdocumentFrame);
|
|
*aCrossDocOffset += subdocumentFrame->GetExtraOffset();
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
// static
|
|
nsIFrame* nsLayoutUtils::GetCrossDocParentFrame(const nsIFrame* aFrame,
|
|
nsPoint* aCrossDocOffset) {
|
|
return GetCrossDocParentFrameInProcess(aFrame, aCrossDocOffset);
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::IsProperAncestorFrameCrossDoc(
|
|
const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
|
|
const nsIFrame* aCommonAncestor) {
|
|
if (aFrame == aAncestorFrame) return false;
|
|
return IsAncestorFrameCrossDoc(aAncestorFrame, aFrame, aCommonAncestor);
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::IsProperAncestorFrameCrossDocInProcess(
|
|
const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
|
|
const nsIFrame* aCommonAncestor) {
|
|
if (aFrame == aAncestorFrame) return false;
|
|
return IsAncestorFrameCrossDocInProcess(aAncestorFrame, aFrame,
|
|
aCommonAncestor);
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::IsAncestorFrameCrossDoc(const nsIFrame* aAncestorFrame,
|
|
const nsIFrame* aFrame,
|
|
const nsIFrame* aCommonAncestor) {
|
|
for (const nsIFrame* f = aFrame; f != aCommonAncestor;
|
|
f = GetCrossDocParentFrameInProcess(f)) {
|
|
if (f == aAncestorFrame) return true;
|
|
}
|
|
return aCommonAncestor == aAncestorFrame;
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::IsAncestorFrameCrossDocInProcess(
|
|
const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
|
|
const nsIFrame* aCommonAncestor) {
|
|
for (const nsIFrame* f = aFrame; f != aCommonAncestor;
|
|
f = GetCrossDocParentFrameInProcess(f)) {
|
|
if (f == aAncestorFrame) return true;
|
|
}
|
|
return aCommonAncestor == aAncestorFrame;
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::IsProperAncestorFrame(const nsIFrame* aAncestorFrame,
|
|
const nsIFrame* aFrame,
|
|
const nsIFrame* aCommonAncestor) {
|
|
if (aFrame == aAncestorFrame) return false;
|
|
for (const 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) {
|
|
MOZ_ASSERT(aIf1Ancestor == -1 || aIf1Ancestor == 0 || aIf1Ancestor == 1);
|
|
MOZ_ASSERT(aIf2Ancestor == -1 || aIf2Ancestor == 0 || aIf2Ancestor == 1);
|
|
MOZ_ASSERT(aContent1, "aContent1 must not be null");
|
|
MOZ_ASSERT(aContent2, "aContent2 must not be null");
|
|
|
|
AutoTArray<nsIContent*, 32> content1Ancestors;
|
|
nsIContent* c1;
|
|
for (c1 = aContent1; c1 && c1 != aCommonAncestor;
|
|
c1 = c1->GetFlattenedTreeParent()) {
|
|
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<nsIContent*, 32> content2Ancestors;
|
|
nsIContent* c2;
|
|
for (c2 = aContent2; c2 && c2 != aCommonAncestor;
|
|
c2 = c2->GetFlattenedTreeParent()) {
|
|
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;
|
|
nsIContent* content1Ancestor = nullptr;
|
|
nsIContent* 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
|
|
nsIContent* parent = content1Ancestor->GetFlattenedTreeParent();
|
|
#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;
|
|
}
|
|
|
|
const Maybe<uint32_t> index1 =
|
|
parent->ComputeFlatTreeIndexOf(content1Ancestor);
|
|
const Maybe<uint32_t> index2 =
|
|
parent->ComputeFlatTreeIndexOf(content2Ancestor);
|
|
|
|
// None of the nodes are anonymous, just do a regular comparison.
|
|
if (index1.isSome() && index2.isSome()) {
|
|
return static_cast<int32_t>(static_cast<int64_t>(*index1) - *index2);
|
|
}
|
|
|
|
// Otherwise handle pseudo-element and anonymous content ordering.
|
|
//
|
|
// ::marker -> ::before -> anon siblings -> regular siblings -> ::after
|
|
auto PseudoIndex = [](const nsINode* aNode,
|
|
const Maybe<uint32_t>& aNodeIndex) -> int32_t {
|
|
if (aNodeIndex.isSome()) {
|
|
return 1; // Not a pseudo.
|
|
}
|
|
if (aNode->IsContent()) {
|
|
if (aNode->AsContent()->IsGeneratedContentContainerForMarker()) {
|
|
return -2;
|
|
}
|
|
if (aNode->AsContent()->IsGeneratedContentContainerForBefore()) {
|
|
return -1;
|
|
}
|
|
if (aNode->AsContent()->IsGeneratedContentContainerForAfter()) {
|
|
return 2;
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
return PseudoIndex(content1Ancestor, index1) -
|
|
PseudoIndex(content2Ancestor, 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) {
|
|
MOZ_ASSERT(aIf1Ancestor == -1 || aIf1Ancestor == 0 || aIf1Ancestor == 1);
|
|
MOZ_ASSERT(aIf2Ancestor == -1 || aIf2Ancestor == 0 || aIf2Ancestor == 1);
|
|
MOZ_ASSERT(aFrame1, "aFrame1 must not be null");
|
|
MOZ_ASSERT(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) {
|
|
MOZ_ASSERT(aIf1Ancestor == -1 || aIf1Ancestor == 0 || aIf1Ancestor == 1);
|
|
MOZ_ASSERT(aIf2Ancestor == -1 || aIf2Ancestor == 0 || aIf2Ancestor == 1);
|
|
MOZ_ASSERT(aFrame1, "aFrame1 must not be null");
|
|
MOZ_ASSERT(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 */
|
|
SideBits nsLayoutUtils::GetSideBitsForFixedPositionContent(
|
|
const nsIFrame* aFixedPosFrame) {
|
|
SideBits sides = SideBits::eNone;
|
|
if (aFixedPosFrame) {
|
|
const nsStylePosition* position = aFixedPosFrame->StylePosition();
|
|
if (!position->mOffset.Get(eSideRight).IsAuto()) {
|
|
sides |= SideBits::eRight;
|
|
}
|
|
if (!position->mOffset.Get(eSideLeft).IsAuto()) {
|
|
sides |= SideBits::eLeft;
|
|
}
|
|
if (!position->mOffset.Get(eSideBottom).IsAuto()) {
|
|
sides |= SideBits::eBottom;
|
|
}
|
|
if (!position->mOffset.Get(eSideTop).IsAuto()) {
|
|
sides |= SideBits::eTop;
|
|
}
|
|
}
|
|
return sides;
|
|
}
|
|
|
|
ScrollableLayerGuid::ViewID nsLayoutUtils::ScrollIdForRootScrollFrame(
|
|
nsPresContext* aPresContext) {
|
|
ViewID id = ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
if (nsIFrame* rootScrollFrame =
|
|
aPresContext->PresShell()->GetRootScrollFrame()) {
|
|
if (nsIContent* content = rootScrollFrame->GetContent()) {
|
|
id = FindOrCreateIDFor(content);
|
|
}
|
|
}
|
|
return id;
|
|
}
|
|
|
|
// static
|
|
nsIScrollableFrame* nsLayoutUtils::GetNearestScrollableFrameForDirection(
|
|
nsIFrame* aFrame, ScrollDirections aDirections) {
|
|
NS_ASSERTION(
|
|
aFrame, "GetNearestScrollableFrameForDirection expects a non-null frame");
|
|
// FIXME Bug 1714720 : This nearest scroll target is not going to work over
|
|
// process boundaries, in such cases we need to hand over in APZ side.
|
|
for (nsIFrame* f = aFrame; f;
|
|
f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) {
|
|
nsIScrollableFrame* scrollableFrame = do_QueryFrame(f);
|
|
if (scrollableFrame) {
|
|
ScrollDirections directions =
|
|
scrollableFrame->GetAvailableScrollingDirectionsForUserInputEvents();
|
|
if (aDirections.contains(ScrollDirection::eVertical)) {
|
|
if (directions.contains(ScrollDirection::eVertical)) {
|
|
return scrollableFrame;
|
|
}
|
|
}
|
|
if (aDirections.contains(ScrollDirection::eHorizontal)) {
|
|
if (directions.contains(ScrollDirection::eHorizontal)) {
|
|
return scrollableFrame;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static nsIFrame* GetNearestScrollableOrOverflowClipFrame(
|
|
nsIFrame* aFrame, uint32_t aFlags,
|
|
const std::function<bool(const nsIFrame* aCurrentFrame)>& aClipFrameCheck =
|
|
nullptr) {
|
|
MOZ_ASSERT(
|
|
aFrame,
|
|
"GetNearestScrollableOrOverflowClipFrame expects a non-null frame");
|
|
|
|
auto GetNextFrame = [aFlags](const nsIFrame* aFrame) -> nsIFrame* {
|
|
return (aFlags & nsLayoutUtils::SCROLLABLE_SAME_DOC)
|
|
? aFrame->GetParent()
|
|
: nsLayoutUtils::GetCrossDocParentFrameInProcess(aFrame);
|
|
};
|
|
|
|
for (nsIFrame* f = aFrame; f; f = GetNextFrame(f)) {
|
|
if (aClipFrameCheck && aClipFrameCheck(f)) {
|
|
return f;
|
|
}
|
|
|
|
if ((aFlags & nsLayoutUtils::SCROLLABLE_STOP_AT_PAGE) && f->IsPageFrame()) {
|
|
break;
|
|
}
|
|
if (nsIScrollableFrame* scrollableFrame = do_QueryFrame(f)) {
|
|
if (aFlags & nsLayoutUtils::SCROLLABLE_ONLY_ASYNC_SCROLLABLE) {
|
|
if (scrollableFrame->WantAsyncScroll()) {
|
|
return f;
|
|
}
|
|
} else {
|
|
ScrollStyles ss = scrollableFrame->GetScrollStyles();
|
|
if ((aFlags & nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN) ||
|
|
ss.mVertical != StyleOverflow::Hidden ||
|
|
ss.mHorizontal != StyleOverflow::Hidden) {
|
|
return f;
|
|
}
|
|
}
|
|
if (aFlags & nsLayoutUtils::SCROLLABLE_ALWAYS_MATCH_ROOT) {
|
|
PresShell* presShell = f->PresShell();
|
|
if (presShell->GetRootScrollFrame() == f && presShell->GetDocument() &&
|
|
presShell->GetDocument()->IsRootDisplayDocument()) {
|
|
return f;
|
|
}
|
|
}
|
|
}
|
|
if ((aFlags & nsLayoutUtils::SCROLLABLE_FIXEDPOS_FINDS_ROOT) &&
|
|
f->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
|
|
nsLayoutUtils::IsReallyFixedPos(f)) {
|
|
return f->PresShell()->GetRootScrollFrame();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// static
|
|
nsIScrollableFrame* nsLayoutUtils::GetNearestScrollableFrame(nsIFrame* aFrame,
|
|
uint32_t aFlags) {
|
|
nsIFrame* found = GetNearestScrollableOrOverflowClipFrame(aFrame, aFlags);
|
|
if (!found) {
|
|
return nullptr;
|
|
}
|
|
|
|
return do_QueryFrame(found);
|
|
}
|
|
|
|
// static
|
|
nsIFrame* nsLayoutUtils::GetNearestOverflowClipFrame(nsIFrame* aFrame) {
|
|
return GetNearestScrollableOrOverflowClipFrame(
|
|
aFrame, SCROLLABLE_SAME_DOC | SCROLLABLE_INCLUDE_HIDDEN,
|
|
[](const nsIFrame* currentFrame) -> bool {
|
|
// In cases of SVG Inner/Outer frames it basically clips descendants
|
|
// unless overflow: visible is explicitly specified.
|
|
LayoutFrameType type = currentFrame->Type();
|
|
return ((type == LayoutFrameType::SVGOuterSVG ||
|
|
type == LayoutFrameType::SVGInnerSVG) &&
|
|
(currentFrame->StyleDisplay()->mOverflowX !=
|
|
StyleOverflow::Visible &&
|
|
currentFrame->StyleDisplay()->mOverflowY !=
|
|
StyleOverflow::Visible));
|
|
});
|
|
}
|
|
|
|
// static
|
|
nsRect nsLayoutUtils::GetScrolledRect(nsIFrame* aScrolledFrame,
|
|
const nsRect& aScrolledFrameOverflowArea,
|
|
const nsSize& aScrollPortSize,
|
|
StyleDirection aDirection) {
|
|
WritingMode wm = aScrolledFrame->GetWritingMode();
|
|
// Potentially override the frame's direction to use the direction found
|
|
// by nsHTMLScrollFrame::GetScrolledFrameDir()
|
|
wm.SetDirectionFromBidiLevel(aDirection == StyleDirection::Rtl
|
|
? mozilla::intl::BidiEmbeddingLevel::RTL()
|
|
: mozilla::intl::BidiEmbeddingLevel::LTR());
|
|
|
|
nscoord x1 = aScrolledFrameOverflowArea.x,
|
|
x2 = aScrolledFrameOverflowArea.XMost(),
|
|
y1 = aScrolledFrameOverflowArea.y,
|
|
y2 = aScrolledFrameOverflowArea.YMost();
|
|
|
|
const bool isHorizontalWM = !wm.IsVertical();
|
|
const bool isVerticalWM = wm.IsVertical();
|
|
bool isInlineFlowFromTopOrLeft = !wm.IsInlineReversed();
|
|
bool isBlockFlowFromTopOrLeft = isHorizontalWM || wm.IsVerticalLR();
|
|
|
|
if (aScrolledFrame->IsFlexContainerFrame()) {
|
|
// In a flex container, the children flow (and overflow) along the flex
|
|
// container's main axis and cross axis. These are analogous to the
|
|
// inline/block axes, and by default they correspond exactly to those axes;
|
|
// but the flex container's CSS (e.g. flex-direction: column-reverse) may
|
|
// have swapped and/or reversed them, and we need to account for that here.
|
|
FlexboxAxisInfo info(aScrolledFrame);
|
|
if (info.mIsRowOriented) {
|
|
// The flex container's inline axis is the main axis.
|
|
isInlineFlowFromTopOrLeft =
|
|
isInlineFlowFromTopOrLeft == !info.mIsMainAxisReversed;
|
|
isBlockFlowFromTopOrLeft =
|
|
isBlockFlowFromTopOrLeft == !info.mIsCrossAxisReversed;
|
|
} else {
|
|
// The flex container's block axis is the main axis.
|
|
isBlockFlowFromTopOrLeft =
|
|
isBlockFlowFromTopOrLeft == !info.mIsMainAxisReversed;
|
|
isInlineFlowFromTopOrLeft =
|
|
isInlineFlowFromTopOrLeft == !info.mIsCrossAxisReversed;
|
|
}
|
|
}
|
|
|
|
// Clamp the horizontal start-edge (x1 or x2, depending whether the logical
|
|
// axis that corresponds to horizontal progresses from left-to-right or
|
|
// right-to-left).
|
|
if ((isHorizontalWM && isInlineFlowFromTopOrLeft) ||
|
|
(isVerticalWM && isBlockFlowFromTopOrLeft)) {
|
|
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 (y1 or y2, depending whether the
|
|
// logical axis that corresponds to vertical progresses from top-to-bottom or
|
|
// buttom-to-top).
|
|
if ((isHorizontalWM && isBlockFlowFromTopOrLeft) ||
|
|
(isVerticalWM && isInlineFlowFromTopOrLeft)) {
|
|
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,
|
|
ComputedStyle* aComputedStyle,
|
|
PseudoStyleType aPseudoElement,
|
|
nsPresContext* aPresContext) {
|
|
MOZ_ASSERT(aPresContext, "Must have a prescontext");
|
|
|
|
RefPtr<ComputedStyle> pseudoContext;
|
|
if (aContent) {
|
|
pseudoContext = aPresContext->StyleSet()->ProbePseudoElementStyle(
|
|
*aContent->AsElement(), aPseudoElement, nullptr, aComputedStyle);
|
|
}
|
|
return pseudoContext != nullptr;
|
|
}
|
|
|
|
nsPoint nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(Event* 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, RelativeTo{aFrame});
|
|
}
|
|
|
|
static bool IsValidCoordinateTypeEvent(const WidgetEvent* aEvent) {
|
|
if (!aEvent) {
|
|
return false;
|
|
}
|
|
return 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;
|
|
}
|
|
|
|
nsPoint nsLayoutUtils::GetEventCoordinatesRelativeTo(const WidgetEvent* aEvent,
|
|
RelativeTo aFrame) {
|
|
if (!IsValidCoordinateTypeEvent(aEvent)) {
|
|
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
|
|
}
|
|
|
|
return GetEventCoordinatesRelativeTo(aEvent, aEvent->AsGUIEvent()->mRefPoint,
|
|
aFrame);
|
|
}
|
|
|
|
nsPoint nsLayoutUtils::GetEventCoordinatesRelativeTo(
|
|
const WidgetEvent* aEvent, const LayoutDeviceIntPoint& aPoint,
|
|
RelativeTo aFrame) {
|
|
if (!aFrame.mFrame) {
|
|
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 GetEventCoordinatesRelativeTo(nsIWidget* aWidget,
|
|
const LayoutDeviceIntPoint& aPoint,
|
|
RelativeTo aFrame) {
|
|
const nsIFrame* frame = aFrame.mFrame;
|
|
if (!frame || !aWidget) {
|
|
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
|
|
}
|
|
|
|
nsView* view = frame->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 = frame->PresContext();
|
|
nsPoint pt(presContext->DevPixelsToAppUnits(aPoint.x),
|
|
presContext->DevPixelsToAppUnits(aPoint.y));
|
|
return pt - view->ViewToWidgetOffset();
|
|
}
|
|
}
|
|
|
|
/* 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.
|
|
*/
|
|
const nsIFrame* rootFrame = frame;
|
|
bool transformFound = false;
|
|
for (const nsIFrame* f = frame; f;
|
|
f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) {
|
|
if (f->IsTransformed() || ViewportUtils::IsZoomedContentRoot(f)) {
|
|
transformFound = true;
|
|
}
|
|
|
|
rootFrame = f;
|
|
}
|
|
|
|
nsView* rootView = rootFrame->GetView();
|
|
if (!rootView) {
|
|
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
|
|
}
|
|
|
|
nsPoint widgetToView = nsLayoutUtils::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 = frame->PresContext()->AppUnitsPerDevPixel();
|
|
widgetToView = widgetToView.ScaleToOtherAppUnits(rootAPD, localAPD);
|
|
|
|
/* 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 || frame->IsInSVGTextSubtree()) {
|
|
return nsLayoutUtils::TransformRootPointToFrame(ViewportType::Visual,
|
|
aFrame, widgetToView);
|
|
}
|
|
|
|
/* Otherwise, all coordinate systems are translations of one another,
|
|
* so we can just subtract out the difference.
|
|
*/
|
|
return widgetToView - frame->GetOffsetToCrossDoc(rootFrame);
|
|
}
|
|
|
|
nsPoint nsLayoutUtils::GetEventCoordinatesRelativeTo(
|
|
nsIWidget* aWidget, const LayoutDeviceIntPoint& aPoint, RelativeTo aFrame) {
|
|
nsPoint result = ::GetEventCoordinatesRelativeTo(aWidget, aPoint, aFrame);
|
|
if (aFrame.mViewportType == ViewportType::Layout && aFrame.mFrame &&
|
|
aFrame.mFrame->Type() == LayoutFrameType::Viewport &&
|
|
aFrame.mFrame->PresContext()->IsRootContentDocumentCrossProcess()) {
|
|
result = ViewportUtils::VisualToLayout(result, aFrame.mFrame->PresShell());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetPopupFrameForEventCoordinates(
|
|
nsPresContext* aRootPresContext, const WidgetEvent* aEvent) {
|
|
if (!IsValidCoordinateTypeEvent(aEvent)) {
|
|
return nullptr;
|
|
}
|
|
|
|
const auto* guiEvent = aEvent->AsGUIEvent();
|
|
return GetPopupFrameForPoint(aRootPresContext, guiEvent->mWidget,
|
|
guiEvent->mRefPoint);
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetPopupFrameForPoint(
|
|
nsPresContext* aRootPresContext, nsIWidget* aWidget,
|
|
const mozilla::LayoutDeviceIntPoint& aPoint,
|
|
GetPopupFrameForPointFlags aFlags /* = GetPopupFrameForPointFlags(0) */) {
|
|
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
|
|
if (!pm) {
|
|
return nullptr;
|
|
}
|
|
nsTArray<nsIFrame*> popups;
|
|
pm->GetVisiblePopups(popups);
|
|
// Search from top to bottom
|
|
for (nsIFrame* popup : popups) {
|
|
if (popup->PresContext()->GetRootPresContext() != aRootPresContext) {
|
|
continue;
|
|
}
|
|
if (!popup->ScrollableOverflowRect().Contains(GetEventCoordinatesRelativeTo(
|
|
aWidget, aPoint, RelativeTo{popup}))) {
|
|
continue;
|
|
}
|
|
if (aFlags & GetPopupFrameForPointFlags::OnlyReturnFramesWithWidgets) {
|
|
if (!popup->HasView() || !popup->GetView()->HasWidget()) {
|
|
continue;
|
|
}
|
|
}
|
|
return popup;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void nsLayoutUtils::GetContainerAndOffsetAtEvent(PresShell* aPresShell,
|
|
const WidgetEvent* aEvent,
|
|
nsIContent** aContainer,
|
|
int32_t* aOffset) {
|
|
MOZ_ASSERT(aContainer || aOffset);
|
|
|
|
if (aContainer) {
|
|
*aContainer = nullptr;
|
|
}
|
|
if (aOffset) {
|
|
*aOffset = 0;
|
|
}
|
|
|
|
if (!aPresShell) {
|
|
return;
|
|
}
|
|
|
|
aPresShell->FlushPendingNotifications(FlushType::Layout);
|
|
|
|
RefPtr<nsPresContext> presContext = aPresShell->GetPresContext();
|
|
if (!presContext) {
|
|
return;
|
|
}
|
|
|
|
nsIFrame* targetFrame = presContext->EventStateManager()->GetEventTarget();
|
|
if (!targetFrame) {
|
|
return;
|
|
}
|
|
|
|
WidgetEvent* openingEvent = nullptr;
|
|
// For popupshowing events, redirect via the original mouse event
|
|
// that triggered the popup to open.
|
|
if (aEvent->mMessage == eXULPopupShowing) {
|
|
if (auto* pm = nsXULPopupManager::GetInstance()) {
|
|
if (Event* openingPopupEvent = pm->GetOpeningPopupEvent()) {
|
|
openingEvent = openingPopupEvent->WidgetEventPtr();
|
|
}
|
|
}
|
|
}
|
|
|
|
nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
|
|
openingEvent ? openingEvent : aEvent, RelativeTo{targetFrame});
|
|
|
|
if (aContainer) {
|
|
// TODO: This result may be useful to change to Selection. However, this
|
|
// may return improper node (e.g., native anonymous node) for the
|
|
// Selection. Perhaps, this should take Selection optionally and
|
|
// if it's specified, needs to check if it's proper for the
|
|
// Selection.
|
|
nsCOMPtr<nsIContent> container =
|
|
targetFrame->GetContentOffsetsFromPoint(point).content;
|
|
if (container && (!container->ChromeOnlyAccess() ||
|
|
nsContentUtils::CanAccessNativeAnon())) {
|
|
container.forget(aContainer);
|
|
}
|
|
}
|
|
if (aOffset) {
|
|
*aOffset = targetFrame->GetContentOffsetsFromPoint(point).offset;
|
|
}
|
|
}
|
|
|
|
void nsLayoutUtils::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 (MOZ_UNLIKELY(std::isnan(aSize))) {
|
|
// Can happen if aStart is -inf and aSize is +inf for example.
|
|
aStart = 0.0f;
|
|
aSize = float(nscoord_MAX);
|
|
} else if (aSize > float(nscoord_MAX)) {
|
|
float excess = aSize - float(nscoord_MAX);
|
|
excess /= 2;
|
|
aStart += excess;
|
|
aSize = float(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;
|
|
}
|
|
|
|
void nsLayoutUtils::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 (MOZ_UNLIKELY(std::isnan(aSize))) {
|
|
// Can happen if aStart is -inf and aSize is +inf for example.
|
|
aStart = 0.0f;
|
|
aSize = nscoord_MAX;
|
|
} else 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;
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
nsRect nsLayoutUtils::MatrixTransformRect(const nsRect& aBounds,
|
|
const Matrix4x4Flagged& 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 = aMatrix.TransformPoint(image);
|
|
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);
|
|
}
|
|
|
|
bool nsLayoutUtils::ShouldSnapToGrid(const nsIFrame* aFrame) {
|
|
return !aFrame || !aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT) ||
|
|
aFrame->IsSVGOuterSVGAnonChildFrame();
|
|
}
|
|
|
|
Matrix4x4Flagged nsLayoutUtils::GetTransformToAncestor(
|
|
RelativeTo aFrame, RelativeTo aAncestor, uint32_t aFlags,
|
|
nsIFrame** aOutAncestor) {
|
|
nsIFrame* parent;
|
|
Matrix4x4Flagged ctm;
|
|
// Make sure we don't get an invalid combination of source and destination
|
|
// RelativeTo values.
|
|
MOZ_ASSERT(!(aFrame.mViewportType == ViewportType::Visual &&
|
|
aAncestor.mViewportType == ViewportType::Layout));
|
|
if (aFrame == aAncestor) {
|
|
return ctm;
|
|
}
|
|
ctm = aFrame.mFrame->GetTransformMatrix(aFrame.mViewportType, aAncestor,
|
|
&parent, aFlags);
|
|
if (!aFrame.mFrame->Combines3DTransformWithAncestors()) {
|
|
ctm.ProjectTo2D();
|
|
}
|
|
while (parent && parent != aAncestor.mFrame &&
|
|
(!(aFlags & nsIFrame::STOP_AT_STACKING_CONTEXT_AND_DISPLAY_PORT) ||
|
|
(!parent->IsStackingContext() &&
|
|
!DisplayPortUtils::FrameHasDisplayPort(parent)))) {
|
|
nsIFrame* cur = parent;
|
|
ctm = ctm * cur->GetTransformMatrix(aFrame.mViewportType, aAncestor,
|
|
&parent, aFlags);
|
|
if (!cur->Combines3DTransformWithAncestors()) {
|
|
ctm.ProjectTo2D();
|
|
}
|
|
}
|
|
if (aOutAncestor) {
|
|
*aOutAncestor = parent;
|
|
}
|
|
return ctm;
|
|
}
|
|
|
|
MatrixScales nsLayoutUtils::GetTransformToAncestorScale(
|
|
const nsIFrame* aFrame) {
|
|
Matrix4x4Flagged transform = GetTransformToAncestor(
|
|
RelativeTo{aFrame},
|
|
RelativeTo{nsLayoutUtils::GetDisplayRootFrame(aFrame)});
|
|
Matrix transform2D;
|
|
if (transform.CanDraw2D(&transform2D)) {
|
|
return ThebesMatrix(transform2D).ScaleFactors().ConvertTo<float>();
|
|
}
|
|
return MatrixScales();
|
|
}
|
|
|
|
static Matrix4x4Flagged GetTransformToAncestorExcludingAnimated(
|
|
nsIFrame* aFrame, const nsIFrame* aAncestor) {
|
|
nsIFrame* parent;
|
|
Matrix4x4Flagged ctm;
|
|
if (aFrame == aAncestor) {
|
|
return ctm;
|
|
}
|
|
if (ActiveLayerTracker::IsScaleSubjectToAnimation(aFrame)) {
|
|
return ctm;
|
|
}
|
|
ctm = aFrame->GetTransformMatrix(ViewportType::Layout, RelativeTo{aAncestor},
|
|
&parent);
|
|
while (parent && parent != aAncestor) {
|
|
if (ActiveLayerTracker::IsScaleSubjectToAnimation(parent)) {
|
|
return Matrix4x4Flagged();
|
|
}
|
|
if (!parent->Extend3DContext()) {
|
|
ctm.ProjectTo2D();
|
|
}
|
|
ctm = ctm * parent->GetTransformMatrix(ViewportType::Layout,
|
|
RelativeTo{aAncestor}, &parent);
|
|
}
|
|
return ctm;
|
|
}
|
|
|
|
MatrixScales nsLayoutUtils::GetTransformToAncestorScaleExcludingAnimated(
|
|
nsIFrame* aFrame) {
|
|
Matrix4x4Flagged transform = GetTransformToAncestorExcludingAnimated(
|
|
aFrame, nsLayoutUtils::GetDisplayRootFrame(aFrame));
|
|
Matrix transform2D;
|
|
if (transform.Is2D(&transform2D)) {
|
|
return ThebesMatrix(transform2D).ScaleFactors().ConvertTo<float>();
|
|
}
|
|
return MatrixScales();
|
|
}
|
|
|
|
const nsIFrame* nsLayoutUtils::FindNearestCommonAncestorFrame(
|
|
const nsIFrame* aFrame1, const nsIFrame* aFrame2) {
|
|
AutoTArray<const nsIFrame*, 100> ancestors1;
|
|
AutoTArray<const nsIFrame*, 100> ancestors2;
|
|
const nsIFrame* commonAncestor = nullptr;
|
|
if (aFrame1->PresContext() == aFrame2->PresContext()) {
|
|
commonAncestor = aFrame1->PresShell()->GetRootFrame();
|
|
}
|
|
for (const nsIFrame* f = aFrame1; f != commonAncestor;
|
|
f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) {
|
|
ancestors1.AppendElement(f);
|
|
}
|
|
for (const nsIFrame* f = aFrame2; f != commonAncestor;
|
|
f = nsLayoutUtils::GetCrossDocParentFrameInProcess(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;
|
|
}
|
|
|
|
const nsIFrame* nsLayoutUtils::FindNearestCommonAncestorFrameWithinBlock(
|
|
const nsTextFrame* aFrame1, const nsTextFrame* aFrame2) {
|
|
MOZ_ASSERT(aFrame1);
|
|
MOZ_ASSERT(aFrame2);
|
|
|
|
const nsIFrame* f1 = aFrame1;
|
|
const nsIFrame* f2 = aFrame2;
|
|
|
|
int n1 = 1;
|
|
int n2 = 1;
|
|
|
|
for (auto f = f1->GetParent();;) {
|
|
NS_ASSERTION(f, "All text frames should have a block ancestor");
|
|
if (!f) {
|
|
return nullptr;
|
|
}
|
|
if (f->IsBlockFrameOrSubclass()) {
|
|
break;
|
|
}
|
|
++n1;
|
|
f = f->GetParent();
|
|
}
|
|
|
|
for (auto f = f2->GetParent();;) {
|
|
NS_ASSERTION(f, "All text frames should have a block ancestor");
|
|
if (!f) {
|
|
return nullptr;
|
|
}
|
|
if (f->IsBlockFrameOrSubclass()) {
|
|
break;
|
|
}
|
|
++n2;
|
|
f = f->GetParent();
|
|
}
|
|
|
|
if (n1 > n2) {
|
|
std::swap(n1, n2);
|
|
std::swap(f1, f2);
|
|
}
|
|
|
|
while (n2 > n1) {
|
|
f2 = f2->GetParent();
|
|
--n2;
|
|
}
|
|
|
|
while (n2 >= 0) {
|
|
if (f1 == f2) {
|
|
return f1;
|
|
}
|
|
f1 = f1->GetParent();
|
|
f2 = f2->GetParent();
|
|
--n2;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool nsLayoutUtils::AuthorSpecifiedBorderBackgroundDisablesTheming(
|
|
StyleAppearance aAppearance) {
|
|
return aAppearance == StyleAppearance::NumberInput ||
|
|
aAppearance == StyleAppearance::Button ||
|
|
aAppearance == StyleAppearance::Textfield ||
|
|
aAppearance == StyleAppearance::Textarea ||
|
|
aAppearance == StyleAppearance::Listbox ||
|
|
aAppearance == StyleAppearance::Menulist ||
|
|
aAppearance == StyleAppearance::MenulistButton;
|
|
}
|
|
|
|
static SVGTextFrame* GetContainingSVGTextFrame(const nsIFrame* aFrame) {
|
|
if (!aFrame->IsInSVGTextSubtree()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return static_cast<SVGTextFrame*>(nsLayoutUtils::GetClosestFrameOfType(
|
|
aFrame->GetParent(), LayoutFrameType::SVGText));
|
|
}
|
|
|
|
static bool TransformGfxPointFromAncestor(RelativeTo aFrame,
|
|
const Point& aPoint,
|
|
RelativeTo aAncestor,
|
|
Maybe<Matrix4x4Flagged>& aMatrixCache,
|
|
Point* aOut) {
|
|
SVGTextFrame* text = GetContainingSVGTextFrame(aFrame.mFrame);
|
|
|
|
if (!aMatrixCache) {
|
|
auto matrix = nsLayoutUtils::GetTransformToAncestor(
|
|
RelativeTo{text ? text : aFrame.mFrame, aFrame.mViewportType},
|
|
aAncestor);
|
|
if (matrix.IsSingular()) {
|
|
return false;
|
|
}
|
|
matrix.Invert();
|
|
aMatrixCache.emplace(matrix);
|
|
}
|
|
|
|
const Matrix4x4Flagged& ctm = *aMatrixCache;
|
|
Point4D point = ctm.ProjectPoint(aPoint);
|
|
if (!point.HasPositiveWCoord()) {
|
|
return false;
|
|
}
|
|
|
|
*aOut = point.As2DPoint();
|
|
|
|
if (text) {
|
|
*aOut = text->TransformFramePointToTextChild(*aOut, aFrame.mFrame);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static Point TransformGfxPointToAncestor(
|
|
RelativeTo aFrame, const Point& aPoint, RelativeTo aAncestor,
|
|
Maybe<Matrix4x4Flagged>& aMatrixCache) {
|
|
if (SVGTextFrame* text = GetContainingSVGTextFrame(aFrame.mFrame)) {
|
|
Point result =
|
|
text->TransformFramePointFromTextChild(aPoint, aFrame.mFrame);
|
|
return TransformGfxPointToAncestor(RelativeTo{text}, result, aAncestor,
|
|
aMatrixCache);
|
|
}
|
|
if (!aMatrixCache) {
|
|
aMatrixCache.emplace(
|
|
nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor));
|
|
}
|
|
return aMatrixCache->ProjectPoint(aPoint).As2DPoint();
|
|
}
|
|
|
|
static Rect TransformGfxRectToAncestor(
|
|
RelativeTo aFrame, const Rect& aRect, RelativeTo aAncestor,
|
|
bool* aPreservesAxisAlignedRectangles = nullptr,
|
|
Maybe<Matrix4x4Flagged>* aMatrixCache = nullptr,
|
|
bool aStopAtStackingContextAndDisplayPortAndOOFFrame = false,
|
|
nsIFrame** aOutAncestor = nullptr) {
|
|
Rect result;
|
|
Matrix4x4Flagged ctm;
|
|
if (SVGTextFrame* text = GetContainingSVGTextFrame(aFrame.mFrame)) {
|
|
result = text->TransformFrameRectFromTextChild(aRect, aFrame.mFrame);
|
|
|
|
result = TransformGfxRectToAncestor(
|
|
RelativeTo{text}, result, aAncestor, nullptr, aMatrixCache,
|
|
aStopAtStackingContextAndDisplayPortAndOOFFrame, aOutAncestor);
|
|
if (aPreservesAxisAlignedRectangles) {
|
|
// 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.
|
|
*aPreservesAxisAlignedRectangles = false;
|
|
}
|
|
return result;
|
|
}
|
|
if (aMatrixCache && *aMatrixCache) {
|
|
// We are given a matrix to use, so use it
|
|
ctm = aMatrixCache->value();
|
|
} else {
|
|
// Else, compute it
|
|
uint32_t flags = 0;
|
|
if (aStopAtStackingContextAndDisplayPortAndOOFFrame) {
|
|
flags |= nsIFrame::STOP_AT_STACKING_CONTEXT_AND_DISPLAY_PORT;
|
|
}
|
|
ctm = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor, flags,
|
|
aOutAncestor);
|
|
if (aMatrixCache) {
|
|
// and put it in the cache, if provided
|
|
*aMatrixCache = Some(ctm);
|
|
}
|
|
}
|
|
// Fill out the axis-alignment flag
|
|
if (aPreservesAxisAlignedRectangles) {
|
|
// 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.
|
|
Matrix matrix2d;
|
|
*aPreservesAxisAlignedRectangles =
|
|
ctm.Is2D(&matrix2d) && matrix2d.PreservesAxisAlignedRectangles();
|
|
}
|
|
const nsIFrame* ancestor = aOutAncestor ? *aOutAncestor : aAncestor.mFrame;
|
|
float factor = ancestor->PresContext()->AppUnitsPerDevPixel();
|
|
Rect maxBounds =
|
|
Rect(float(nscoord_MIN) / factor * 0.5, float(nscoord_MIN) / factor * 0.5,
|
|
float(nscoord_MAX) / factor, float(nscoord_MAX) / factor);
|
|
return ctm.TransformAndClipBounds(aRect, maxBounds);
|
|
}
|
|
|
|
nsLayoutUtils::TransformResult nsLayoutUtils::TransformPoints(
|
|
RelativeTo aFromFrame, RelativeTo aToFrame, uint32_t aPointCount,
|
|
CSSPoint* aPoints) {
|
|
// Conceptually, {ViewportFrame, Visual} is an ancestor of
|
|
// {ViewportFrame, Layout}, so factor that into the nearest ancestor
|
|
// computation.
|
|
RelativeTo nearestCommonAncestor{
|
|
FindNearestCommonAncestorFrame(aFromFrame.mFrame, aToFrame.mFrame),
|
|
aFromFrame.mViewportType == ViewportType::Visual ||
|
|
aToFrame.mViewportType == ViewportType::Visual
|
|
? ViewportType::Visual
|
|
: ViewportType::Layout};
|
|
if (!nearestCommonAncestor.mFrame) {
|
|
return NO_COMMON_ANCESTOR;
|
|
}
|
|
CSSToLayoutDeviceScale devPixelsPerCSSPixelFromFrame =
|
|
aFromFrame.mFrame->PresContext()->CSSToDevPixelScale();
|
|
CSSToLayoutDeviceScale devPixelsPerCSSPixelToFrame =
|
|
aToFrame.mFrame->PresContext()->CSSToDevPixelScale();
|
|
Maybe<Matrix4x4Flagged> cacheTo;
|
|
Maybe<Matrix4x4Flagged> cacheFrom;
|
|
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 =
|
|
TransformGfxPointToAncestor(aFromFrame, Point(devPixels.x, devPixels.y),
|
|
nearestCommonAncestor, cacheTo);
|
|
Point result;
|
|
if (!TransformGfxPointFromAncestor(
|
|
aToFrame, toDevPixels, nearestCommonAncestor, cacheFrom, &result)) {
|
|
return NONINVERTIBLE_TRANSFORM;
|
|
}
|
|
// 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(result.x, result.y) / devPixelsPerCSSPixelToFrame;
|
|
}
|
|
return TRANSFORM_SUCCEEDED;
|
|
}
|
|
|
|
nsLayoutUtils::TransformResult nsLayoutUtils::TransformPoint(
|
|
RelativeTo aFromFrame, RelativeTo aToFrame, nsPoint& aPoint) {
|
|
CSSPoint point = CSSPoint::FromAppUnits(aPoint);
|
|
auto result = TransformPoints(aFromFrame, aToFrame, 1, &point);
|
|
if (result == TRANSFORM_SUCCEEDED) {
|
|
aPoint = CSSPoint::ToAppUnits(point);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
nsLayoutUtils::TransformResult nsLayoutUtils::TransformRect(
|
|
const nsIFrame* aFromFrame, const nsIFrame* aToFrame, nsRect& aRect) {
|
|
const nsIFrame* nearestCommonAncestor =
|
|
FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
|
|
if (!nearestCommonAncestor) {
|
|
return NO_COMMON_ANCESTOR;
|
|
}
|
|
Matrix4x4Flagged downToDest = GetTransformToAncestor(
|
|
RelativeTo{aToFrame}, RelativeTo{nearestCommonAncestor});
|
|
if (downToDest.IsSingular()) {
|
|
return NONINVERTIBLE_TRANSFORM;
|
|
}
|
|
downToDest.Invert();
|
|
aRect = TransformFrameRectToAncestor(aFromFrame, aRect,
|
|
RelativeTo{nearestCommonAncestor});
|
|
|
|
float devPixelsPerAppUnitFromFrame =
|
|
1.0f / nearestCommonAncestor->PresContext()->AppUnitsPerDevPixel();
|
|
float devPixelsPerAppUnitToFrame =
|
|
1.0f / aToFrame->PresContext()->AppUnitsPerDevPixel();
|
|
gfx::Rect toDevPixels = downToDest.ProjectRectBounds(
|
|
gfx::Rect(aRect.x * devPixelsPerAppUnitFromFrame,
|
|
aRect.y * devPixelsPerAppUnitFromFrame,
|
|
aRect.width * devPixelsPerAppUnitFromFrame,
|
|
aRect.height * devPixelsPerAppUnitFromFrame),
|
|
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 = NSToCoordRoundWithClamp(toDevPixels.x / devPixelsPerAppUnitToFrame);
|
|
aRect.y = NSToCoordRoundWithClamp(toDevPixels.y / devPixelsPerAppUnitToFrame);
|
|
aRect.width =
|
|
NSToCoordRoundWithClamp(toDevPixels.width / devPixelsPerAppUnitToFrame);
|
|
aRect.height =
|
|
NSToCoordRoundWithClamp(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, LayoutFrameType::Scroll);
|
|
|
|
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(), LayoutFrameType::Scroll);
|
|
}
|
|
|
|
return resultRect;
|
|
}
|
|
|
|
nsPoint nsLayoutUtils::TransformAncestorPointToFrame(RelativeTo aFrame,
|
|
const nsPoint& aPoint,
|
|
RelativeTo aAncestor) {
|
|
float factor = aFrame.mFrame->PresContext()->AppUnitsPerDevPixel();
|
|
Point result(NSAppUnitsToFloatPixels(aPoint.x, factor),
|
|
NSAppUnitsToFloatPixels(aPoint.y, factor));
|
|
|
|
Maybe<Matrix4x4Flagged> matrixCache;
|
|
if (!TransformGfxPointFromAncestor(aFrame, result, aAncestor, matrixCache,
|
|
&result)) {
|
|
return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
|
|
}
|
|
|
|
return nsPoint(NSFloatPixelsToAppUnits(float(result.x), factor),
|
|
NSFloatPixelsToAppUnits(float(result.y), factor));
|
|
}
|
|
|
|
nsRect nsLayoutUtils::TransformFrameRectToAncestor(
|
|
const nsIFrame* aFrame, const nsRect& aRect, RelativeTo aAncestor,
|
|
bool* aPreservesAxisAlignedRectangles /* = nullptr */,
|
|
Maybe<Matrix4x4Flagged>* aMatrixCache /* = nullptr */,
|
|
bool aStopAtStackingContextAndDisplayPortAndOOFFrame /* = false */,
|
|
nsIFrame** aOutAncestor /* = nullptr */) {
|
|
MOZ_ASSERT(IsAncestorFrameCrossDocInProcess(aAncestor.mFrame, aFrame),
|
|
"Fix the caller");
|
|
float srcAppUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
|
|
Rect result(NSAppUnitsToFloatPixels(aRect.x, srcAppUnitsPerDevPixel),
|
|
NSAppUnitsToFloatPixels(aRect.y, srcAppUnitsPerDevPixel),
|
|
NSAppUnitsToFloatPixels(aRect.width, srcAppUnitsPerDevPixel),
|
|
NSAppUnitsToFloatPixels(aRect.height, srcAppUnitsPerDevPixel));
|
|
result = TransformGfxRectToAncestor(
|
|
RelativeTo{aFrame}, result, aAncestor, aPreservesAxisAlignedRectangles,
|
|
aMatrixCache, aStopAtStackingContextAndDisplayPortAndOOFFrame,
|
|
aOutAncestor);
|
|
|
|
float destAppUnitsPerDevPixel =
|
|
aAncestor.mFrame->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->GetWindowType() == widget::WindowType::Child) {
|
|
nsIWidget* parent = aWidget->GetParent();
|
|
if (!parent) {
|
|
break;
|
|
}
|
|
LayoutDeviceIntRect bounds = aWidget->GetBounds();
|
|
offset += bounds.TopLeft();
|
|
aWidget = parent;
|
|
}
|
|
aRootWidget = aWidget;
|
|
return offset;
|
|
}
|
|
|
|
LayoutDeviceIntPoint nsLayoutUtils::WidgetToWidgetOffset(nsIWidget* aFrom,
|
|
nsIWidget* aTo) {
|
|
nsIWidget* fromRoot;
|
|
LayoutDeviceIntPoint fromOffset = GetWidgetOffset(aFrom, fromRoot);
|
|
nsIWidget* toRoot;
|
|
LayoutDeviceIntPoint toOffset = GetWidgetOffset(aTo, toRoot);
|
|
|
|
if (fromRoot != toRoot) {
|
|
fromOffset = aFrom->WidgetToScreenOffset();
|
|
toOffset = aTo->WidgetToScreenOffset();
|
|
}
|
|
return fromOffset - toOffset;
|
|
}
|
|
|
|
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,
|
|
ViewportType aViewportType, nsIWidget* aWidget) {
|
|
nsPoint viewOffset;
|
|
nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
|
|
if (!viewWidget) {
|
|
return LayoutDeviceIntPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
|
|
}
|
|
|
|
nsPoint pt = (aPt + viewOffset);
|
|
// The target coordinates are visual, so perform a layout-to-visual
|
|
// conversion if the incoming coordinates are layout.
|
|
if (aViewportType == ViewportType::Layout && aPresContext->GetPresShell()) {
|
|
pt = ViewportUtils::LayoutToVisual(pt, aPresContext->GetPresShell());
|
|
}
|
|
LayoutDeviceIntPoint relativeToViewWidget(
|
|
aPresContext->AppUnitsToDevPixels(pt.x),
|
|
aPresContext->AppUnitsToDevPixels(pt.y));
|
|
return relativeToViewWidget + WidgetToWidgetOffset(viewWidget, aWidget);
|
|
}
|
|
|
|
StyleClear nsLayoutUtils::CombineClearType(StyleClear aOrigClearType,
|
|
StyleClear aNewClearType) {
|
|
StyleClear clearType = aOrigClearType;
|
|
switch (clearType) {
|
|
case StyleClear::Left:
|
|
if (StyleClear::Right == aNewClearType ||
|
|
StyleClear::Both == aNewClearType) {
|
|
clearType = StyleClear::Both;
|
|
}
|
|
break;
|
|
case StyleClear::Right:
|
|
if (StyleClear::Left == aNewClearType ||
|
|
StyleClear::Both == aNewClearType) {
|
|
clearType = StyleClear::Both;
|
|
}
|
|
break;
|
|
case StyleClear::None:
|
|
if (StyleClear::Left == aNewClearType ||
|
|
StyleClear::Right == aNewClearType ||
|
|
StyleClear::Both == aNewClearType) {
|
|
clearType = aNewClearType;
|
|
}
|
|
break;
|
|
case StyleClear::Both:
|
|
// Do nothing.
|
|
break;
|
|
}
|
|
return clearType;
|
|
}
|
|
|
|
#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->RemoveLastElement(); }
|
|
};
|
|
|
|
#endif
|
|
|
|
nsIFrame* nsLayoutUtils::GetFrameForPoint(
|
|
RelativeTo aRelativeTo, nsPoint aPt, const FrameForPointOptions& aOptions) {
|
|
AUTO_PROFILER_LABEL("nsLayoutUtils::GetFrameForPoint", LAYOUT);
|
|
|
|
nsresult rv;
|
|
AutoTArray<nsIFrame*, 8> outFrames;
|
|
rv = GetFramesForArea(aRelativeTo, nsRect(aPt, nsSize(1, 1)), outFrames,
|
|
aOptions);
|
|
NS_ENSURE_SUCCESS(rv, nullptr);
|
|
return outFrames.SafeElementAt(0);
|
|
}
|
|
|
|
nsresult nsLayoutUtils::GetFramesForArea(RelativeTo aRelativeTo,
|
|
const nsRect& aRect,
|
|
nsTArray<nsIFrame*>& aOutFrames,
|
|
const FrameForPointOptions& aOptions) {
|
|
AUTO_PROFILER_LABEL("nsLayoutUtils::GetFramesForArea", LAYOUT);
|
|
|
|
nsIFrame* frame = const_cast<nsIFrame*>(aRelativeTo.mFrame);
|
|
|
|
nsDisplayListBuilder builder(frame, nsDisplayListBuilderMode::EventDelivery,
|
|
false);
|
|
builder.BeginFrame();
|
|
nsDisplayList list(&builder);
|
|
|
|
if (aOptions.mBits.contains(FrameForPointOption::IgnorePaintSuppression)) {
|
|
builder.IgnorePaintSuppression();
|
|
}
|
|
if (aOptions.mBits.contains(FrameForPointOption::IgnoreRootScrollFrame)) {
|
|
nsIFrame* rootScrollFrame = frame->PresShell()->GetRootScrollFrame();
|
|
if (rootScrollFrame) {
|
|
builder.SetIgnoreScrollFrame(rootScrollFrame);
|
|
}
|
|
}
|
|
if (aRelativeTo.mViewportType == ViewportType::Layout) {
|
|
builder.SetIsRelativeToLayoutViewport();
|
|
}
|
|
if (aOptions.mBits.contains(FrameForPointOption::IgnoreCrossDoc)) {
|
|
builder.SetDescendIntoSubdocuments(false);
|
|
}
|
|
|
|
if (aOptions.mBits.contains(FrameForPointOption::OnlyVisible)) {
|
|
builder.SetHitTestIsForVisibility(aOptions.mVisibleThreshold);
|
|
}
|
|
|
|
builder.EnterPresShell(frame);
|
|
|
|
builder.SetVisibleRect(aRect);
|
|
builder.SetDirtyRect(aRect);
|
|
|
|
frame->BuildDisplayListForStackingContext(&builder, &list);
|
|
builder.LeavePresShell(frame, nullptr);
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
if (gDumpEventList) {
|
|
fprintf_stderr(stderr, "Event handling --- (%d,%d):\n", aRect.x, aRect.y);
|
|
|
|
std::stringstream ss;
|
|
nsIFrame::PrintDisplayList(&builder, list, ss);
|
|
print_stderr(ss);
|
|
}
|
|
#endif
|
|
|
|
nsDisplayItem::HitTestState hitTestState;
|
|
list.HitTest(&builder, aRect, &hitTestState, &aOutFrames);
|
|
list.DeleteAll(&builder);
|
|
builder.EndFrame();
|
|
return NS_OK;
|
|
}
|
|
|
|
mozilla::ParentLayerToScreenScale2D
|
|
nsLayoutUtils::GetTransformToAncestorScaleCrossProcessForFrameMetrics(
|
|
const nsIFrame* aFrame) {
|
|
ParentLayerToScreenScale2D transformToAncestorScale =
|
|
ViewAs<ParentLayerToScreenScale2D>(
|
|
nsLayoutUtils::GetTransformToAncestorScale(aFrame));
|
|
|
|
if (BrowserChild* browserChild = BrowserChild::GetFrom(aFrame->PresShell())) {
|
|
transformToAncestorScale =
|
|
ViewTargetAs<ParentLayerPixel>(
|
|
transformToAncestorScale,
|
|
PixelCastJustification::PropagatingToChildProcess) *
|
|
browserChild->GetEffectsInfo().mTransformToAncestorScale;
|
|
}
|
|
|
|
return transformToAncestorScale;
|
|
}
|
|
|
|
// 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();
|
|
PresShell* presShell = presContext->PresShell();
|
|
CSSToLayoutDeviceScale deviceScale = presContext->CSSToDevPixelScale();
|
|
float resolution = 1.0f;
|
|
bool isRcdRsf = aScrollFrame->IsRootScrollFrameOfDocument() &&
|
|
presContext->IsRootContentDocumentCrossProcess();
|
|
metrics.SetIsRootContent(isRcdRsf);
|
|
if (isRcdRsf) {
|
|
// Only the root content document's root scrollable frame should pick up
|
|
// the presShell's resolution. All the other frames are 1.0.
|
|
resolution = presShell->GetResolution();
|
|
}
|
|
LayoutDeviceToLayerScale cumulativeResolution(
|
|
LayoutDeviceToLayerScale(presShell->GetCumulativeResolution()));
|
|
|
|
LayerToParentLayerScale layerToParentLayerScale(1.0f);
|
|
metrics.SetDevPixelsPerCSSPixel(deviceScale);
|
|
metrics.SetPresShellResolution(resolution);
|
|
|
|
metrics.SetTransformToAncestorScale(
|
|
GetTransformToAncestorScaleCrossProcessForFrameMetrics(frame));
|
|
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);
|
|
LayoutDeviceToParentLayerScale compBoundsScale;
|
|
if (frame == presShell->GetRootScrollFrame() &&
|
|
presContext->IsRootContentDocumentCrossProcess()) {
|
|
if (presContext->GetParentPresContext()) {
|
|
float res = presContext->GetParentPresContext()
|
|
->PresShell()
|
|
->GetCumulativeResolution();
|
|
compBoundsScale = LayoutDeviceToParentLayerScale(res);
|
|
}
|
|
} else {
|
|
compBoundsScale = cumulativeResolution * layerToParentLayerScale;
|
|
}
|
|
metrics.SetCompositionBounds(
|
|
LayoutDeviceRect::FromAppUnits(nsRect(nsPoint(0, 0), compositionSize),
|
|
presContext->AppUnitsPerDevPixel()) *
|
|
compBoundsScale);
|
|
|
|
metrics.SetBoundingCompositionSize(
|
|
nsLayoutUtils::CalculateBoundingCompositionSize(frame, false, metrics));
|
|
|
|
metrics.SetLayoutViewport(
|
|
CSSRect::FromAppUnits(nsRect(aScrollFrame->GetScrollPosition(),
|
|
aScrollFrame->GetScrollPortRect().Size())));
|
|
metrics.SetVisualScrollOffset(
|
|
isRcdRsf ? CSSPoint::FromAppUnits(presShell->GetVisualViewportOffset())
|
|
: metrics.GetLayoutViewport().TopLeft());
|
|
|
|
metrics.SetScrollableRect(CSSRect::FromAppUnits(
|
|
nsLayoutUtils::CalculateScrollableRectForFrame(aScrollFrame, nullptr)));
|
|
|
|
return metrics;
|
|
}
|
|
|
|
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::AddExtraBackgroundItems(nsDisplayListBuilder* aBuilder,
|
|
nsDisplayList* aList,
|
|
nsIFrame* aFrame,
|
|
const nsRect& aCanvasArea,
|
|
const nsRegion& aVisibleRegion,
|
|
nscolor aBackstop) {
|
|
if (aFrame->IsPageFrame()) {
|
|
// 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.
|
|
return;
|
|
}
|
|
// 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.
|
|
nsRect canvasArea = aVisibleRegion.GetBounds();
|
|
canvasArea.IntersectRect(aCanvasArea, canvasArea);
|
|
nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList(
|
|
aBuilder, aFrame, canvasArea, canvasArea);
|
|
aFrame->PresShell()->AddCanvasBackgroundColorItem(aBuilder, aList, aFrame,
|
|
canvasArea, aBackstop);
|
|
}
|
|
|
|
// #define PRINT_HITTESTINFO_STATS
|
|
#ifdef PRINT_HITTESTINFO_STATS
|
|
void PrintHitTestInfoStatsInternal(nsDisplayList* aList, int& aTotal,
|
|
int& aHitTest, int& aVisible,
|
|
int& aSpecial) {
|
|
for (nsDisplayItem* i : *aList) {
|
|
aTotal++;
|
|
|
|
if (i->GetChildren()) {
|
|
PrintHitTestInfoStatsInternal(i->GetChildren(), aTotal, aHitTest,
|
|
aVisible, aSpecial);
|
|
}
|
|
|
|
if (i->GetType() == DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {
|
|
aHitTest++;
|
|
|
|
const auto& hitTestInfo = static_cast<nsDisplayCompositorHitTestInfo*>(i)
|
|
->GetHitTestInfo()
|
|
.Info();
|
|
|
|
if (hitTestInfo.size() > 1) {
|
|
aSpecial++;
|
|
continue;
|
|
}
|
|
|
|
if (hitTestInfo == CompositorHitTestFlags::eVisibleToHitTest) {
|
|
aVisible++;
|
|
continue;
|
|
}
|
|
|
|
aSpecial++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PrintHitTestInfoStats(nsDisplayList* aList) {
|
|
int total = 0;
|
|
int hitTest = 0;
|
|
int visible = 0;
|
|
int special = 0;
|
|
|
|
PrintHitTestInfoStatsInternal(aList, total, hitTest, visible, special);
|
|
|
|
double ratio = (double)hitTest / (double)total;
|
|
|
|
printf(
|
|
"List %p: total items: %d, hit test items: %d, ratio: %f, visible: %d, "
|
|
"special: %d\n",
|
|
aList, total, hitTest, ratio, visible, special);
|
|
}
|
|
#endif
|
|
|
|
// Apply a batch of effects updates generated during a paint to their
|
|
// respective remote browsers.
|
|
static void ApplyEffectsUpdates(
|
|
const nsTHashMap<nsPtrHashKey<RemoteBrowser>, EffectsInfo>& aUpdates) {
|
|
for (const auto& entry : aUpdates) {
|
|
auto* browser = entry.GetKey();
|
|
const auto& update = entry.GetData();
|
|
browser->UpdateEffects(update);
|
|
}
|
|
}
|
|
|
|
static void DumpBeforePaintDisplayList(UniquePtr<std::stringstream>& aStream,
|
|
nsDisplayListBuilder* aBuilder,
|
|
nsDisplayList* aList,
|
|
const nsRect& aVisibleRect) {
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
if (gfxEnv::MOZ_DUMP_PAINT_TO_FILE()) {
|
|
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::MOZ_DUMP_PAINT_TO_FILE()) {
|
|
*aStream << "<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
|
|
*aStream << nsPrintfCString(
|
|
"Painting --- before optimization (dirty %d,%d,%d,%d):\n",
|
|
aVisibleRect.x, aVisibleRect.y, aVisibleRect.width,
|
|
aVisibleRect.height)
|
|
.get();
|
|
nsIFrame::PrintDisplayList(aBuilder, *aList, *aStream,
|
|
gfxEnv::MOZ_DUMP_PAINT_TO_FILE());
|
|
|
|
if (gfxEnv::MOZ_DUMP_PAINT() || gfxEnv::MOZ_DUMP_PAINT_ITEMS()) {
|
|
// Flush stream now to avoid reordering dump output relative to
|
|
// messages dumped by PaintRoot below.
|
|
fprint_stderr(gfxUtils::sDumpPaintFile, *aStream);
|
|
aStream = MakeUnique<std::stringstream>();
|
|
}
|
|
}
|
|
|
|
static void DumpAfterPaintDisplayList(UniquePtr<std::stringstream>& aStream,
|
|
nsDisplayListBuilder* aBuilder,
|
|
nsDisplayList* aList) {
|
|
*aStream << "Painting --- after optimization:\n";
|
|
nsIFrame::PrintDisplayList(aBuilder, *aList, *aStream,
|
|
gfxEnv::MOZ_DUMP_PAINT_TO_FILE());
|
|
|
|
fprint_stderr(gfxUtils::sDumpPaintFile, *aStream);
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
if (gfxEnv::MOZ_DUMP_PAINT_TO_FILE()) {
|
|
*aStream << "</body></html>";
|
|
}
|
|
if (gfxEnv::MOZ_DUMP_PAINT_TO_FILE()) {
|
|
fclose(gfxUtils::sDumpPaintFile);
|
|
}
|
|
#endif
|
|
|
|
std::stringstream lsStream;
|
|
nsIFrame::PrintDisplayList(aBuilder, *aList, lsStream);
|
|
}
|
|
|
|
struct TemporaryDisplayListBuilder {
|
|
TemporaryDisplayListBuilder(nsIFrame* aFrame,
|
|
nsDisplayListBuilderMode aBuilderMode,
|
|
const bool aBuildCaret)
|
|
: mBuilder(aFrame, aBuilderMode, aBuildCaret), mList(&mBuilder) {}
|
|
|
|
~TemporaryDisplayListBuilder() { mList.DeleteAll(&mBuilder); }
|
|
|
|
nsDisplayListBuilder mBuilder;
|
|
nsDisplayList mList;
|
|
RetainedDisplayListMetrics mMetrics;
|
|
};
|
|
|
|
void nsLayoutUtils::PaintFrame(gfxContext* aRenderingContext, nsIFrame* aFrame,
|
|
const nsRegion& aDirtyRegion, nscolor aBackstop,
|
|
nsDisplayListBuilderMode aBuilderMode,
|
|
PaintFrameFlags aFlags) {
|
|
AUTO_PROFILER_LABEL("nsLayoutUtils::PaintFrame", GRAPHICS);
|
|
|
|
// Create a static storage counter that is incremented on eacy entry to
|
|
// PaintFrame and decremented on exit. We can use this later to determine if
|
|
// this is a top-level paint.
|
|
static uint32_t paintFrameDepth = 0;
|
|
++paintFrameDepth;
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
if (!gPaintCountStack) {
|
|
gPaintCountStack = new nsTArray<int>();
|
|
ClearOnShutdown(&gPaintCountStack);
|
|
|
|
gPaintCountStack->AppendElement(0);
|
|
}
|
|
++gPaintCountStack->LastElement();
|
|
AutoNestedPaintCount nestedPaintCount;
|
|
#endif
|
|
|
|
nsIFrame* displayRoot = GetDisplayRootFrame(aFrame);
|
|
|
|
if (aFlags & PaintFrameFlags::WidgetLayers) {
|
|
nsView* view = aFrame->GetView();
|
|
if (!(view && view->GetWidget() && displayRoot == aFrame)) {
|
|
aFlags &= ~PaintFrameFlags::WidgetLayers;
|
|
NS_ASSERTION(aRenderingContext, "need a rendering context");
|
|
}
|
|
}
|
|
|
|
nsPresContext* presContext = aFrame->PresContext();
|
|
PresShell* presShell = presContext->PresShell();
|
|
|
|
TimeStamp startBuildDisplayList = TimeStamp::Now();
|
|
auto dlTimerId = mozilla::glean::paint::build_displaylist_time.Start();
|
|
|
|
const bool buildCaret = !(aFlags & PaintFrameFlags::HideCaret);
|
|
|
|
// Note that isForPainting here does not include the PaintForPrinting builder
|
|
// mode; that's OK because there is no point in using retained display lists
|
|
// for a print destination.
|
|
const bool isForPainting = (aFlags & PaintFrameFlags::WidgetLayers) &&
|
|
aBuilderMode == nsDisplayListBuilderMode::Painting;
|
|
|
|
// Only allow retaining for painting when preffed on, and for root frames
|
|
// (since the modified frame tracking is per-root-frame).
|
|
const bool retainDisplayList =
|
|
isForPainting && AreRetainedDisplayListsEnabled() && !aFrame->GetParent();
|
|
|
|
RetainedDisplayListBuilder* retainedBuilder = nullptr;
|
|
Maybe<TemporaryDisplayListBuilder> temporaryBuilder;
|
|
|
|
nsDisplayListBuilder* builder = nullptr;
|
|
nsDisplayList* list = nullptr;
|
|
RetainedDisplayListMetrics* metrics = nullptr;
|
|
|
|
if (retainDisplayList) {
|
|
MOZ_ASSERT(aFrame == displayRoot);
|
|
retainedBuilder = aFrame->GetProperty(RetainedDisplayListBuilder::Cached());
|
|
if (!retainedBuilder) {
|
|
retainedBuilder =
|
|
new RetainedDisplayListBuilder(aFrame, aBuilderMode, buildCaret);
|
|
aFrame->SetProperty(RetainedDisplayListBuilder::Cached(),
|
|
retainedBuilder);
|
|
}
|
|
|
|
builder = retainedBuilder->Builder();
|
|
list = retainedBuilder->List();
|
|
metrics = retainedBuilder->Metrics();
|
|
} else {
|
|
temporaryBuilder.emplace(aFrame, aBuilderMode, buildCaret);
|
|
builder = &temporaryBuilder->mBuilder;
|
|
list = &temporaryBuilder->mList;
|
|
metrics = &temporaryBuilder->mMetrics;
|
|
}
|
|
|
|
MOZ_ASSERT(builder && list && metrics);
|
|
|
|
nsAutoString uri;
|
|
Document* doc = presContext->Document();
|
|
MOZ_ASSERT(doc);
|
|
Unused << doc->GetDocumentURI(uri);
|
|
|
|
nsAutoString frameName, displayRootName;
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
aFrame->GetFrameName(frameName);
|
|
displayRoot->GetFrameName(displayRootName);
|
|
#endif
|
|
|
|
DL_LOGI("PaintFrame: %p (%s), DisplayRoot: %p (%s), Builder: %p, URI: %s",
|
|
aFrame, NS_ConvertUTF16toUTF8(frameName).get(), displayRoot,
|
|
NS_ConvertUTF16toUTF8(displayRootName).get(), retainedBuilder,
|
|
NS_ConvertUTF16toUTF8(uri).get());
|
|
|
|
metrics->Reset();
|
|
metrics->StartBuild();
|
|
|
|
builder->BeginFrame();
|
|
|
|
MOZ_ASSERT(paintFrameDepth >= 1);
|
|
// If this is a top-level paint, increment the paint sequence number.
|
|
if (paintFrameDepth == 1) {
|
|
// Increment the paint sequence number for the display list builder.
|
|
nsDisplayListBuilder::IncrementPaintSequenceNumber();
|
|
}
|
|
|
|
if (aFlags & PaintFrameFlags::InTransform) {
|
|
builder->SetInTransform(true);
|
|
}
|
|
if (aFlags & PaintFrameFlags::SyncDecodeImages) {
|
|
builder->SetSyncDecodeImages(true);
|
|
}
|
|
if (aFlags & (PaintFrameFlags::WidgetLayers | PaintFrameFlags::ToWindow)) {
|
|
builder->SetPaintingToWindow(true);
|
|
}
|
|
if (aFlags & PaintFrameFlags::UseHighQualityScaling) {
|
|
builder->SetUseHighQualityScaling(true);
|
|
}
|
|
if (aFlags & PaintFrameFlags::ForWebRender) {
|
|
builder->SetPaintingForWebRender(true);
|
|
}
|
|
if (aFlags & PaintFrameFlags::IgnoreSuppression) {
|
|
builder->IgnorePaintSuppression();
|
|
}
|
|
|
|
if (BrowsingContext* bc = presContext->Document()->GetBrowsingContext()) {
|
|
builder->SetInActiveDocShell(bc->IsActive());
|
|
}
|
|
|
|
nsRect rootInkOverflow = aFrame->InkOverflowRectRelativeToSelf();
|
|
|
|
// If the dynamic toolbar is completely collapsed, the visible rect should
|
|
// be expanded to include this area.
|
|
const bool hasDynamicToolbar =
|
|
presContext->IsRootContentDocumentCrossProcess() &&
|
|
presContext->HasDynamicToolbar();
|
|
if (hasDynamicToolbar) {
|
|
rootInkOverflow.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar(
|
|
presContext, rootInkOverflow.Size()));
|
|
}
|
|
|
|
// If we are in a remote browser, then apply clipping from ancestor browsers
|
|
if (BrowserChild* browserChild = BrowserChild::GetFrom(presShell)) {
|
|
if (!browserChild->IsTopLevel()) {
|
|
const nsRect unscaledVisibleRect =
|
|
browserChild->GetVisibleRect().valueOr(nsRect());
|
|
rootInkOverflow.IntersectRect(rootInkOverflow, unscaledVisibleRect);
|
|
}
|
|
}
|
|
|
|
builder->ClearHaveScrollableDisplayPort();
|
|
if (builder->IsPaintingToWindow()) {
|
|
DisplayPortUtils::MaybeCreateDisplayPortInFirstScrollFrameEncountered(
|
|
aFrame, builder);
|
|
}
|
|
|
|
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
|
|
if (rootScrollFrame && !aFrame->GetParent()) {
|
|
nsIScrollableFrame* rootScrollableFrame =
|
|
presShell->GetRootScrollFrameAsScrollable();
|
|
MOZ_ASSERT(rootScrollableFrame);
|
|
nsRect displayPortBase = rootInkOverflow;
|
|
nsRect temp = displayPortBase;
|
|
Unused << rootScrollableFrame->DecideScrollableLayer(
|
|
builder, &displayPortBase, &temp,
|
|
/* aSetBase = */ true);
|
|
}
|
|
|
|
nsRegion visibleRegion;
|
|
if (aFlags & PaintFrameFlags::WidgetLayers) {
|
|
// 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 = rootInkOverflow;
|
|
} else {
|
|
visibleRegion = aDirtyRegion;
|
|
}
|
|
|
|
Maybe<nsPoint> originalScrollPosition;
|
|
auto maybeResetScrollPosition = MakeScopeExit([&]() {
|
|
if (originalScrollPosition && rootScrollFrame) {
|
|
nsIScrollableFrame* rootScrollableFrame =
|
|
presShell->GetRootScrollFrameAsScrollable();
|
|
MOZ_ASSERT(rootScrollableFrame->GetScrolledFrame()->GetPosition() ==
|
|
nsPoint());
|
|
rootScrollableFrame->GetScrolledFrame()->SetPosition(
|
|
*originalScrollPosition);
|
|
}
|
|
});
|
|
|
|
nsRect canvasArea(nsPoint(0, 0),
|
|
aFrame->InkOverflowRectRelativeToSelf().Size());
|
|
bool ignoreViewportScrolling =
|
|
!aFrame->GetParent() && presShell->IgnoringViewportScrolling();
|
|
|
|
if (!aFrame->GetParent() && hasDynamicToolbar) {
|
|
canvasArea.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar(
|
|
presContext, canvasArea.Size()));
|
|
}
|
|
|
|
if (ignoreViewportScrolling && rootScrollFrame) {
|
|
nsIScrollableFrame* rootScrollableFrame =
|
|
presShell->GetRootScrollFrameAsScrollable();
|
|
if (aFlags & PaintFrameFlags::ResetViewportScrolling) {
|
|
// Temporarily scroll the root scroll frame to 0,0 so that position:fixed
|
|
// elements will appear fixed to the top-left of the document. We manually
|
|
// set the position of the scrolled frame instead of using ScrollTo, since
|
|
// the latter fires scroll listeners, which we don't want.
|
|
originalScrollPosition.emplace(
|
|
rootScrollableFrame->GetScrolledFrame()->GetPosition());
|
|
rootScrollableFrame->GetScrolledFrame()->SetPosition(nsPoint());
|
|
}
|
|
if (aFlags & PaintFrameFlags::DocumentRelative) {
|
|
// 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->SetMatrixDouble(
|
|
aRenderingContext->CurrentMatrixDouble().PreTranslate(
|
|
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));
|
|
}
|
|
}
|
|
|
|
nsRect visibleRect = visibleRegion.GetBounds();
|
|
PartialUpdateResult updateState = PartialUpdateResult::Failed;
|
|
|
|
{
|
|
AUTO_PROFILER_LABEL_CATEGORY_PAIR(GRAPHICS_DisplayListBuilding);
|
|
AUTO_PROFILER_TRACING_MARKER("Paint", "DisplayList", GRAPHICS);
|
|
PerfStats::AutoMetricRecording<PerfStats::Metric::DisplayListBuilding>
|
|
autoRecording;
|
|
|
|
ViewID id = ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(
|
|
builder);
|
|
|
|
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);
|
|
}
|
|
// In some cases we get a root document here on an APZ-enabled window
|
|
// that doesn't have the root displayport initialized yet, even though
|
|
// the ChromeProcessController is supposed to do it when the widget is
|
|
// created. This can happen simply because the ChromeProcessController
|
|
// does it on the next spin of the event loop, and we can trigger a
|
|
// paint synchronously after window creation but before that runs. In
|
|
// that case we should initialize the root displayport here before we do
|
|
// the paint.
|
|
} else if (XRE_IsParentProcess() && presContext->IsRoot() &&
|
|
presShell->GetDocument() != nullptr &&
|
|
presShell->GetRootScrollFrame() != nullptr &&
|
|
nsLayoutUtils::UsesAsyncScrolling(
|
|
presShell->GetRootScrollFrame())) {
|
|
if (dom::Element* element =
|
|
presShell->GetDocument()->GetDocumentElement()) {
|
|
if (!DisplayPortUtils::HasNonMinimalDisplayPort(element)) {
|
|
APZCCallbackHelper::InitializeRootDisplayport(presShell);
|
|
}
|
|
}
|
|
}
|
|
|
|
asrSetter.SetCurrentScrollParentId(id);
|
|
|
|
builder->SetVisibleRect(visibleRect);
|
|
builder->SetIsBuilding(true);
|
|
builder->SetAncestorHasApzAwareEventHandler(
|
|
gfxPlatform::AsyncPanZoomEnabled() &&
|
|
nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(presShell));
|
|
|
|
// If a pref is toggled that adds or removes display list items,
|
|
// we need to rebuild the display list. The pref may be toggled
|
|
// manually by the user, or during test setup.
|
|
if (retainDisplayList &&
|
|
!builder->ShouldRebuildDisplayListDueToPrefChange()) {
|
|
// Attempt to do a partial build and merge into the existing list.
|
|
// This calls BuildDisplayListForStacking context on a subset of the
|
|
// viewport.
|
|
updateState = retainedBuilder->AttemptPartialUpdate(aBackstop);
|
|
metrics->EndPartialBuild(updateState);
|
|
} else {
|
|
// Partial updates are disabled.
|
|
DL_LOGI("Partial updates are disabled");
|
|
metrics->mPartialUpdateResult = PartialUpdateResult::Failed;
|
|
metrics->mPartialUpdateFailReason = PartialUpdateFailReason::Disabled;
|
|
}
|
|
|
|
// Rebuild the full display list if the partial display list build failed.
|
|
bool doFullRebuild = updateState == PartialUpdateResult::Failed;
|
|
|
|
if (StaticPrefs::layout_display_list_build_twice()) {
|
|
// Build display list twice to compare partial and full display list
|
|
// build times.
|
|
metrics->StartBuild();
|
|
doFullRebuild = true;
|
|
}
|
|
|
|
if (doFullRebuild) {
|
|
if (retainDisplayList) {
|
|
retainedBuilder->ClearRetainedData();
|
|
#ifdef DEBUG
|
|
mozilla::RDLUtils::AssertFrameSubtreeUnmodified(
|
|
builder->RootReferenceFrame());
|
|
#endif
|
|
}
|
|
|
|
list->DeleteAll(builder);
|
|
|
|
builder->ClearRetainedWindowRegions();
|
|
builder->ClearWillChangeBudgets();
|
|
|
|
builder->EnterPresShell(aFrame);
|
|
builder->SetDirtyRect(visibleRect);
|
|
|
|
DL_LOGI("Starting full display list build, root frame: %p",
|
|
builder->RootReferenceFrame());
|
|
|
|
aFrame->BuildDisplayListForStackingContext(builder, list);
|
|
AddExtraBackgroundItems(builder, list, aFrame, canvasArea, visibleRegion,
|
|
aBackstop);
|
|
|
|
builder->LeavePresShell(aFrame, list);
|
|
metrics->EndFullBuild();
|
|
|
|
DL_LOGI("Finished full display list build");
|
|
updateState = PartialUpdateResult::Updated;
|
|
}
|
|
|
|
builder->SetIsBuilding(false);
|
|
builder->IncrementPresShellPaintCount(presShell);
|
|
}
|
|
|
|
MOZ_ASSERT(updateState != PartialUpdateResult::Failed);
|
|
builder->Check();
|
|
|
|
const double geckoDLBuildTime =
|
|
(TimeStamp::Now() - startBuildDisplayList).ToMilliseconds();
|
|
mozilla::glean::paint::build_displaylist_time.StopAndAccumulate(
|
|
std::move(dlTimerId));
|
|
|
|
bool consoleNeedsDisplayList =
|
|
(gfxUtils::DumpDisplayList() || gfxEnv::MOZ_DUMP_PAINT()) &&
|
|
builder->IsInActiveDocShell();
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
FILE* savedDumpFile = gfxUtils::sDumpPaintFile;
|
|
#endif
|
|
|
|
UniquePtr<std::stringstream> ss;
|
|
if (consoleNeedsDisplayList) {
|
|
ss = MakeUnique<std::stringstream>();
|
|
*ss << "Display list for " << uri << "\n";
|
|
DumpBeforePaintDisplayList(ss, builder, list, visibleRect);
|
|
}
|
|
|
|
uint32_t flags = nsDisplayList::PAINT_DEFAULT;
|
|
if (aFlags & PaintFrameFlags::WidgetLayers) {
|
|
flags |= nsDisplayList::PAINT_USE_WIDGET_LAYERS;
|
|
if (!(aFlags & PaintFrameFlags::DocumentRelative)) {
|
|
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::ExistingTransaction) {
|
|
flags |= nsDisplayList::PAINT_EXISTING_TRANSACTION;
|
|
}
|
|
if (updateState == PartialUpdateResult::NoChange && !aRenderingContext) {
|
|
flags |= nsDisplayList::PAINT_IDENTICAL_DISPLAY_LIST;
|
|
}
|
|
|
|
#ifdef PRINT_HITTESTINFO_STATS
|
|
if (XRE_IsContentProcess()) {
|
|
PrintHitTestInfoStats(list);
|
|
}
|
|
#endif
|
|
|
|
TimeStamp paintStart = TimeStamp::Now();
|
|
list->PaintRoot(builder, aRenderingContext, flags, Some(geckoDLBuildTime));
|
|
Telemetry::AccumulateTimeDelta(Telemetry::PAINT_RASTERIZE_TIME, paintStart);
|
|
|
|
if (builder->IsPaintingToWindow()) {
|
|
presShell->EndPaint();
|
|
}
|
|
builder->Check();
|
|
|
|
if (consoleNeedsDisplayList) {
|
|
DumpAfterPaintDisplayList(ss, builder, list);
|
|
}
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
gfxUtils::sDumpPaintFile = savedDumpFile;
|
|
#endif
|
|
|
|
// Update the widget's opaque region information. This sets
|
|
// glass boundaries on Windows. Also set up the window dragging region.
|
|
if ((aFlags & PaintFrameFlags::WidgetLayers) &&
|
|
!(aFlags & PaintFrameFlags::DocumentRelative)) {
|
|
if (nsIWidget* widget = aFrame->GetNearestWidget()) {
|
|
const nsRegion& opaqueRegion = builder->GetWindowOpaqueRegion();
|
|
widget->UpdateOpaqueRegion(LayoutDeviceIntRegion::FromUnknownRegion(
|
|
opaqueRegion.ToNearestPixels(presContext->AppUnitsPerDevPixel())));
|
|
widget->UpdateWindowDraggingRegion(builder->GetWindowDraggingRegion());
|
|
}
|
|
}
|
|
|
|
// Apply effects updates if we were actually painting
|
|
if (isForPainting) {
|
|
ApplyEffectsUpdates(builder->GetEffectUpdates());
|
|
}
|
|
|
|
builder->Check();
|
|
|
|
{
|
|
AUTO_PROFILER_TRACING_MARKER("Paint", "DisplayListResources", GRAPHICS);
|
|
|
|
builder->EndFrame();
|
|
|
|
if (temporaryBuilder) {
|
|
temporaryBuilder.reset();
|
|
}
|
|
}
|
|
|
|
--paintFrameDepth;
|
|
#if 0
|
|
if (XRE_IsParentProcess()) {
|
|
if (metrics->mPartialUpdateResult == PartialUpdateResult::Failed) {
|
|
printf("DL partial update failed: %s, Frame: %p\n",
|
|
metrics->FailReasonString(), aFrame);
|
|
} else {
|
|
printf(
|
|
"DL partial build success!"
|
|
" new: %d, reused: %d, rebuilt: %d, removed: %d, total: %d\n",
|
|
metrics->mNewItems, metrics->mReusedItems, metrics->mRebuiltItems,
|
|
metrics->mRemovedItems, metrics->mTotalItems);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
void nsLayoutUtils::AddBoxesForFrame(nsIFrame* aFrame,
|
|
nsLayoutUtils::BoxCallback* aCallback) {
|
|
auto pseudoType = aFrame->Style()->GetPseudoType();
|
|
|
|
if (pseudoType == PseudoStyleType::tableWrapper) {
|
|
AddBoxesForFrame(aFrame->PrincipalChildList().FirstChild(), aCallback);
|
|
if (aCallback->mIncludeCaptionBoxForTable) {
|
|
nsIFrame* kid =
|
|
aFrame->GetChildList(FrameChildListID::Caption).FirstChild();
|
|
if (kid) {
|
|
AddBoxesForFrame(kid, aCallback);
|
|
}
|
|
}
|
|
} else if (pseudoType == PseudoStyleType::mozBlockInsideInlineWrapper ||
|
|
pseudoType == PseudoStyleType::mozMathMLAnonymousBlock) {
|
|
for (nsIFrame* kid : aFrame->PrincipalChildList()) {
|
|
AddBoxesForFrame(kid, aCallback);
|
|
}
|
|
} else {
|
|
aCallback->AddBox(aFrame);
|
|
}
|
|
}
|
|
|
|
void nsLayoutUtils::GetAllInFlowBoxes(nsIFrame* aFrame,
|
|
BoxCallback* aCallback) {
|
|
aCallback->mInTargetContinuation = false;
|
|
while (aFrame) {
|
|
AddBoxesForFrame(aFrame, aCallback);
|
|
aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
|
|
aCallback->mInTargetContinuation = true;
|
|
}
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetFirstNonAnonymousFrame(nsIFrame* aFrame) {
|
|
while (aFrame) {
|
|
auto pseudoType = aFrame->Style()->GetPseudoType();
|
|
|
|
if (pseudoType == PseudoStyleType::tableWrapper) {
|
|
nsIFrame* f =
|
|
GetFirstNonAnonymousFrame(aFrame->PrincipalChildList().FirstChild());
|
|
if (f) {
|
|
return f;
|
|
}
|
|
nsIFrame* kid =
|
|
aFrame->GetChildList(FrameChildListID::Caption).FirstChild();
|
|
if (kid) {
|
|
f = GetFirstNonAnonymousFrame(kid);
|
|
if (f) {
|
|
return f;
|
|
}
|
|
}
|
|
} else if (pseudoType == PseudoStyleType::mozBlockInsideInlineWrapper ||
|
|
pseudoType == PseudoStyleType::mozMathMLAnonymousBlock) {
|
|
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 {
|
|
const nsIFrame* mRelativeTo;
|
|
RectCallback* mCallback;
|
|
uint32_t mFlags;
|
|
// If the frame we're measuring relative to is the root, we know all frames
|
|
// are descendants of it, so we don't need to compute the common ancestor
|
|
// between a frame and mRelativeTo.
|
|
bool mRelativeToIsRoot;
|
|
// For the same reason, if the frame we're measuring relative to is the target
|
|
// (this is useful for IntersectionObserver), we know all frames are
|
|
// descendants of it except if we're in a continuation or ib-split-sibling of
|
|
// it.
|
|
bool mRelativeToIsTarget;
|
|
|
|
BoxToRect(const nsIFrame* aTargetFrame, const nsIFrame* aRelativeTo,
|
|
RectCallback* aCallback, uint32_t aFlags)
|
|
: mRelativeTo(aRelativeTo),
|
|
mCallback(aCallback),
|
|
mFlags(aFlags),
|
|
mRelativeToIsRoot(!aRelativeTo->GetParent()),
|
|
mRelativeToIsTarget(aRelativeTo == aTargetFrame) {}
|
|
|
|
void AddBox(nsIFrame* aFrame) override {
|
|
nsRect r;
|
|
nsIFrame* outer = SVGUtils::GetOuterSVGFrameAndCoveredRegion(aFrame, &r);
|
|
const bool usingSVGOuterFrame = !!outer;
|
|
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) {
|
|
const bool isAncestorKnown = [&] {
|
|
if (mRelativeToIsRoot) {
|
|
return true;
|
|
}
|
|
if (mRelativeToIsTarget && !mInTargetContinuation) {
|
|
return !usingSVGOuterFrame;
|
|
}
|
|
return false;
|
|
}();
|
|
if (isAncestorKnown) {
|
|
r = nsLayoutUtils::TransformFrameRectToAncestor(outer, r, mRelativeTo);
|
|
} else {
|
|
nsLayoutUtils::TransformRect(outer, mRelativeTo, r);
|
|
}
|
|
} else {
|
|
if (aFrame->PresContext() != mRelativeTo->PresContext()) {
|
|
r += outer->GetOffsetToCrossDoc(mRelativeTo);
|
|
} else {
|
|
r += outer->GetOffsetTo(mRelativeTo);
|
|
}
|
|
}
|
|
mCallback->AddRect(r);
|
|
}
|
|
};
|
|
|
|
struct MOZ_RAII BoxToRectAndText : public BoxToRect {
|
|
Sequence<nsString>* mTextList;
|
|
|
|
BoxToRectAndText(const nsIFrame* aTargetFrame, const nsIFrame* aRelativeTo,
|
|
RectCallback* aCallback, Sequence<nsString>* aTextList,
|
|
uint32_t aFlags)
|
|
: BoxToRect(aTargetFrame, aRelativeTo, aCallback, aFlags),
|
|
mTextList(aTextList) {}
|
|
|
|
static void AccumulateText(nsIFrame* aFrame, nsAString& aResult) {
|
|
MOZ_ASSERT(aFrame);
|
|
|
|
// Get all the text in aFrame and child frames, while respecting
|
|
// the content offsets in each of the nsTextFrames.
|
|
if (aFrame->IsTextFrame()) {
|
|
nsTextFrame* textFrame = static_cast<nsTextFrame*>(aFrame);
|
|
|
|
nsIFrame::RenderedText renderedText = textFrame->GetRenderedText(
|
|
textFrame->GetContentOffset(),
|
|
textFrame->GetContentOffset() + textFrame->GetContentLength(),
|
|
nsIFrame::TextOffsetType::OffsetsInContentText,
|
|
nsIFrame::TrailingWhitespace::DontTrim);
|
|
|
|
aResult.Append(renderedText.mString);
|
|
}
|
|
|
|
for (nsIFrame* child = aFrame->PrincipalChildList().FirstChild(); child;
|
|
child = child->GetNextSibling()) {
|
|
AccumulateText(child, aResult);
|
|
}
|
|
}
|
|
|
|
void AddBox(nsIFrame* aFrame) override {
|
|
BoxToRect::AddBox(aFrame);
|
|
if (mTextList) {
|
|
nsString* textForFrame = mTextList->AppendElement(fallible);
|
|
if (textForFrame) {
|
|
AccumulateText(aFrame, *textForFrame);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
void nsLayoutUtils::GetAllInFlowRects(nsIFrame* aFrame,
|
|
const nsIFrame* aRelativeTo,
|
|
RectCallback* aCallback,
|
|
uint32_t aFlags) {
|
|
BoxToRect converter(aFrame, aRelativeTo, aCallback, aFlags);
|
|
GetAllInFlowBoxes(aFrame, &converter);
|
|
}
|
|
|
|
void nsLayoutUtils::GetAllInFlowRectsAndTexts(nsIFrame* aFrame,
|
|
const nsIFrame* aRelativeTo,
|
|
RectCallback* aCallback,
|
|
Sequence<nsString>* aTextList,
|
|
uint32_t aFlags) {
|
|
BoxToRectAndText converter(aFrame, 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->PresShell()->GetRootFrame();
|
|
}
|
|
|
|
nsRect nsLayoutUtils::GetAllInFlowRectsUnion(nsIFrame* aFrame,
|
|
const 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();
|
|
auto shadows = textStyle->mTextShadow.AsSpan();
|
|
if (shadows.IsEmpty()) {
|
|
return aTextAndDecorationsRect;
|
|
}
|
|
|
|
nsRect resultRect = aTextAndDecorationsRect;
|
|
int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
|
|
for (auto& shadow : shadows) {
|
|
nsMargin blur =
|
|
nsContextBoxBlur::GetBlurRadiusMargin(shadow.blur.ToAppUnits(), A2D);
|
|
if ((aFlags & EXCLUDE_BLUR_SHADOWS) && blur != nsMargin(0, 0, 0, 0))
|
|
continue;
|
|
|
|
nsRect tmpRect(aTextAndDecorationsRect);
|
|
|
|
tmpRect.MoveBy(
|
|
nsPoint(shadow.horizontal.ToAppUnits(), shadow.vertical.ToAppUnits()));
|
|
tmpRect.Inflate(blur);
|
|
|
|
resultRect.UnionRect(resultRect, tmpRect);
|
|
}
|
|
return resultRect;
|
|
}
|
|
|
|
enum ObjectDimensionType { eWidth, eHeight };
|
|
static nscoord ComputeMissingDimension(
|
|
const nsSize& aDefaultObjectSize, const AspectRatio& 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) {
|
|
// Fill in the missing dimension using the intrinsic aspect ratio.
|
|
if (aDimensionToCompute == eWidth) {
|
|
return aIntrinsicRatio.ApplyTo(*aSpecifiedHeight);
|
|
}
|
|
return aIntrinsicRatio.Inverted().ApplyTo(*aSpecifiedWidth);
|
|
}
|
|
|
|
// 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 AspectRatio& 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:
|
|
const Maybe<nscoord>& specifiedWidth = aIntrinsicSize.width;
|
|
const Maybe<nscoord>& specifiedHeight = aIntrinsicSize.height;
|
|
|
|
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 AspectRatio& aIntrinsicRatio,
|
|
StyleObjectFit 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 == StyleObjectFit::Fill) || !aIntrinsicRatio) {
|
|
return aConstraintSize;
|
|
}
|
|
|
|
// The type of constraint to compute (cover/contain), if needed:
|
|
Maybe<nsImageRenderer::FitType> fitType;
|
|
|
|
Maybe<nsSize> noneSize;
|
|
if (aObjectFit == StyleObjectFit::None ||
|
|
aObjectFit == StyleObjectFit::ScaleDown) {
|
|
noneSize = MaybeComputeObjectFitNoneSize(aConstraintSize, aIntrinsicSize,
|
|
aIntrinsicRatio);
|
|
if (!noneSize || aObjectFit == StyleObjectFit::ScaleDown) {
|
|
// 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 == StyleObjectFit::Cover) {
|
|
fitType.emplace(nsImageRenderer::COVER);
|
|
} else if (aObjectFit == StyleObjectFit::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 StyleObjectFit::Fill; we handled it w/ early-return.
|
|
case StyleObjectFit::Contain:
|
|
case StyleObjectFit::Cover:
|
|
MOZ_ASSERT(constrainedSize);
|
|
return *constrainedSize;
|
|
|
|
case StyleObjectFit::None:
|
|
if (noneSize) {
|
|
return *noneSize;
|
|
}
|
|
MOZ_ASSERT(constrainedSize);
|
|
return *constrainedSize;
|
|
|
|
case StyleObjectFit::ScaleDown:
|
|
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 LengthPercentage& aCoord) {
|
|
return aCoord.ConvertsToPercentage() && aCoord.ToPercentage() == 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 Position& objectPos = aStylePos->mObjectPosition;
|
|
|
|
return aStylePos->mObjectFit == StyleObjectFit::Fill &&
|
|
IsCoord50Pct(objectPos.horizontal) && IsCoord50Pct(objectPos.vertical);
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::ComputeObjectDestRect(const nsRect& aConstraintRect,
|
|
const IntrinsicSize& aIntrinsicSize,
|
|
const AspectRatio& 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) {
|
|
ComputedStyle* computedStyle = aFrame->Style();
|
|
uint8_t variantWidth = NS_FONT_VARIANT_WIDTH_NORMAL;
|
|
if (computedStyle->IsTextCombined()) {
|
|
MOZ_ASSERT(aFrame->IsTextFrame());
|
|
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 GetFontMetricsForComputedStyle(computedStyle, aFrame->PresContext(),
|
|
aInflation, variantWidth);
|
|
}
|
|
|
|
already_AddRefed<nsFontMetrics> nsLayoutUtils::GetFontMetricsForComputedStyle(
|
|
const ComputedStyle* aComputedStyle, nsPresContext* aPresContext,
|
|
float aInflation, uint8_t aVariantWidth) {
|
|
WritingMode wm(aComputedStyle);
|
|
const nsStyleFont* styleFont = aComputedStyle->StyleFont();
|
|
nsFontMetrics::Params params;
|
|
params.language = styleFont->mLanguage;
|
|
params.explicitLanguage = styleFont->mExplicitLanguage;
|
|
params.orientation = wm.IsVertical() && !wm.IsSideways()
|
|
? nsFontMetrics::eVertical
|
|
: nsFontMetrics::eHorizontal;
|
|
// pass the user font set object into the device context to
|
|
// pass along to CreateFontGroup
|
|
params.userFontSet = aPresContext->GetUserFontSet();
|
|
params.textPerf = aPresContext->GetTextPerfMetrics();
|
|
params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
|
|
|
|
// 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 aPresContext->GetMetricsFor(styleFont->mFont, params);
|
|
}
|
|
|
|
nsFont font = styleFont->mFont;
|
|
MOZ_ASSERT(!std::isnan(float(font.size.ToCSSPixels())),
|
|
"Style font should never be NaN");
|
|
font.size.ScaleBy(aInflation);
|
|
if (MOZ_UNLIKELY(std::isnan(float(font.size.ToCSSPixels())))) {
|
|
font.size = {0};
|
|
}
|
|
font.variantWidth = aVariantWidth;
|
|
return aPresContext->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::FindNearestBlockAncestor(nsIFrame* aFrame) {
|
|
nsIFrame* nextAncestor;
|
|
for (nextAncestor = aFrame->GetParent(); nextAncestor;
|
|
nextAncestor = nextAncestor->GetParent()) {
|
|
nsBlockFrame* block = do_QueryFrame(nextAncestor);
|
|
if (block) return block;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetNonGeneratedAncestor(nsIFrame* aFrame) {
|
|
if (!aFrame->HasAnyStateBits(NS_FRAME_GENERATED_CONTENT)) return aFrame;
|
|
|
|
nsIFrame* f = aFrame;
|
|
do {
|
|
f = GetParentOrPlaceholderFor(f);
|
|
} while (f->HasAnyStateBits(NS_FRAME_GENERATED_CONTENT));
|
|
return f;
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetParentOrPlaceholderFor(const nsIFrame* aFrame) {
|
|
// This condition must match the condition in FindContainingBlocks in
|
|
// RetainedDisplayListBuider.cpp, MarkFrameForDisplayIfVisible and
|
|
// UnmarkFrameForDisplayIfVisible in nsDisplayList.cpp
|
|
if (aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) &&
|
|
!aFrame->GetPrevInFlow()) {
|
|
return aFrame->GetProperty(nsIFrame::PlaceholderFrameProperty());
|
|
}
|
|
return aFrame->GetParent();
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(
|
|
const nsIFrame* aFrame) {
|
|
nsIFrame* f = GetParentOrPlaceholderFor(aFrame);
|
|
if (f) return f;
|
|
return GetCrossDocParentFrameInProcess(aFrame);
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetDisplayListParent(nsIFrame* aFrame) {
|
|
if (aFrame->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT)) {
|
|
return aFrame->GetParent();
|
|
}
|
|
return nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(aFrame);
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetPrevContinuationOrIBSplitSibling(
|
|
const nsIFrame* aFrame) {
|
|
if (nsIFrame* result = aFrame->GetPrevContinuation()) {
|
|
return result;
|
|
}
|
|
|
|
if (aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
|
|
// We are the first frame in the continuation chain. Get the ib-split prev
|
|
// sibling property stored in us.
|
|
return aFrame->GetProperty(nsIFrame::IBSplitPrevSibling());
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::GetNextContinuationOrIBSplitSibling(
|
|
const nsIFrame* aFrame) {
|
|
if (nsIFrame* result = aFrame->GetNextContinuation()) {
|
|
return result;
|
|
}
|
|
|
|
if (aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
|
|
// We only store the ib-split sibling annotation with the first frame in the
|
|
// continuation chain.
|
|
return aFrame->FirstContinuation()->GetProperty(nsIFrame::IBSplitSibling());
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::FirstContinuationOrIBSplitSibling(
|
|
const nsIFrame* aFrame) {
|
|
nsIFrame* result = aFrame->FirstContinuation();
|
|
|
|
if (result->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
|
|
while (auto* f = result->GetProperty(nsIFrame::IBSplitPrevSibling())) {
|
|
result = f;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
nsIFrame* nsLayoutUtils::LastContinuationOrIBSplitSibling(
|
|
const nsIFrame* aFrame) {
|
|
nsIFrame* result = aFrame->FirstContinuation();
|
|
|
|
if (result->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
|
|
while (auto* f = result->GetProperty(nsIFrame::IBSplitSibling())) {
|
|
result = f;
|
|
}
|
|
}
|
|
|
|
return result->LastContinuation();
|
|
}
|
|
|
|
bool nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(
|
|
const nsIFrame* aFrame) {
|
|
if (aFrame->GetPrevContinuation()) {
|
|
return false;
|
|
}
|
|
if (aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT) &&
|
|
aFrame->GetProperty(nsIFrame::IBSplitPrevSibling())) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool nsLayoutUtils::IsViewportScrollbarFrame(nsIFrame* aFrame) {
|
|
if (!aFrame) return false;
|
|
|
|
nsIFrame* rootScrollFrame = aFrame->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 paddings / widths / heights, since it clamps negative calc() to
|
|
* 0.
|
|
*/
|
|
template <typename LengthPercentageLike>
|
|
static bool GetAbsoluteCoord(const LengthPercentageLike& aStyle,
|
|
nscoord& aResult) {
|
|
if (!aStyle.ConvertsToLength()) {
|
|
return false;
|
|
}
|
|
aResult = std::max(0, aStyle.ToLength());
|
|
return true;
|
|
}
|
|
|
|
static nscoord GetBSizePercentBasisAdjustment(StyleBoxSizing aBoxSizing,
|
|
nsIFrame* aFrame,
|
|
bool aHorizontalAxis,
|
|
bool aResolvesAgainstPaddingBox);
|
|
|
|
static bool GetPercentBSize(const LengthPercentage& aStyle, nsIFrame* aFrame,
|
|
bool aHorizontalAxis, nscoord& aResult);
|
|
|
|
// Only call on style coords for which GetAbsoluteCoord returned false.
|
|
template <typename SizeOrMaxSize>
|
|
static bool GetPercentBSize(const SizeOrMaxSize& aStyle, nsIFrame* aFrame,
|
|
bool aHorizontalAxis, nscoord& aResult) {
|
|
if (!aStyle.IsLengthPercentage()) {
|
|
return false;
|
|
}
|
|
return GetPercentBSize(aStyle.AsLengthPercentage(), aFrame, aHorizontalAxis,
|
|
aResult);
|
|
}
|
|
|
|
static bool GetPercentBSize(const LengthPercentage& aStyle, nsIFrame* aFrame,
|
|
bool aHorizontalAxis, nscoord& aResult) {
|
|
if (!aStyle.HasPercent()) {
|
|
return false;
|
|
}
|
|
|
|
MOZ_ASSERT(!aStyle.ConvertsToLength(),
|
|
"GetAbsoluteCoord should have handled this");
|
|
|
|
// During reflow, nsHTMLScrollFrame::ReflowScrolledFrame uses
|
|
// SetComputedHeight on the reflow input 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) {
|
|
MOZ_ASSERT_UNREACHABLE("top of frame tree not a containing block");
|
|
return false;
|
|
}
|
|
|
|
WritingMode wm = f->GetWritingMode();
|
|
|
|
const nsStylePosition* pos = f->StylePosition();
|
|
const auto& bSizeCoord = pos->BSize(wm);
|
|
nscoord h;
|
|
if (!GetAbsoluteCoord(bSizeCoord, h) &&
|
|
!GetPercentBSize(bSizeCoord, f, aHorizontalAxis, h)) {
|
|
LayoutFrameType fType = f->Type();
|
|
if (fType != LayoutFrameType::Viewport &&
|
|
fType != LayoutFrameType::Canvas &&
|
|
fType != LayoutFrameType::PageContent) {
|
|
// 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;
|
|
}
|
|
// 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 auto& maxBSizeCoord = pos->MaxBSize(wm);
|
|
|
|
nscoord maxh;
|
|
if (GetAbsoluteCoord(maxBSizeCoord, maxh) ||
|
|
GetPercentBSize(maxBSizeCoord, f, aHorizontalAxis, maxh)) {
|
|
if (maxh < h) h = maxh;
|
|
}
|
|
|
|
const auto& minBSizeCoord = pos->MinBSize(wm);
|
|
|
|
nscoord minh;
|
|
if (GetAbsoluteCoord(minBSizeCoord, minh) ||
|
|
GetPercentBSize(minBSizeCoord, f, aHorizontalAxis, minh)) {
|
|
if (minh > h) {
|
|
h = minh;
|
|
}
|
|
}
|
|
|
|
// If we're an abspos box, percentages in that case resolve against the
|
|
// padding box.
|
|
//
|
|
// TODO: This could conceivably cause some problems with fieldsets (which are
|
|
// the other 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.
|
|
const bool resolvesAgainstPaddingBox = aFrame->IsAbsolutelyPositioned();
|
|
h += GetBSizePercentBasisAdjustment(pos->mBoxSizing, f, aHorizontalAxis,
|
|
resolvesAgainstPaddingBox);
|
|
|
|
aResult = std::max(aStyle.Resolve(std::max(h, 0)), 0);
|
|
return true;
|
|
}
|
|
|
|
// Return true if aStyle can be resolved to a definite value and if so
|
|
// return that value in aResult.
|
|
static bool GetDefiniteSize(const LengthPercentage& aStyle, nsIFrame* aFrame,
|
|
bool aIsInlineAxis,
|
|
const Maybe<LogicalSize>& aPercentageBasis,
|
|
nscoord* aResult) {
|
|
if (aStyle.ConvertsToLength()) {
|
|
*aResult = aStyle.ToLength();
|
|
return true;
|
|
}
|
|
|
|
if (!aPercentageBasis) {
|
|
return false;
|
|
}
|
|
|
|
auto wm = aFrame->GetWritingMode();
|
|
nscoord pb = aIsInlineAxis ? aPercentageBasis.value().ISize(wm)
|
|
: aPercentageBasis.value().BSize(wm);
|
|
if (pb == NS_UNCONSTRAINEDSIZE) {
|
|
return false;
|
|
}
|
|
*aResult = std::max(0, aStyle.Resolve(pb));
|
|
return true;
|
|
}
|
|
|
|
// Return true if aStyle can be resolved to a definite value and if so
|
|
// return that value in aResult.
|
|
template <typename SizeOrMaxSize>
|
|
static bool GetDefiniteSize(const SizeOrMaxSize& aStyle, nsIFrame* aFrame,
|
|
bool aIsInlineAxis,
|
|
const Maybe<LogicalSize>& aPercentageBasis,
|
|
nscoord* aResult) {
|
|
if (!aStyle.IsLengthPercentage()) {
|
|
return false;
|
|
}
|
|
return GetDefiniteSize(aStyle.AsLengthPercentage(), aFrame, aIsInlineAxis,
|
|
aPercentageBasis, aResult);
|
|
}
|
|
|
|
// NOTE: this function will be replaced by GetDefiniteSizeTakenByBoxSizing (bug
|
|
// 1363918). Please do not add new uses of this function.
|
|
//
|
|
// Get the amount of space to add or subtract out of aFrame's 'block-size' or
|
|
// property value due its borders and paddings, given the box-sizing value in
|
|
// aBoxSizing.
|
|
//
|
|
// aHorizontalAxis is true if our inline direction is horizontal and our block
|
|
// direction is vertical. aResolvesAgainstPaddingBox is true if padding should
|
|
// be added or not removed.
|
|
static nscoord GetBSizePercentBasisAdjustment(StyleBoxSizing aBoxSizing,
|
|
nsIFrame* aFrame,
|
|
bool aHorizontalAxis,
|
|
bool aResolvesAgainstPaddingBox) {
|
|
nscoord adjustment = 0;
|
|
if (aBoxSizing == StyleBoxSizing::Border) {
|
|
const auto& border = aFrame->StyleBorder()->GetComputedBorder();
|
|
adjustment -= aHorizontalAxis ? border.TopBottom() : border.LeftRight();
|
|
}
|
|
if ((aBoxSizing == StyleBoxSizing::Border) == !aResolvesAgainstPaddingBox) {
|
|
const auto& stylePadding = aFrame->StylePadding()->mPadding;
|
|
const LengthPercentage& paddingStart =
|
|
stylePadding.Get(aHorizontalAxis ? eSideTop : eSideLeft);
|
|
const LengthPercentage& 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)) {
|
|
adjustment += aResolvesAgainstPaddingBox ? pad : -pad;
|
|
}
|
|
if (GetAbsoluteCoord(paddingEnd, pad) ||
|
|
GetPercentBSize(paddingEnd, aFrame, aHorizontalAxis, pad)) {
|
|
adjustment += aResolvesAgainstPaddingBox ? pad : -pad;
|
|
}
|
|
}
|
|
return adjustment;
|
|
}
|
|
|
|
// Get the amount of 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.
|
|
// aIsInlineAxis is true if we're computing for aFrame's inline axis.
|
|
// aIgnorePadding is true if padding should be ignored.
|
|
static nscoord GetDefiniteSizeTakenByBoxSizing(
|
|
StyleBoxSizing aBoxSizing, nsIFrame* aFrame, bool aIsInlineAxis,
|
|
bool aIgnorePadding, const Maybe<LogicalSize>& aPercentageBasis) {
|
|
nscoord sizeTakenByBoxSizing = 0;
|
|
if (MOZ_UNLIKELY(aBoxSizing == StyleBoxSizing::Border)) {
|
|
const bool isHorizontalAxis =
|
|
aIsInlineAxis == !aFrame->GetWritingMode().IsVertical();
|
|
const nsStyleBorder* styleBorder = aFrame->StyleBorder();
|
|
sizeTakenByBoxSizing = isHorizontalAxis
|
|
? styleBorder->GetComputedBorder().LeftRight()
|
|
: styleBorder->GetComputedBorder().TopBottom();
|
|
if (!aIgnorePadding) {
|
|
const auto& stylePadding = aFrame->StylePadding()->mPadding;
|
|
const LengthPercentage& pStart =
|
|
stylePadding.Get(isHorizontalAxis ? eSideLeft : eSideTop);
|
|
const LengthPercentage& pEnd =
|
|
stylePadding.Get(isHorizontalAxis ? eSideRight : eSideBottom);
|
|
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 (GetDefiniteSize(pStart, aFrame, aIsInlineAxis, aPercentageBasis,
|
|
&pad) ||
|
|
(aPercentageBasis.isNothing() &&
|
|
GetPercentBSize(pStart, aFrame, isHorizontalAxis, pad))) {
|
|
sizeTakenByBoxSizing += pad;
|
|
}
|
|
if (GetDefiniteSize(pEnd, aFrame, aIsInlineAxis, aPercentageBasis,
|
|
&pad) ||
|
|
(aPercentageBasis.isNothing() &&
|
|
GetPercentBSize(pEnd, aFrame, isHorizontalAxis, pad))) {
|
|
sizeTakenByBoxSizing += pad;
|
|
}
|
|
}
|
|
}
|
|
return sizeTakenByBoxSizing;
|
|
}
|
|
|
|
/**
|
|
* Handles only max-content and 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.
|
|
*/
|
|
static bool GetIntrinsicCoord(nsIFrame::ExtremumLength aStyle,
|
|
gfxContext* aRenderingContext, nsIFrame* aFrame,
|
|
Maybe<nscoord> aInlineSizeFromAspectRatio,
|
|
nsIFrame::SizeProperty aProperty,
|
|
nscoord aContentBoxToBoxSizingDiff,
|
|
nscoord& aResult) {
|
|
if (aStyle == nsIFrame::ExtremumLength::MozAvailable) {
|
|
return false;
|
|
}
|
|
|
|
if (aStyle == nsIFrame::ExtremumLength::FitContentFunction) {
|
|
// fit-content() should be handled by the caller.
|
|
return false;
|
|
}
|
|
|
|
if (aStyle == nsIFrame::ExtremumLength::FitContent) {
|
|
switch (aProperty) {
|
|
case nsIFrame::SizeProperty::Size:
|
|
// handle like 'width: auto'
|
|
return false;
|
|
case nsIFrame::SizeProperty::MaxSize:
|
|
// constrain large 'width' values down to max-content
|
|
aStyle = nsIFrame::ExtremumLength::MaxContent;
|
|
break;
|
|
case nsIFrame::SizeProperty::MinSize:
|
|
// constrain small 'width' or 'max-width' values up to min-content
|
|
aStyle = nsIFrame::ExtremumLength::MinContent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
NS_ASSERTION(aStyle == nsIFrame::ExtremumLength::MinContent ||
|
|
aStyle == nsIFrame::ExtremumLength::MaxContent,
|
|
"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 (aInlineSizeFromAspectRatio) {
|
|
aResult = *aInlineSizeFromAspectRatio;
|
|
} else if (aStyle == nsIFrame::ExtremumLength::MaxContent) {
|
|
aResult = aFrame->GetPrefISize(aRenderingContext);
|
|
} else {
|
|
aResult = aFrame->GetMinISize(aRenderingContext);
|
|
}
|
|
|
|
aResult += aContentBoxToBoxSizingDiff;
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename SizeOrMaxSize>
|
|
static bool GetIntrinsicCoord(const SizeOrMaxSize& aStyle,
|
|
gfxContext* aRenderingContext, nsIFrame* aFrame,
|
|
Maybe<nscoord> aInlineSizeFromAspectRatio,
|
|
nsIFrame::SizeProperty aProperty,
|
|
nscoord aContentBoxToBoxSizingDiff,
|
|
nscoord& aResult) {
|
|
auto length = nsIFrame::ToExtremumLength(aStyle);
|
|
if (!length) {
|
|
return false;
|
|
}
|
|
return GetIntrinsicCoord(*length, aRenderingContext, aFrame,
|
|
aInlineSizeFromAspectRatio, aProperty,
|
|
aContentBoxToBoxSizingDiff, aResult);
|
|
}
|
|
|
|
#undef DEBUG_INTRINSIC_WIDTH
|
|
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
static int32_t gNoiseIndent = 0;
|
|
#endif
|
|
|
|
static nscoord GetFitContentSizeForMaxOrPreferredSize(
|
|
const IntrinsicISizeType aType, const nsIFrame::SizeProperty aProperty,
|
|
const nsIFrame* aFrame, const LengthPercentage& aStyleSize,
|
|
const nscoord aInitialValue, const nscoord aMinContentSize,
|
|
const nscoord aMaxContentSize) {
|
|
MOZ_ASSERT(aProperty != nsIFrame::SizeProperty::MinSize);
|
|
|
|
nscoord size = NS_UNCONSTRAINEDSIZE;
|
|
// 1. Treat fit-content()'s arg as a plain LengthPercentage
|
|
// However, we have to handle the cyclic percentage contribution first.
|
|
//
|
|
// https://drafts.csswg.org/css-sizing-3/#cyclic-percentage-contribution
|
|
if (aType == IntrinsicISizeType::MinISize &&
|
|
aFrame->IsPercentageResolvedAgainstZero(aStyleSize, aProperty)) {
|
|
// Case (c) in the spec.
|
|
// FIXME: This doesn't follow the spec for calc(). We should fix this in
|
|
// Bug 1463700.
|
|
size = 0;
|
|
} else if (!GetAbsoluteCoord(aStyleSize, size)) {
|
|
// As initial value. Case (a) and (b) in the spec.
|
|
size = aInitialValue;
|
|
}
|
|
|
|
// 2. Clamp size by min-content and max-content.
|
|
return std::max(aMinContentSize, std::min(aMaxContentSize, size));
|
|
}
|
|
|
|
/**
|
|
* 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 aInlineSizeFromAspectRatio the content-box inline size computed from
|
|
* aspect-ratio and the definite block size.
|
|
* We use this value to resolve
|
|
* {min|max}-content.
|
|
* @param aFlags same as for IntrinsicForContainer
|
|
* @param aContainerWM the container's WM
|
|
*/
|
|
static nscoord AddIntrinsicSizeOffset(
|
|
gfxContext* aRenderingContext, nsIFrame* aFrame,
|
|
const nsIFrame::IntrinsicSizeOffsetData& aOffsets, IntrinsicISizeType aType,
|
|
StyleBoxSizing aBoxSizing, nscoord aContentSize, nscoord aContentMinSize,
|
|
const StyleSize& aStyleSize, const nscoord* aFixedMinSize,
|
|
const StyleSize& aStyleMinSize, const nscoord* aFixedMaxSize,
|
|
const StyleMaxSize& aStyleMaxSize,
|
|
Maybe<nscoord> aInlineSizeFromAspectRatio, uint32_t aFlags,
|
|
PhysicalAxis aAxis) {
|
|
nscoord result = aContentSize;
|
|
nscoord min = aContentMinSize;
|
|
nscoord coordOutsideSize = 0;
|
|
nscoord contentBoxToBoxSizingDiff = 0;
|
|
|
|
if (!(aFlags & nsLayoutUtils::IGNORE_PADDING)) {
|
|
coordOutsideSize += aOffsets.padding;
|
|
}
|
|
|
|
coordOutsideSize += aOffsets.border;
|
|
|
|
if (aBoxSizing == StyleBoxSizing::Border) {
|
|
// Store the padding of the box so we can pass it into
|
|
// functions that works with content box-sizing.
|
|
contentBoxToBoxSizingDiff = coordOutsideSize;
|
|
|
|
min += coordOutsideSize;
|
|
result = NSCoordSaturatingAdd(result, coordOutsideSize);
|
|
|
|
coordOutsideSize = 0;
|
|
}
|
|
|
|
coordOutsideSize += aOffsets.margin;
|
|
|
|
min += coordOutsideSize;
|
|
|
|
// Compute min-content/max-content for fit-content().
|
|
nscoord minContent = 0;
|
|
nscoord maxContent = NS_UNCONSTRAINEDSIZE;
|
|
if (aStyleSize.IsFitContentFunction() ||
|
|
aStyleMaxSize.IsFitContentFunction() ||
|
|
aStyleMinSize.IsFitContentFunction()) {
|
|
if (aInlineSizeFromAspectRatio) {
|
|
minContent = maxContent = *aInlineSizeFromAspectRatio;
|
|
} else {
|
|
minContent = aFrame->GetMinISize(aRenderingContext);
|
|
maxContent = aFrame->GetPrefISize(aRenderingContext);
|
|
}
|
|
minContent += contentBoxToBoxSizingDiff;
|
|
maxContent += contentBoxToBoxSizingDiff;
|
|
}
|
|
|
|
// Compute size.
|
|
nscoord size = NS_UNCONSTRAINEDSIZE;
|
|
if (aType == IntrinsicISizeType::MinISize &&
|
|
aFrame->IsPercentageResolvedAgainstZero(aStyleSize, aStyleMaxSize)) {
|
|
// XXX bug 1463700: this doesn't handle calc() according to spec
|
|
result = 0; // let |min| handle padding/border/margin
|
|
} else if (GetAbsoluteCoord(aStyleSize, size) ||
|
|
GetIntrinsicCoord(aStyleSize, aRenderingContext, aFrame,
|
|
aInlineSizeFromAspectRatio,
|
|
nsIFrame::SizeProperty::Size,
|
|
contentBoxToBoxSizingDiff, size)) {
|
|
result = size + coordOutsideSize;
|
|
} else if (aStyleSize.IsFitContentFunction()) {
|
|
// |result| here is the content size or border size, depends on
|
|
// StyleBoxSizing. We use it as the initial value when handling the cyclic
|
|
// percentage.
|
|
nscoord initial = result;
|
|
nscoord fitContentFuncSize = GetFitContentSizeForMaxOrPreferredSize(
|
|
aType, nsIFrame::SizeProperty::Size, aFrame,
|
|
aStyleSize.AsFitContentFunction(), initial, minContent, maxContent);
|
|
// Add border and padding.
|
|
result = NSCoordSaturatingAdd(fitContentFuncSize, coordOutsideSize);
|
|
} else {
|
|
result = NSCoordSaturatingAdd(result, coordOutsideSize);
|
|
}
|
|
|
|
// Compute max-size.
|
|
nscoord maxSize = aFixedMaxSize ? *aFixedMaxSize : 0;
|
|
if (aFixedMaxSize || GetIntrinsicCoord(aStyleMaxSize, aRenderingContext,
|
|
aFrame, aInlineSizeFromAspectRatio,
|
|
nsIFrame::SizeProperty::MaxSize,
|
|
contentBoxToBoxSizingDiff, maxSize)) {
|
|
maxSize += coordOutsideSize;
|
|
if (result > maxSize) {
|
|
result = maxSize;
|
|
}
|
|
} else if (aStyleMaxSize.IsFitContentFunction()) {
|
|
nscoord fitContentFuncSize = GetFitContentSizeForMaxOrPreferredSize(
|
|
aType, nsIFrame::SizeProperty::MaxSize, aFrame,
|
|
aStyleMaxSize.AsFitContentFunction(), NS_UNCONSTRAINEDSIZE, minContent,
|
|
maxContent);
|
|
maxSize = NSCoordSaturatingAdd(fitContentFuncSize, coordOutsideSize);
|
|
if (result > maxSize) {
|
|
result = maxSize;
|
|
}
|
|
}
|
|
|
|
// Compute min-size.
|
|
nscoord minSize = aFixedMinSize ? *aFixedMinSize : 0;
|
|
if (aFixedMinSize || GetIntrinsicCoord(aStyleMinSize, aRenderingContext,
|
|
aFrame, aInlineSizeFromAspectRatio,
|
|
nsIFrame::SizeProperty::MinSize,
|
|
contentBoxToBoxSizingDiff, minSize)) {
|
|
minSize += coordOutsideSize;
|
|
if (result < minSize) {
|
|
result = minSize;
|
|
}
|
|
} else if (aStyleMinSize.IsFitContentFunction()) {
|
|
if (!GetAbsoluteCoord(aStyleMinSize.AsFitContentFunction(), minSize)) {
|
|
// FIXME: Bug 1463700, we should resolve only the percentage part to 0
|
|
// such as min-width: fit-content(calc(50% + 50px)).
|
|
minSize = 0;
|
|
}
|
|
nscoord fitContentFuncSize =
|
|
std::max(minContent, std::min(maxContent, minSize));
|
|
minSize = NSCoordSaturatingAdd(fitContentFuncSize, coordOutsideSize);
|
|
if (result < minSize) {
|
|
result = minSize;
|
|
}
|
|
}
|
|
|
|
if (result < min) {
|
|
result = min;
|
|
}
|
|
|
|
const nsStyleDisplay* disp = aFrame->StyleDisplay();
|
|
if (aFrame->IsThemed(disp)) {
|
|
nsPresContext* pc = aFrame->PresContext();
|
|
LayoutDeviceIntSize devSize = pc->Theme()->GetMinimumWidgetSize(
|
|
pc, aFrame, disp->EffectiveAppearance());
|
|
nscoord themeSize = pc->DevPixelsToAppUnits(
|
|
aAxis == eAxisVertical ? devSize.height : devSize.width);
|
|
// GetMinimumWidgetSize() returns a border-box width.
|
|
themeSize += aOffsets.margin;
|
|
if (themeSize > result) {
|
|
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, gfxContext* aRenderingContext, nsIFrame* aFrame,
|
|
IntrinsicISizeType aType, const Maybe<LogicalSize>& aPercentageBasis,
|
|
uint32_t aFlags, nscoord aMarginBoxMinSizeClamp) {
|
|
MOZ_ASSERT(aFrame, "null frame");
|
|
MOZ_ASSERT(aFrame->GetParent(),
|
|
"IntrinsicForAxis called on frame not in tree");
|
|
MOZ_ASSERT(aFrame->GetParent()->Type() != LayoutFrameType::GridContainer ||
|
|
aPercentageBasis.isSome(),
|
|
"grid layout should always pass a percentage basis");
|
|
|
|
const bool horizontalAxis = MOZ_LIKELY(aAxis == eAxisHorizontal);
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
nsIFrame::IndentBy(stderr, gNoiseIndent);
|
|
aFrame->ListTag(stderr);
|
|
printf_stderr(" %s %s intrinsic size for container:\n",
|
|
aType == IntrinsicISizeType::MinISize ? "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;
|
|
|
|
StyleSize styleMinISize =
|
|
horizontalAxis ? stylePos->mMinWidth : stylePos->mMinHeight;
|
|
StyleSize styleISize =
|
|
(aFlags & MIN_INTRINSIC_ISIZE)
|
|
? styleMinISize
|
|
: (horizontalAxis ? stylePos->mWidth : stylePos->mHeight);
|
|
MOZ_ASSERT(!(aFlags & MIN_INTRINSIC_ISIZE) || styleISize.IsAuto() ||
|
|
nsIFrame::ToExtremumLength(styleISize),
|
|
"should only use MIN_INTRINSIC_ISIZE for intrinsic values");
|
|
StyleMaxSize styleMaxISize =
|
|
horizontalAxis ? stylePos->mMaxWidth : stylePos->mMaxHeight;
|
|
|
|
PhysicalAxis ourInlineAxis =
|
|
aFrame->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
|
|
const bool isInlineAxis = aAxis == ourInlineAxis;
|
|
|
|
auto resetIfKeywords = [](StyleSize& aSize, StyleSize& aMinSize,
|
|
StyleMaxSize& aMaxSize) {
|
|
if (!aSize.IsLengthPercentage()) {
|
|
aSize = StyleSize::Auto();
|
|
}
|
|
if (!aMinSize.IsLengthPercentage()) {
|
|
aMinSize = StyleSize::Auto();
|
|
}
|
|
if (!aMaxSize.IsLengthPercentage()) {
|
|
aMaxSize = StyleMaxSize::None();
|
|
}
|
|
};
|
|
// According to the spec, max-content and min-content should behave as the
|
|
// property's initial values in block axis.
|
|
// It also make senses to use the initial values for -moz-fit-content and
|
|
// -moz-available for intrinsic size in block axis. Therefore, we reset them
|
|
// if needed.
|
|
if (!isInlineAxis) {
|
|
resetIfKeywords(styleISize, styleMinISize, styleMaxISize);
|
|
}
|
|
|
|
// 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 (styleMinISize.IsAuto()) {
|
|
// 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);
|
|
}
|
|
|
|
auto childWM = aFrame->GetWritingMode();
|
|
nscoord pmPercentageBasis = NS_UNCONSTRAINEDSIZE;
|
|
if (aPercentageBasis.isSome()) {
|
|
// The padding/margin percentage basis is the inline-size in the parent's
|
|
// writing-mode.
|
|
pmPercentageBasis =
|
|
aFrame->GetParent()->GetWritingMode().IsOrthogonalTo(childWM)
|
|
? aPercentageBasis->BSize(childWM)
|
|
: aPercentageBasis->ISize(childWM);
|
|
}
|
|
nsIFrame::IntrinsicSizeOffsetData offsets =
|
|
MOZ_LIKELY(isInlineAxis)
|
|
? aFrame->IntrinsicISizeOffsets(pmPercentageBasis)
|
|
: aFrame->IntrinsicBSizeOffsets(pmPercentageBasis);
|
|
|
|
auto getContentBoxSizeToBoxSizingAdjust =
|
|
[childWM, &offsets, &aFrame, isInlineAxis,
|
|
pmPercentageBasis](const StyleBoxSizing aBoxSizing) {
|
|
return aBoxSizing == StyleBoxSizing::Border
|
|
? LogicalSize(childWM,
|
|
(isInlineAxis ? offsets
|
|
: aFrame->IntrinsicISizeOffsets(
|
|
pmPercentageBasis))
|
|
.BorderPadding(),
|
|
(!isInlineAxis ? offsets
|
|
: aFrame->IntrinsicBSizeOffsets(
|
|
pmPercentageBasis))
|
|
.BorderPadding())
|
|
: LogicalSize(childWM);
|
|
};
|
|
|
|
Maybe<nscoord> inlineSizeFromAspectRatio;
|
|
Maybe<LogicalSize> contentBoxSizeToBoxSizingAdjust;
|
|
|
|
const bool ignorePadding =
|
|
(aFlags & IGNORE_PADDING) || aFrame->IsAbsolutelyPositioned();
|
|
|
|
// 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.IsMaxContent() || styleISize.IsMinContent()) {
|
|
MOZ_ASSERT(isInlineAxis);
|
|
// -moz-fit-content and -moz-available enumerated widths compute intrinsic
|
|
// widths just like auto.
|
|
// For max-content and min-content, we handle them like
|
|
// specified widths, but ignore box-sizing.
|
|
boxSizing = StyleBoxSizing::Content;
|
|
} else if (!styleISize.ConvertsToLength() &&
|
|
!(styleISize.IsFitContentFunction() &&
|
|
styleISize.AsFitContentFunction().ConvertsToLength()) &&
|
|
!(haveFixedMinISize && haveFixedMaxISize &&
|
|
maxISize <= minISize)) {
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
++gNoiseIndent;
|
|
#endif
|
|
if (MOZ_UNLIKELY(!isInlineAxis)) {
|
|
IntrinsicSize intrinsicSize = aFrame->GetIntrinsicSize();
|
|
const auto& intrinsicBSize =
|
|
horizontalAxis ? intrinsicSize.width : intrinsicSize.height;
|
|
if (intrinsicBSize) {
|
|
result = *intrinsicBSize;
|
|
} 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_ISIZE_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 == IntrinsicISizeType::MinISize
|
|
? aFrame->GetMinISize(aRenderingContext)
|
|
: aFrame->GetPrefISize(aRenderingContext);
|
|
}
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
--gNoiseIndent;
|
|
nsIFrame::IndentBy(stderr, gNoiseIndent);
|
|
aFrame->ListTag(stderr);
|
|
printf_stderr(" %s %s intrinsic size from frame is %d.\n",
|
|
aType == IntrinsicISizeType::MinISize ? "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:
|
|
// 1. 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.
|
|
// 2. The 'B' in |styleBSize|, |styleMinBSize|, and |styleMaxBSize|
|
|
// represents the ratio-determining axis of |aFrame|. It could be the inline
|
|
// axis or the block axis of |aFrame|. (So we are calculating the size
|
|
// along the ratio-dependent axis in this if-branch.)
|
|
StyleSize styleBSize =
|
|
horizontalAxis ? stylePos->mHeight : stylePos->mWidth;
|
|
StyleSize styleMinBSize =
|
|
horizontalAxis ? stylePos->mMinHeight : stylePos->mMinWidth;
|
|
StyleMaxSize styleMaxBSize =
|
|
horizontalAxis ? stylePos->mMaxHeight : stylePos->mMaxWidth;
|
|
|
|
// According to the spec, max-content and min-content should behave as the
|
|
// property's initial values in block axis.
|
|
// It also make senses to use the initial values for -moz-fit-content and
|
|
// -moz-available for intrinsic size in block axis. Therefore, we reset them
|
|
// if needed.
|
|
if (isInlineAxis) {
|
|
resetIfKeywords(styleBSize, styleMinBSize, styleMaxBSize);
|
|
}
|
|
|
|
// If our BSize or min/max-BSize properties are set to values that we can
|
|
// resolve and that will impose a constraint when transferred through our
|
|
// aspect ratio (if we have one), then compute and apply that constraint.
|
|
//
|
|
// (Note: This helper-bool & lambda just let us optimize away the actual
|
|
// transferring-and-clamping arithmetic, for the common case where we can
|
|
// tell that none of the block-axis size properties establish a meaningful
|
|
// transferred constraint.)
|
|
const bool mightHaveBlockAxisConstraintToTransfer = [&] {
|
|
if (!styleBSize.BehavesLikeInitialValueOnBlockAxis()) {
|
|
return true; // BSize property might have a constraint to transfer.
|
|
}
|
|
// Check for min-BSize values that would obviously produce zero in the
|
|
// transferring logic that follows; zero is trivially-ignorable as a
|
|
// transferred lower-bound. (These include the the property's initial
|
|
// value, explicit 0, and values that are equivalent to these.)
|
|
bool minBSizeHasNoConstraintToTransfer =
|
|
styleMinBSize.BehavesLikeInitialValueOnBlockAxis() ||
|
|
(styleMinBSize.IsLengthPercentage() &&
|
|
styleMinBSize.AsLengthPercentage().IsDefinitelyZero());
|
|
if (!minBSizeHasNoConstraintToTransfer) {
|
|
return true; // min-BSize property might have a constraint to transfer.
|
|
}
|
|
if (!styleMaxBSize.BehavesLikeInitialValueOnBlockAxis()) {
|
|
return true; // max-BSize property might have a constraint to transfer.
|
|
}
|
|
return false;
|
|
}();
|
|
if (mightHaveBlockAxisConstraintToTransfer) {
|
|
if (AspectRatio ratio = aFrame->GetAspectRatio()) {
|
|
AddStateBitToAncestors(
|
|
aFrame, NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE);
|
|
|
|
nscoord bSizeTakenByBoxSizing = GetDefiniteSizeTakenByBoxSizing(
|
|
boxSizing, aFrame, !isInlineAxis, ignorePadding, aPercentageBasis);
|
|
contentBoxSizeToBoxSizingAdjust.emplace(
|
|
getContentBoxSizeToBoxSizingAdjust(boxSizing));
|
|
// 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 (GetDefiniteSize(styleBSize, aFrame, !isInlineAxis, aPercentageBasis,
|
|
&h) ||
|
|
(aPercentageBasis.isNothing() &&
|
|
GetPercentBSize(styleBSize, aFrame, horizontalAxis, h))) {
|
|
h = std::max(0, h - bSizeTakenByBoxSizing);
|
|
// We are computing the size of |aFrame|, so we use the inline & block
|
|
// dimensions of |aFrame|.
|
|
result = ratio.ComputeRatioDependentSize(
|
|
isInlineAxis ? eLogicalAxisInline : eLogicalAxisBlock, childWM, h,
|
|
*contentBoxSizeToBoxSizingAdjust);
|
|
// We have get the inlineSizeForAspectRatio value, so we don't have to
|
|
// recompute this again below.
|
|
inlineSizeFromAspectRatio.emplace(result);
|
|
}
|
|
|
|
if (GetDefiniteSize(styleMaxBSize, aFrame, !isInlineAxis,
|
|
aPercentageBasis, &h) ||
|
|
(aPercentageBasis.isNothing() &&
|
|
GetPercentBSize(styleMaxBSize, aFrame, horizontalAxis, h))) {
|
|
h = std::max(0, h - bSizeTakenByBoxSizing);
|
|
nscoord maxISize = ratio.ComputeRatioDependentSize(
|
|
isInlineAxis ? eLogicalAxisInline : eLogicalAxisBlock, childWM, h,
|
|
*contentBoxSizeToBoxSizingAdjust);
|
|
if (maxISize < result) {
|
|
result = maxISize;
|
|
}
|
|
if (maxISize < minContentSize) {
|
|
minContentSize = maxISize;
|
|
}
|
|
}
|
|
|
|
if (GetDefiniteSize(styleMinBSize, aFrame, !isInlineAxis,
|
|
aPercentageBasis, &h) ||
|
|
(aPercentageBasis.isNothing() &&
|
|
GetPercentBSize(styleMinBSize, aFrame, horizontalAxis, h))) {
|
|
h = std::max(0, h - bSizeTakenByBoxSizing);
|
|
nscoord minISize = ratio.ComputeRatioDependentSize(
|
|
isInlineAxis ? eLogicalAxisInline : eLogicalAxisBlock, childWM, h,
|
|
*contentBoxSizeToBoxSizingAdjust);
|
|
if (minISize > result) {
|
|
result = minISize;
|
|
}
|
|
if (minISize > minContentSize) {
|
|
minContentSize = minISize;
|
|
}
|
|
}
|
|
|
|
if (MOZ_UNLIKELY(aFlags & nsLayoutUtils::MIN_INTRINSIC_ISIZE) &&
|
|
// FIXME: Bug 1715681. Should we use eReplacedSizing instead
|
|
// because eReplaced is set on some other frames which are
|
|
// non-replaced elements, e.g. <select>?
|
|
aFrame->IsFrameOfType(nsIFrame::eReplaced)) {
|
|
// This is the 'min-width/height:auto' "transferred size" piece of:
|
|
// https://drafts.csswg.org/css-flexbox-1/#min-size-auto
|
|
// https://drafts.csswg.org/css-grid/#min-size-auto
|
|
// Per spec, we handle it only for replaced elements.
|
|
result = std::min(result, minContentSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aFrame->IsTableFrame()) {
|
|
// Tables can't shrink smaller than their intrinsic minimum width,
|
|
// no matter what.
|
|
min = aFrame->GetMinISize(aRenderingContext);
|
|
}
|
|
|
|
// If we have an aspect-ratio and a definite block size of |aFrame|, we
|
|
// resolve the {min|max}-content size by the aspect-ratio and the block size.
|
|
// If |aAxis| is not the inline axis of |aFrame|, {min|max}-content should
|
|
// behaves as auto, so we don't need this.
|
|
//
|
|
// FIXME(emilio): For -moz-available it seems we shouldn't need this.
|
|
//
|
|
// https://github.com/w3c/csswg-drafts/issues/5032
|
|
// FIXME: Bug 1670151: Use GetAspectRatio() to cover replaced elements (and
|
|
// then we can drop the check of eSupportsAspectRatio).
|
|
const AspectRatio ar = stylePos->mAspectRatio.ToLayoutRatio();
|
|
if (isInlineAxis && ar && nsIFrame::ToExtremumLength(styleISize) &&
|
|
aFrame->IsFrameOfType(nsIFrame::eSupportsAspectRatio) &&
|
|
!inlineSizeFromAspectRatio) {
|
|
// This 'B' in |styleBSize| means the block size of |aFrame|. We go into
|
|
// this branch only if |aAxis| is the inline axis of |aFrame|.
|
|
const StyleSize& styleBSize =
|
|
horizontalAxis ? stylePos->mHeight : stylePos->mWidth;
|
|
nscoord bSize;
|
|
if (GetDefiniteSize(styleBSize, aFrame, !isInlineAxis, aPercentageBasis,
|
|
&bSize) ||
|
|
(aPercentageBasis.isNothing() &&
|
|
GetPercentBSize(styleBSize, aFrame, horizontalAxis, bSize))) {
|
|
// We cannot reuse |boxSizing| because it may be updated to content-box
|
|
// in the above if-branch.
|
|
const StyleBoxSizing boxSizingForAR = stylePos->mBoxSizing;
|
|
if (!contentBoxSizeToBoxSizingAdjust) {
|
|
contentBoxSizeToBoxSizingAdjust.emplace(
|
|
getContentBoxSizeToBoxSizingAdjust(boxSizingForAR));
|
|
}
|
|
nscoord bSizeTakenByBoxSizing =
|
|
GetDefiniteSizeTakenByBoxSizing(boxSizingForAR, aFrame, !isInlineAxis,
|
|
ignorePadding, aPercentageBasis);
|
|
bSize -= bSizeTakenByBoxSizing;
|
|
inlineSizeFromAspectRatio.emplace(ar.ComputeRatioDependentSize(
|
|
LogicalAxis::eLogicalAxisInline, childWM, bSize,
|
|
*contentBoxSizeToBoxSizingAdjust));
|
|
}
|
|
}
|
|
|
|
nscoord contentBoxSize = result;
|
|
result = AddIntrinsicSizeOffset(
|
|
aRenderingContext, aFrame, offsets, aType, boxSizing, result, min,
|
|
styleISize, haveFixedMinISize ? &minISize : nullptr, styleMinISize,
|
|
haveFixedMaxISize ? &maxISize : nullptr, styleMaxISize,
|
|
inlineSizeFromAspectRatio, 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
|
|
nsIFrame::IndentBy(stderr, gNoiseIndent);
|
|
aFrame->ListTag(stderr);
|
|
printf_stderr(" %s %s intrinsic size for container is %d twips.\n",
|
|
aType == IntrinsicISizeType::MinISize ? "min" : "pref",
|
|
horizontalAxis ? "horizontal" : "vertical", result);
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
/* static */
|
|
nscoord nsLayoutUtils::IntrinsicForContainer(gfxContext* 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, Nothing(),
|
|
aFlags);
|
|
}
|
|
|
|
/* static */
|
|
nscoord nsLayoutUtils::MinSizeContributionForAxis(
|
|
PhysicalAxis aAxis, gfxContext* aRC, nsIFrame* aFrame,
|
|
IntrinsicISizeType aType, const LogicalSize& aPercentageBasis,
|
|
uint32_t aFlags) {
|
|
MOZ_ASSERT(aFrame);
|
|
MOZ_ASSERT(aFrame->IsFlexOrGridItem(),
|
|
"only grid/flex items have this behavior currently");
|
|
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
nsIFrame::IndentBy(stderr, gNoiseIndent);
|
|
aFrame->ListTag(stderr);
|
|
printf_stderr(" %s min-isize for %s WM:\n",
|
|
aType == IntrinsicISizeType::MinISize ? "min" : "pref",
|
|
aAxis == eAxisVertical ? "vertical" : "horizontal");
|
|
#endif
|
|
|
|
// Note: this method is only meant for grid/flex items.
|
|
const nsStylePosition* const stylePos = aFrame->StylePosition();
|
|
StyleSize size =
|
|
aAxis == eAxisHorizontal ? stylePos->mMinWidth : stylePos->mMinHeight;
|
|
StyleMaxSize maxSize =
|
|
aAxis == eAxisHorizontal ? stylePos->mMaxWidth : stylePos->mMaxHeight;
|
|
auto childWM = aFrame->GetWritingMode();
|
|
PhysicalAxis ourInlineAxis = childWM.PhysicalAxis(eLogicalAxisInline);
|
|
// According to the spec, max-content and min-content should behave as the
|
|
// property's initial values in block axis.
|
|
// It also make senses to use the initial values for -moz-fit-content and
|
|
// -moz-available for intrinsic size in block axis. Therefore, we reset them
|
|
// if needed.
|
|
if (aAxis != ourInlineAxis) {
|
|
if (size.BehavesLikeInitialValueOnBlockAxis()) {
|
|
size = StyleSize::Auto();
|
|
}
|
|
if (maxSize.BehavesLikeInitialValueOnBlockAxis()) {
|
|
maxSize = StyleMaxSize::None();
|
|
}
|
|
}
|
|
|
|
nscoord minSize;
|
|
nscoord* fixedMinSize = nullptr;
|
|
if (size.IsAuto()) {
|
|
if (aFrame->StyleDisplay()->mOverflowX == StyleOverflow::Visible) {
|
|
size = aAxis == eAxisHorizontal ? stylePos->mWidth : stylePos->mHeight;
|
|
// This is same as above: keywords should behaves as property's initial
|
|
// values in block axis.
|
|
if (aAxis != ourInlineAxis && size.BehavesLikeInitialValueOnBlockAxis()) {
|
|
size = StyleSize::Auto();
|
|
}
|
|
|
|
if (GetAbsoluteCoord(size, minSize)) {
|
|
// We have a definite width/height. This is the "specified size" in:
|
|
// https://drafts.csswg.org/css-grid/#min-size-auto
|
|
fixedMinSize = &minSize;
|
|
} else if (aFrame->IsPercentageResolvedAgainstZero(size, maxSize)) {
|
|
// XXX bug 1463700: this doesn't handle calc() according to spec
|
|
minSize = 0;
|
|
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(size, minSize)) {
|
|
fixedMinSize = &minSize;
|
|
} else if (size.IsLengthPercentage()) {
|
|
MOZ_ASSERT(size.HasPercent());
|
|
minSize = 0;
|
|
fixedMinSize = &minSize;
|
|
}
|
|
|
|
if (!fixedMinSize) {
|
|
// Let the caller deal with the "content size" cases.
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
nsIFrame::IndentBy(stderr, gNoiseIndent);
|
|
aFrame->ListTag(stderr);
|
|
printf_stderr(" %s min-isize is indefinite.\n",
|
|
aType == IntrinsicISizeType::MinISize ? "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);
|
|
|
|
// The padding/margin percentage basis is the inline-size in the parent's
|
|
// writing-mode.
|
|
nscoord pmPercentageBasis =
|
|
aFrame->GetParent()->GetWritingMode().IsOrthogonalTo(childWM)
|
|
? aPercentageBasis.BSize(childWM)
|
|
: aPercentageBasis.ISize(childWM);
|
|
nsIFrame::IntrinsicSizeOffsetData offsets =
|
|
ourInlineAxis == aAxis ? aFrame->IntrinsicISizeOffsets(pmPercentageBasis)
|
|
: aFrame->IntrinsicBSizeOffsets(pmPercentageBasis);
|
|
nscoord result = 0;
|
|
nscoord min = 0;
|
|
// Note: aInlineSizeFromAspectRatio is Nothing() here because we don't handle
|
|
// "content size" cases here (i.e. |fixedMinSize| is false here).
|
|
result = AddIntrinsicSizeOffset(
|
|
aRC, aFrame, offsets, aType, stylePos->mBoxSizing, result, min, size,
|
|
fixedMinSize, size, nullptr, maxSize, Nothing(), aFlags, aAxis);
|
|
|
|
#ifdef DEBUG_INTRINSIC_WIDTH
|
|
nsIFrame::IndentBy(stderr, gNoiseIndent);
|
|
aFrame->ListTag(stderr);
|
|
printf_stderr(" %s min-isize is %d twips.\n",
|
|
aType == IntrinsicISizeType::MinISize ? "min" : "pref", result);
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
/* static */
|
|
nscoord nsLayoutUtils::ComputeBSizeDependentValue(
|
|
nscoord aContainingBlockBSize, const LengthPercentageOrAuto& aCoord) {
|
|
// XXXldb Some callers explicitly check aContainingBlockBSize
|
|
// against NS_UNCONSTRAINEDSIZE *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_ASSERTION(
|
|
NS_UNCONSTRAINEDSIZE != aContainingBlockBSize || !aCoord.HasPercent(),
|
|
"unexpected containing block block-size");
|
|
|
|
if (aCoord.IsAuto()) {
|
|
return 0;
|
|
}
|
|
|
|
return aCoord.AsLengthPercentage().Resolve(aContainingBlockBSize);
|
|
}
|
|
|
|
/* 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.PopLastElement();
|
|
|
|
// 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.PopLastElement();
|
|
|
|
f->MarkIntrinsicISizesDirty();
|
|
|
|
if (f->IsPlaceholderFrame()) {
|
|
nsIFrame* oof = nsPlaceholderFrame::GetRealFrameForPlaceholder(f);
|
|
if (!nsLayoutUtils::IsProperAncestorFrame(subtreeRoot, oof)) {
|
|
// We have another distinct subtree we need to mark.
|
|
subtrees.AppendElement(oof);
|
|
}
|
|
}
|
|
|
|
for (const auto& childList : f->ChildLists()) {
|
|
for (nsIFrame* kid : childList.mList) {
|
|
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.PopLastElement();
|
|
|
|
if (!f->HasAnyStateBits(
|
|
NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
|
|
continue;
|
|
}
|
|
f->MarkIntrinsicISizesDirty();
|
|
|
|
for (const auto& childList : f->ChildLists()) {
|
|
for (nsIFrame* kid : childList.mList) {
|
|
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,
|
|
gfxContext* aRenderingContext) {
|
|
NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
|
|
"should not be container for font size inflation");
|
|
|
|
nsIFrame::InlineMinISizeData data;
|
|
DISPLAY_MIN_INLINE_SIZE(aFrame, data.mPrevLines);
|
|
aFrame->AddInlineMinISize(aRenderingContext, &data);
|
|
data.ForceBreak();
|
|
return data.mPrevLines;
|
|
}
|
|
|
|
/* static */
|
|
nscoord nsLayoutUtils::PrefISizeFromInline(nsIFrame* aFrame,
|
|
gfxContext* aRenderingContext) {
|
|
NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
|
|
"should not be container for font size inflation");
|
|
|
|
nsIFrame::InlinePrefISizeData data;
|
|
DISPLAY_PREF_INLINE_SIZE(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(nsIFrame* aFrame) {
|
|
nsPresContext* pc = aFrame->PresContext();
|
|
if (pc->GetBackgroundColorDraw() || pc->GetBackgroundImageDraw()) {
|
|
return false;
|
|
}
|
|
return aFrame->StyleVisibility()->mPrintColorAdjust !=
|
|
StylePrintColorAdjust::Exact;
|
|
}
|
|
|
|
nscolor nsLayoutUtils::DarkenColorIfNeeded(nsIFrame* aFrame, nscolor aColor) {
|
|
return ShouldDarkenColors(aFrame) ? DarkenColor(aColor) : 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, gfxContext::SnapOption::IgnoreScale)) {
|
|
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, gfxContext::SnapOption::IgnoreScale)) {
|
|
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,
|
|
gfxContext& aContext) {
|
|
nsPresContext* presContext = aFrame->PresContext();
|
|
if (presContext->BidiEnabled()) {
|
|
mozilla::intl::BidiEmbeddingLevel level =
|
|
nsBidiPresUtils::BidiLevelFromStyle(aFrame->Style());
|
|
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,
|
|
gfxContext* aContext, const char16_t* aString,
|
|
int32_t aLength, nsPoint aPoint,
|
|
ComputedStyle* aComputedStyle,
|
|
DrawStringFlags aFlags) {
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
// If caller didn't pass a style, use the frame's.
|
|
if (!aComputedStyle) {
|
|
aComputedStyle = aFrame->Style();
|
|
}
|
|
|
|
if (aFlags & DrawStringFlags::ForceHorizontal) {
|
|
aFontMetrics.SetVertical(false);
|
|
} else {
|
|
aFontMetrics.SetVertical(WritingMode(aComputedStyle).IsVertical());
|
|
}
|
|
|
|
aFontMetrics.SetTextOrientation(
|
|
aComputedStyle->StyleVisibility()->mTextOrientation);
|
|
|
|
nsPresContext* presContext = aFrame->PresContext();
|
|
if (presContext->BidiEnabled()) {
|
|
mozilla::intl::BidiEmbeddingLevel level =
|
|
nsBidiPresUtils::BidiLevelFromStyle(aComputedStyle);
|
|
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,
|
|
const nsPoint& aPoint,
|
|
nsFontMetrics& aFontMetrics,
|
|
gfxContext& 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, gfxContext* aContext, const nsRect& aTextRect,
|
|
const nsRect& aDirtyRect, const nscolor& aForegroundColor,
|
|
TextShadowCallback aCallback, void* aCallbackData) {
|
|
const nsStyleText* textStyle = aFrame->StyleText();
|
|
auto shadows = textStyle->mTextShadow.AsSpan();
|
|
if (shadows.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
// Text shadow happens with the last value being painted at the back,
|
|
// ie. it is painted first.
|
|
gfxContext* aDestCtx = aContext;
|
|
for (auto& shadow : Reversed(shadows)) {
|
|
nsPoint shadowOffset(shadow.horizontal.ToAppUnits(),
|
|
shadow.vertical.ToAppUnits());
|
|
nscoord blurRadius = std::max(shadow.blur.ToAppUnits(), 0);
|
|
|
|
nsRect shadowRect(aTextRect);
|
|
shadowRect.MoveBy(shadowOffset);
|
|
|
|
nsPresContext* presCtx = aFrame->PresContext();
|
|
nsContextBoxBlur contextBoxBlur;
|
|
|
|
nscolor shadowColor = shadow.color.CalcColor(aForegroundColor);
|
|
|
|
// Webrender just needs the shadow details
|
|
if (auto* textDrawer = aContext->GetTextDrawer()) {
|
|
wr::Shadow wrShadow;
|
|
|
|
wrShadow.offset = {
|
|
presCtx->AppUnitsToFloatDevPixels(shadow.horizontal.ToAppUnits()),
|
|
presCtx->AppUnitsToFloatDevPixels(shadow.vertical.ToAppUnits())};
|
|
|
|
wrShadow.blur_radius = presCtx->AppUnitsToFloatDevPixels(blurRadius);
|
|
wrShadow.color = wr::ToColorF(ToDeviceColor(shadowColor));
|
|
|
|
// Gecko already inflates the bounding rect of text shadows,
|
|
// so tell WR not to inflate again.
|
|
bool inflate = false;
|
|
textDrawer->AppendShadow(wrShadow, inflate);
|
|
continue;
|
|
}
|
|
|
|
gfxContext* shadowContext = contextBoxBlur.Init(
|
|
shadowRect, 0, blurRadius, presCtx->AppUnitsPerDevPixel(), aDestCtx,
|
|
aDirtyRect, nullptr,
|
|
nsContextBoxBlur::DISABLE_HARDWARE_ACCELERATION_BLUR);
|
|
if (!shadowContext) continue;
|
|
|
|
aDestCtx->Save();
|
|
aDestCtx->NewPath();
|
|
aDestCtx->SetColor(sRGBColor::FromABGR(shadowColor));
|
|
|
|
// The callback will draw whatever we want to blur as a shadow.
|
|
aCallback(shadowContext, 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) {
|
|
if (aFrame->StyleDisplay()->IsContainLayout()) {
|
|
return false;
|
|
}
|
|
const nsBlockFrame* block = do_QueryFrame(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.
|
|
LayoutFrameType fType = aFrame->Type();
|
|
if (fType == LayoutFrameType::TableWrapper ||
|
|
fType == LayoutFrameType::FlexContainer ||
|
|
fType == LayoutFrameType::GridContainer) {
|
|
if ((fType == LayoutFrameType::GridContainer &&
|
|
aFrame->HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) ||
|
|
(fType == LayoutFrameType::FlexContainer &&
|
|
aFrame->HasAnyStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE)) ||
|
|
(fType == LayoutFrameType::TableWrapper &&
|
|
static_cast<const nsTableWrapperFrame*>(aFrame)->GetRowCount() ==
|
|
0)) {
|
|
// empty grid/flex/table container
|
|
aResult->mBStart = 0;
|
|
aResult->mBaseline = Baseline::SynthesizeBOffsetFromBorderBox(
|
|
aFrame, aWM, BaselineSharingGroup::First);
|
|
aResult->mBEnd = aFrame->BSize(aWM);
|
|
return true;
|
|
}
|
|
if (fType == LayoutFrameType::TableWrapper &&
|
|
aFrame->GetWritingMode().IsOrthogonalTo(aWM)) {
|
|
// For tables, the upcoming GetLogicalBaseline call would determine the
|
|
// table's baseline from its first row that has a baseline. However:
|
|
// this doesn't make sense for an orthogonal writing mode, so in that
|
|
// case we report no baseline instead. The table wrapper and its rows
|
|
// should flow the same way, so we can bail out early, but this logic
|
|
// wouldn't be correct to transplant into other places in the codebase
|
|
// (Depending on how bug 1786633 is resolved).
|
|
return false;
|
|
}
|
|
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 (nsIScrollableFrame* sFrame =
|
|
do_QueryFrame(const_cast<nsIFrame*>(aFrame))) {
|
|
LinePosition kidPosition;
|
|
if (GetFirstLinePosition(aWM, sFrame->GetScrolledFrame(), &kidPosition)) {
|
|
// Consider only the border (Padding is ignored, since
|
|
// `-moz-scrolled-content` inherits and handles the padding) that
|
|
// contributes to the kid's position, not the scrolling, so we get the
|
|
// initial position.
|
|
*aResult = kidPosition + aFrame->GetLogicalUsedBorder(aWM).BStart(aWM);
|
|
// Don't want to move the line's block positioning, but the baseline
|
|
// needs to be clamped (See bug 1791069).
|
|
aResult->mBaseline = std::clamp(aResult->mBaseline, 0,
|
|
aFrame->GetLogicalSize(aWM).BSize(aWM));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (fType == LayoutFrameType::FieldSet) {
|
|
LinePosition kidPosition;
|
|
// Get the first baseline from the fieldset content, not from the legend.
|
|
nsIFrame* kid = static_cast<const nsFieldSetFrame*>(aFrame)->GetInner();
|
|
if (kid && GetFirstLinePosition(aWM, kid, &kidPosition)) {
|
|
*aResult = kidPosition +
|
|
kid->GetLogicalNormalPosition(aWM, aFrame->GetSize()).B(aWM);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (fType == LayoutFrameType::ColumnSet) {
|
|
// Note(dshin): This is basically the same as
|
|
// `nsColumnSetFrame::GetNaturalBaselineBOffset`, but with line start and
|
|
// end, all stored in `LinePosition`. Field value apart from baseline is
|
|
// used in one other place
|
|
// (`nsBlockFrame`) - if that goes away, this becomes a duplication that
|
|
// should be removed.
|
|
LinePosition kidPosition;
|
|
for (const auto* kid : aFrame->PrincipalChildList()) {
|
|
LinePosition position;
|
|
if (!GetFirstLinePosition(aWM, kid, &position)) {
|
|
continue;
|
|
}
|
|
if (position.mBaseline < kidPosition.mBaseline) {
|
|
kidPosition = position;
|
|
}
|
|
}
|
|
if (kidPosition.mBaseline != nscoord_MAX) {
|
|
*aResult = kidPosition;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// No baseline.
|
|
return false;
|
|
}
|
|
|
|
for (const auto& line : block->Lines()) {
|
|
if (line.IsBlock()) {
|
|
const 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 auto& 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 (0 != line.BSize() || !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) {
|
|
if (aFrame->StyleDisplay()->IsContainLayout()) {
|
|
return false;
|
|
}
|
|
|
|
const nsBlockFrame* block = do_QueryFrame(aFrame);
|
|
if (!block) {
|
|
if (nsIScrollableFrame* sFrame = do_QueryFrame(aFrame)) {
|
|
// Use the baseline position only if the last line's baseline is within
|
|
// the scrolling frame's box in the initial position.
|
|
const auto* scrolledFrame = sFrame->GetScrolledFrame();
|
|
if (!GetLastLineBaseline(aWM, scrolledFrame, aResult)) {
|
|
return false;
|
|
}
|
|
// Go from scrolled frame to scrollable frame position.
|
|
*aResult += aFrame->GetLogicalUsedBorder(aWM).BStart(aWM);
|
|
const auto maxBaseline = aFrame->GetLogicalSize(aWM).BSize(aWM);
|
|
// Clamp the last baseline to border (See bug 1791069).
|
|
*aResult = std::clamp(*aResult, 0, maxBaseline);
|
|
return true;
|
|
}
|
|
|
|
// No need to duplicate the baseline logic (Unlike `GetFirstLinePosition`,
|
|
// we don't need to return any other value apart from baseline), just defer
|
|
// to `GetNaturalBaselineBOffset`. Technically, we could do this at
|
|
// `ColumnSetWrapperFrame` level, but this keeps it symmetric to
|
|
// `GetFirstLinePosition`.
|
|
if (aFrame->IsColumnSetFrame()) {
|
|
const auto baseline = aFrame->GetNaturalBaselineBOffset(
|
|
aWM, BaselineSharingGroup::Last, BaselineExportContext::Other);
|
|
if (!baseline) {
|
|
return false;
|
|
}
|
|
*aResult = aFrame->BSize(aWM) - *baseline;
|
|
return true;
|
|
}
|
|
// No baseline.
|
|
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;
|
|
}
|
|
if (kid->IsScrollFrame()) {
|
|
// Defer to nsIFrame::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) {
|
|
MOZ_ASSERT(aFrame, "null ptr");
|
|
|
|
nscoord contentBEnd = 0;
|
|
|
|
for (const auto& line : aFrame->Lines()) {
|
|
if (line.IsBlock()) {
|
|
nsIFrame* child = line.mFirstChild;
|
|
const auto& 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) {
|
|
MOZ_ASSERT(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->ScrollableOverflowRect().Size());
|
|
if (overflowSize.BSize(aWM) > contentBEnd) {
|
|
FrameChildListIDs skip = {FrameChildListID::Overflow,
|
|
FrameChildListID::ExcessOverflowContainers,
|
|
FrameChildListID::OverflowOutOfFlow};
|
|
nsBlockFrame* blockFrame = do_QueryFrame(aFrame);
|
|
if (blockFrame) {
|
|
contentBEnd =
|
|
std::max(contentBEnd, CalculateBlockContentBEnd(aWM, blockFrame));
|
|
skip += FrameChildListID::Principal;
|
|
}
|
|
for (const auto& [list, listID] : aFrame->ChildLists()) {
|
|
if (!skip.contains(listID)) {
|
|
for (nsIFrame* child : list) {
|
|
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()->IsScrollFrame()))
|
|
break;
|
|
}
|
|
if (layer) return layer;
|
|
return aFrame->PresShell()->GetRootFrame();
|
|
}
|
|
|
|
SamplingFilter nsLayoutUtils::GetSamplingFilterForFrame(nsIFrame* aForFrame) {
|
|
switch (aForFrame->UsedImageRendering()) {
|
|
case StyleImageRendering::Smooth:
|
|
case StyleImageRendering::Optimizequality:
|
|
return SamplingFilter::LINEAR;
|
|
case StyleImageRendering::CrispEdges:
|
|
case StyleImageRendering::Optimizespeed:
|
|
case StyleImageRendering::Pixelated:
|
|
return SamplingFilter::POINT;
|
|
case StyleImageRendering::Auto:
|
|
return SamplingFilter::GOOD;
|
|
}
|
|
MOZ_ASSERT_UNREACHABLE("Unknown image-rendering value");
|
|
return SamplingFilter::GOOD;
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
MatrixScalesDouble scale(aTo.width / aFrom.width, aTo.height / aFrom.height);
|
|
gfxPoint translation(aTo.x - aFrom.x * scale.xScale,
|
|
aTo.y - aFrom.y * scale.yScale);
|
|
return gfxMatrix(scale.xScale, 0, 0, scale.yScale, 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->CurrentMatrixDouble();
|
|
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,
|
|
gfxContext::SnapOption::IgnoreScale) &&
|
|
aCtx->UserToDevicePixelSnapped(dest,
|
|
gfxContext::SnapOption::IgnoreScale)) {
|
|
// 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();
|
|
auto scaleFactors = currentMatrix.ScaleFactors();
|
|
if (!didSnap) {
|
|
snappedDestSize.Scale(scaleFactors.xScale, scaleFactors.yScale);
|
|
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()) {
|
|
return SnappedImageDrawingParameters();
|
|
}
|
|
|
|
nsIntSize intImageSize = aImage->OptimalImageSizeForDest(
|
|
snappedDestSize, imgIContainer::FRAME_CURRENT, aSamplingFilter,
|
|
aImageFlags);
|
|
|
|
nsIntSize svgViewportSize;
|
|
if (scaleFactors.xScale == 1.0 && scaleFactors.yScale == 1.0) {
|
|
// intImageSize is scaled by currentMatrix. But since there are no scale
|
|
// factors in currentMatrix, it is safe to assign intImageSize to
|
|
// svgViewportSize directly.
|
|
svgViewportSize = intImageSize;
|
|
} else {
|
|
// We should not take into account any transformation of currentMatrix
|
|
// when computing svg viewport size. Since currentMatrix contains scale
|
|
// factors, we need to recompute SVG viewport by unscaled devPixelDest.
|
|
svgViewportSize = aImage->OptimalImageSizeForDest(
|
|
devPixelDest.Size(), imgIContainer::FRAME_CURRENT, aSamplingFilter,
|
|
aImageFlags);
|
|
}
|
|
|
|
gfxSize imageSize(intImageSize.width, intImageSize.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.TransformPoint(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()
|
|
: 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.TransformRect(devPixelDirty);
|
|
devPixelDirty.RoundOut();
|
|
fill = fill.Intersect(devPixelDirty);
|
|
}
|
|
if (fill.IsEmpty()) return SnappedImageDrawingParameters();
|
|
|
|
gfxRect imageSpaceFill(didSnap ? invTransform.TransformRect(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,
|
|
CSSIntSize(svgViewportSize.width, svgViewportSize.height));
|
|
}
|
|
|
|
static ImgDrawResult 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) {
|
|
ImgDrawResult result = ImgDrawResult::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);
|
|
|
|
aContext.SetMatrixDouble(params.imageSpaceToDeviceSpace);
|
|
|
|
SVGImageContext newContext = aSVGContext;
|
|
if (!aSVGContext.GetViewportSize()) {
|
|
newContext.SetViewportSize(Some(params.svgViewportSize));
|
|
}
|
|
|
|
result = aImage->Draw(&aContext, params.size, params.region,
|
|
imgIContainer::FRAME_CURRENT, aSamplingFilter,
|
|
newContext, aImageFlags, aOpacity);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* static */
|
|
ImgDrawResult nsLayoutUtils::DrawSingleUnscaledImage(
|
|
gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
|
|
const SamplingFilter aSamplingFilter, const nsPoint& aDest,
|
|
const nsRect* aDirty, const SVGImageContext& aSVGContext,
|
|
uint32_t aImageFlags, const nsRect* aSourceArea) {
|
|
CSSIntSize imageSize;
|
|
aImage->GetWidth(&imageSize.width);
|
|
aImage->GetHeight(&imageSize.height);
|
|
aImage->GetResolution().ApplyTo(imageSize.width, imageSize.height);
|
|
|
|
if (imageSize.width < 1 || imageSize.height < 1) {
|
|
NS_WARNING("Image width or height is non-positive");
|
|
return ImgDrawResult::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,
|
|
aSVGContext, aImageFlags);
|
|
}
|
|
|
|
/* static */
|
|
ImgDrawResult nsLayoutUtils::DrawSingleImage(
|
|
gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
|
|
SamplingFilter aSamplingFilter, const nsRect& aDest, const nsRect& aDirty,
|
|
const SVGImageContext& aSVGContext, uint32_t aImageFlags,
|
|
const nsPoint* aAnchorPoint) {
|
|
// NOTE(emilio): We can hardcode resolution to 1 here, since we're interested
|
|
// in the actual image pixels, for snapping purposes, not on the adjusted
|
|
// size.
|
|
CSSIntSize pixelImageSize(ComputeSizeForDrawingWithFallback(
|
|
aImage, ImageResolution(), aDest.Size()));
|
|
if (pixelImageSize.width < 1 || pixelImageSize.height < 1) {
|
|
NS_ASSERTION(pixelImageSize.width >= 0 && pixelImageSize.height >= 0,
|
|
"Image width or height is negative");
|
|
return ImgDrawResult::SUCCESS; // no point in drawing a zero size image
|
|
}
|
|
|
|
const nsSize imageSize(CSSPixel::ToAppUnits(pixelImageSize));
|
|
const nsRect source(nsPoint(), imageSize);
|
|
const 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, aImage, aSamplingFilter,
|
|
dest, fill,
|
|
aAnchorPoint ? *aAnchorPoint : fill.TopLeft(),
|
|
aDirty, aSVGContext, aImageFlags);
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::ComputeSizeForDrawing(
|
|
imgIContainer* aImage, const ImageResolution& aResolution,
|
|
/* outparam */ CSSIntSize& aImageSize,
|
|
/* outparam */ AspectRatio& aIntrinsicRatio,
|
|
/* outparam */ bool& aGotWidth,
|
|
/* outparam */ bool& aGotHeight) {
|
|
aGotWidth = NS_SUCCEEDED(aImage->GetWidth(&aImageSize.width));
|
|
aGotHeight = NS_SUCCEEDED(aImage->GetHeight(&aImageSize.height));
|
|
Maybe<AspectRatio> intrinsicRatio = aImage->GetIntrinsicRatio();
|
|
aIntrinsicRatio = intrinsicRatio.valueOr(AspectRatio());
|
|
|
|
if (aGotWidth) {
|
|
aResolution.ApplyXTo(aImageSize.width);
|
|
}
|
|
if (aGotHeight) {
|
|
aResolution.ApplyYTo(aImageSize.height);
|
|
}
|
|
|
|
if (!(aGotWidth && aGotHeight) && intrinsicRatio.isNothing()) {
|
|
// 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);
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
CSSIntSize nsLayoutUtils::ComputeSizeForDrawingWithFallback(
|
|
imgIContainer* aImage, const ImageResolution& aResolution,
|
|
const nsSize& aFallbackSize) {
|
|
CSSIntSize imageSize;
|
|
AspectRatio imageRatio;
|
|
bool gotHeight, gotWidth;
|
|
ComputeSizeForDrawing(aImage, aResolution, 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) {
|
|
imageSize.width = imageRatio.ApplyTo(imageSize.height);
|
|
gotWidth = true;
|
|
}
|
|
} else {
|
|
if (imageRatio) {
|
|
imageSize.height = imageRatio.Inverted().ApplyTo(imageSize.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 */ LayerIntRect SnapRectForImage(
|
|
const gfx::Matrix& aTransform, const gfx::MatrixScales& aScaleFactors,
|
|
const LayoutDeviceRect& aRect) {
|
|
// Attempt to snap pixels, the same as ComputeSnappedImageDrawingParameters.
|
|
// Any changes to the algorithm here will need to be reflected there.
|
|
bool snapped = false;
|
|
LayerIntRect snapRect;
|
|
if (!aTransform.HasNonAxisAlignedTransform() && aTransform._11 > 0.0 &&
|
|
aTransform._22 > 0.0) {
|
|
gfxRect rect(gfxPoint(aRect.X(), aRect.Y()),
|
|
gfxSize(aRect.Width(), aRect.Height()));
|
|
|
|
gfxPoint p1 =
|
|
ThebesPoint(aTransform.TransformPoint(ToPoint(rect.TopLeft())));
|
|
gfxPoint p2 =
|
|
ThebesPoint(aTransform.TransformPoint(ToPoint(rect.TopRight())));
|
|
gfxPoint p3 =
|
|
ThebesPoint(aTransform.TransformPoint(ToPoint(rect.BottomRight())));
|
|
|
|
if (p2 == gfxPoint(p1.x, p3.y) || p2 == gfxPoint(p3.x, p1.y)) {
|
|
p1.Round();
|
|
p3.Round();
|
|
|
|
IntPoint p1i(int32_t(p1.x), int32_t(p1.y));
|
|
IntPoint p3i(int32_t(p3.x), int32_t(p3.y));
|
|
|
|
snapRect.MoveTo(std::min(p1i.x, p3i.x), std::min(p1i.y, p3i.y));
|
|
snapRect.SizeTo(std::max(p1i.x, p3i.x) - snapRect.X(),
|
|
std::max(p1i.y, p3i.y) - snapRect.Y());
|
|
snapped = true;
|
|
}
|
|
}
|
|
|
|
if (!snapped) {
|
|
// If we couldn't snap directly with the transform, we need to go best
|
|
// effort in layer pixels.
|
|
snapRect = RoundedToInt(
|
|
aRect * LayoutDeviceToLayerScale2D::FromUnknownScale(aScaleFactors));
|
|
}
|
|
|
|
// An empty size is unacceptable so we ensure our suggested size is at least
|
|
// 1 pixel wide/tall.
|
|
if (snapRect.Width() < 1) {
|
|
snapRect.SetWidth(1);
|
|
}
|
|
if (snapRect.Height() < 1) {
|
|
snapRect.SetHeight(1);
|
|
}
|
|
return snapRect;
|
|
}
|
|
|
|
/* static */
|
|
IntSize nsLayoutUtils::ComputeImageContainerDrawingParameters(
|
|
imgIContainer* aImage, nsIFrame* aForFrame,
|
|
const LayoutDeviceRect& aDestRect, const LayoutDeviceRect& aFillRect,
|
|
const StackingContextHelper& aSc, uint32_t aFlags,
|
|
SVGImageContext& aSVGContext, Maybe<ImageIntRegion>& aRegion) {
|
|
MOZ_ASSERT(aImage);
|
|
MOZ_ASSERT(aForFrame);
|
|
|
|
MatrixScales scaleFactors = aSc.GetInheritedScale();
|
|
SamplingFilter samplingFilter =
|
|
nsLayoutUtils::GetSamplingFilterForFrame(aForFrame);
|
|
|
|
// Compute our SVG context parameters, if any. Don't replace the viewport
|
|
// size if it was already set, prefer what the caller gave.
|
|
SVGImageContext::MaybeStoreContextPaint(aSVGContext, aForFrame, aImage);
|
|
if ((scaleFactors.xScale != 1.0 || scaleFactors.yScale != 1.0) &&
|
|
aImage->GetType() == imgIContainer::TYPE_VECTOR &&
|
|
(!aSVGContext.GetViewportSize())) {
|
|
gfxSize gfxDestSize(aDestRect.Width(), aDestRect.Height());
|
|
IntSize viewportSize = aImage->OptimalImageSizeForDest(
|
|
gfxDestSize, imgIContainer::FRAME_CURRENT, samplingFilter, aFlags);
|
|
|
|
CSSIntSize cssViewportSize(viewportSize.width, viewportSize.height);
|
|
aSVGContext.SetViewportSize(Some(cssViewportSize));
|
|
}
|
|
|
|
const gfx::Matrix& itm = aSc.GetInheritedTransform();
|
|
LayerIntRect destRect = SnapRectForImage(itm, scaleFactors, aDestRect);
|
|
|
|
// Since we always decode entire raster images, we only care about the
|
|
// ImageIntRegion for vector images when we are recording blobs, for which we
|
|
// may only draw part of in some cases.
|
|
if ((aImage->GetType() != imgIContainer::TYPE_VECTOR) ||
|
|
!(aFlags & imgIContainer::FLAG_RECORD_BLOB)) {
|
|
// If the transform scale of our stacking context helper is being animated
|
|
// on the compositor then the transform will have the current value of the
|
|
// scale, but the scale factors will have max value of the scale animation.
|
|
// So we want to ask for a decoded image that can fulfill that larger size.
|
|
int32_t scaleWidth = int32_t(ceil(aDestRect.Width() * scaleFactors.xScale));
|
|
if (scaleWidth > destRect.width + 2) {
|
|
destRect.width = scaleWidth;
|
|
}
|
|
int32_t scaleHeight =
|
|
int32_t(ceil(aDestRect.Height() * scaleFactors.yScale));
|
|
if (scaleHeight > destRect.height + 2) {
|
|
destRect.height = scaleHeight;
|
|
}
|
|
|
|
return aImage->OptimalImageSizeForDest(
|
|
gfxSize(destRect.Width(), destRect.Height()),
|
|
imgIContainer::FRAME_CURRENT, samplingFilter, aFlags);
|
|
}
|
|
|
|
// We only use the region rect with blob recordings. This is because when we
|
|
// rasterize an SVG image in process, we always create a complete
|
|
// rasterization of the whole image which can be given to any caller, while
|
|
// we support partial rasterization with the blob recordings.
|
|
if (aFlags & imgIContainer::FLAG_RECORD_BLOB) {
|
|
// If the dest rect contains the fill rect, then we are only displaying part
|
|
// of the vector image. We need to calculate the restriction region to avoid
|
|
// drawing more than we need, and sampling outside the desired bounds.
|
|
LayerIntRect clipRect = SnapRectForImage(itm, scaleFactors, aFillRect);
|
|
if (destRect.Contains(clipRect)) {
|
|
LayerIntRect restrictRect = destRect.Intersect(clipRect);
|
|
restrictRect.MoveBy(-destRect.TopLeft());
|
|
|
|
if (restrictRect.Width() < 1) {
|
|
restrictRect.SetWidth(1);
|
|
}
|
|
if (restrictRect.Height() < 1) {
|
|
restrictRect.SetHeight(1);
|
|
}
|
|
|
|
if (restrictRect.X() != 0 || restrictRect.Y() != 0 ||
|
|
restrictRect.Size() != destRect.Size()) {
|
|
IntRect sampleRect = restrictRect.ToUnknownRect();
|
|
aRegion = Some(ImageIntRegion::CreateWithSamplingRestriction(
|
|
sampleRect, sampleRect, ExtendMode::CLAMP));
|
|
}
|
|
}
|
|
}
|
|
|
|
// VectorImage::OptimalImageSizeForDest will just round up, but we already
|
|
// have an integer size.
|
|
return destRect.Size().ToUnknownSize();
|
|
}
|
|
|
|
/* static */
|
|
nsPoint nsLayoutUtils::GetBackgroundFirstTilePos(const nsPoint& aDest,
|
|
const nsPoint& aFill,
|
|
const nsSize& aRepeatSize) {
|
|
return nsPoint(NSToIntFloor(float(aFill.x - aDest.x) / aRepeatSize.width) *
|
|
aRepeatSize.width,
|
|
NSToIntFloor(float(aFill.y - aDest.y) / aRepeatSize.height) *
|
|
aRepeatSize.height) +
|
|
aDest;
|
|
}
|
|
|
|
/* static */
|
|
ImgDrawResult nsLayoutUtils::DrawBackgroundImage(
|
|
gfxContext& aContext, nsIFrame* aForFrame, nsPresContext* aPresContext,
|
|
imgIContainer* aImage, SamplingFilter aSamplingFilter, const nsRect& aDest,
|
|
const nsRect& aFill, const nsSize& aRepeatSize, const nsPoint& aAnchor,
|
|
const nsRect& aDirty, uint32_t aImageFlags, ExtendMode aExtendMode,
|
|
float aOpacity) {
|
|
AUTO_PROFILER_LABEL("nsLayoutUtils::DrawBackgroundImage",
|
|
GRAPHICS_Rasterization);
|
|
|
|
CSSIntSize destCSSSize{nsPresContext::AppUnitsToIntCSSPixels(aDest.width),
|
|
nsPresContext::AppUnitsToIntCSSPixels(aDest.height)};
|
|
|
|
SVGImageContext svgContext(Some(destCSSSize));
|
|
SVGImageContext::MaybeStoreContextPaint(svgContext, aForFrame, aImage);
|
|
|
|
/* 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);
|
|
}
|
|
|
|
const nsPoint firstTilePos =
|
|
GetBackgroundFirstTilePos(aDest.TopLeft(), aFill.TopLeft(), aRepeatSize);
|
|
const nscoord xMost = aFill.XMost();
|
|
const nscoord repeatWidth = aRepeatSize.width;
|
|
const nscoord yMost = aFill.YMost();
|
|
const nscoord repeatHeight = aRepeatSize.height;
|
|
nsRect dest(0, 0, aDest.width, aDest.height);
|
|
nsPoint anchor = aAnchor;
|
|
for (nscoord x = firstTilePos.x; x < xMost; x += repeatWidth) {
|
|
for (nscoord y = firstTilePos.y; y < yMost; y += repeatHeight) {
|
|
dest.x = x;
|
|
dest.y = y;
|
|
ImgDrawResult result = DrawImageInternal(
|
|
aContext, aPresContext, aImage, aSamplingFilter, dest, dest, anchor,
|
|
aDirty, svgContext, aImageFlags, ExtendMode::CLAMP, aOpacity);
|
|
anchor.y += repeatHeight;
|
|
if (result != ImgDrawResult::SUCCESS) {
|
|
return result;
|
|
}
|
|
}
|
|
anchor.x += repeatWidth;
|
|
anchor.y = aAnchor.y;
|
|
}
|
|
|
|
return ImgDrawResult::SUCCESS;
|
|
}
|
|
|
|
/* static */
|
|
ImgDrawResult nsLayoutUtils::DrawImage(
|
|
gfxContext& aContext, ComputedStyle* aComputedStyle,
|
|
nsPresContext* aPresContext, imgIContainer* aImage,
|
|
const SamplingFilter aSamplingFilter, const nsRect& aDest,
|
|
const nsRect& aFill, const nsPoint& aAnchor, const nsRect& aDirty,
|
|
uint32_t aImageFlags, float aOpacity) {
|
|
SVGImageContext svgContext;
|
|
SVGImageContext::MaybeStoreContextPaint(svgContext, *aPresContext,
|
|
*aComputedStyle, aImage);
|
|
|
|
return DrawImageInternal(aContext, aPresContext, aImage, aSamplingFilter,
|
|
aDest, aFill, aAnchor, aDirty, svgContext,
|
|
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 StyleImageOrientation& aOrientation) {
|
|
MOZ_ASSERT(aContainer, "Should have an image container");
|
|
nsCOMPtr<imgIContainer> img(aContainer);
|
|
|
|
switch (aOrientation) {
|
|
case StyleImageOrientation::FromImage:
|
|
break;
|
|
case StyleImageOrientation::None:
|
|
img = ImageOps::Unorient(img);
|
|
break;
|
|
}
|
|
|
|
return img.forget();
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::ImageRequestUsesCORS(imgIRequest* aRequest) {
|
|
int32_t corsMode = mozilla::CORS_NONE;
|
|
return NS_SUCCEEDED(aRequest->GetCORSMode(&corsMode)) &&
|
|
corsMode != mozilla::CORS_NONE;
|
|
}
|
|
|
|
static bool NonZeroCorner(const LengthPercentage& aLength) {
|
|
// Since negative results are clamped to 0, check > 0.
|
|
return aLength.Resolve(nscoord_MAX) > 0 || aLength.Resolve(0) > 0;
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::HasNonZeroCorner(const BorderRadius& aCorners) {
|
|
for (const auto corner : mozilla::AllPhysicalHalfCorners()) {
|
|
if (NonZeroCorner(aCorners.Get(corner))) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// aCorner is a "full corner" value, i.e. eCornerTopLeft 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 BorderRadius& 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");
|
|
|
|
for (const auto corner : mozilla::AllPhysicalHalfCorners()) {
|
|
// corner is a "half corner" value, so dividing by two gives us a
|
|
// "full corner" value.
|
|
if (NonZeroCorner(aCorners.Get(corner)) &&
|
|
IsCornerAdjacentToSide(corner / 2, aSide))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* static */
|
|
widget::TransparencyMode nsLayoutUtils::GetFrameTransparency(
|
|
nsIFrame* aBackgroundFrame, nsIFrame* aCSSRootFrame) {
|
|
if (!aCSSRootFrame->StyleEffects()->IsOpaque()) {
|
|
return TransparencyMode::Transparent;
|
|
}
|
|
|
|
if (HasNonZeroCorner(aCSSRootFrame->StyleBorder()->mBorderRadius)) {
|
|
return TransparencyMode::Transparent;
|
|
}
|
|
|
|
nsITheme::Transparency transparency;
|
|
if (aCSSRootFrame->IsThemed(&transparency)) {
|
|
return transparency == nsITheme::eTransparent
|
|
? TransparencyMode::Transparent
|
|
: TransparencyMode::Opaque;
|
|
}
|
|
|
|
// 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->IsViewportFrame() &&
|
|
!aBackgroundFrame->PrincipalChildList().FirstChild()) {
|
|
return TransparencyMode::Opaque;
|
|
}
|
|
|
|
const ComputedStyle* bgSC = nsCSSRendering::FindBackground(aBackgroundFrame);
|
|
if (!bgSC) {
|
|
return TransparencyMode::Transparent;
|
|
}
|
|
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::BorderBox) {
|
|
return TransparencyMode::Transparent;
|
|
}
|
|
return TransparencyMode::Opaque;
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::IsPopup(const nsIFrame* aFrame) {
|
|
// Optimization: the frame can't possibly be a popup if it has no view.
|
|
if (!aFrame->HasView()) {
|
|
NS_ASSERTION(!aFrame->IsMenuPopupFrame(), "popup frame must have a view");
|
|
return false;
|
|
}
|
|
return aFrame->IsMenuPopupFrame();
|
|
}
|
|
|
|
/* static */
|
|
nsIFrame* nsLayoutUtils::GetDisplayRootFrame(nsIFrame* aFrame) {
|
|
return const_cast<nsIFrame*>(
|
|
nsLayoutUtils::GetDisplayRootFrame(const_cast<const nsIFrame*>(aFrame)));
|
|
}
|
|
|
|
/* static */
|
|
const nsIFrame* nsLayoutUtils::GetDisplayRootFrame(const nsIFrame* aFrame) {
|
|
// We could use GetRootPresContext() here if the
|
|
// NS_FRAME_IN_POPUP frame bit is set.
|
|
const nsIFrame* f = aFrame;
|
|
for (;;) {
|
|
if (!f->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
|
|
f = f->PresShell()->GetRootFrame();
|
|
if (!f) {
|
|
return aFrame;
|
|
}
|
|
} else if (IsPopup(f)) {
|
|
return f;
|
|
}
|
|
nsIFrame* parent = GetCrossDocParentFrameInProcess(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 = GetCrossDocParentFrameInProcess(f);
|
|
if (!parent) {
|
|
return f;
|
|
}
|
|
f = parent;
|
|
}
|
|
}
|
|
|
|
/* static */ gfx::ShapedTextFlags nsLayoutUtils::GetTextRunFlagsForStyle(
|
|
const ComputedStyle* aComputedStyle, nsPresContext* aPresContext,
|
|
const nsStyleFont* aStyleFont, const nsStyleText* aStyleText,
|
|
nscoord aLetterSpacing) {
|
|
gfx::ShapedTextFlags result = gfx::ShapedTextFlags();
|
|
if (aLetterSpacing != 0 ||
|
|
aStyleText->mTextJustify == StyleTextJustify::InterCharacter) {
|
|
result |= gfx::ShapedTextFlags::TEXT_DISABLE_OPTIONAL_LIGATURES;
|
|
}
|
|
if (aStyleText->mMozControlCharacterVisibility ==
|
|
StyleMozControlCharacterVisibility::Hidden) {
|
|
result |= gfx::ShapedTextFlags::TEXT_HIDE_CONTROL_CHARACTERS;
|
|
}
|
|
switch (aComputedStyle->StyleText()->mTextRendering) {
|
|
case StyleTextRendering::Optimizespeed:
|
|
result |= gfx::ShapedTextFlags::TEXT_OPTIMIZE_SPEED;
|
|
break;
|
|
case StyleTextRendering::Auto:
|
|
if (aPresContext &&
|
|
aStyleFont->mFont.size.ToCSSPixels() <
|
|
aPresContext->DevPixelsToFloatCSSPixels(
|
|
StaticPrefs::browser_display_auto_quality_min_font_size())) {
|
|
result |= gfx::ShapedTextFlags::TEXT_OPTIMIZE_SPEED;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return result | GetTextRunOrientFlagsForStyle(aComputedStyle);
|
|
}
|
|
|
|
/* static */ gfx::ShapedTextFlags nsLayoutUtils::GetTextRunOrientFlagsForStyle(
|
|
const ComputedStyle* aComputedStyle) {
|
|
auto writingMode = aComputedStyle->StyleVisibility()->mWritingMode;
|
|
switch (writingMode) {
|
|
case StyleWritingModeProperty::HorizontalTb:
|
|
return gfx::ShapedTextFlags::TEXT_ORIENT_HORIZONTAL;
|
|
|
|
case StyleWritingModeProperty::VerticalLr:
|
|
case StyleWritingModeProperty::VerticalRl:
|
|
switch (aComputedStyle->StyleVisibility()->mTextOrientation) {
|
|
case StyleTextOrientation::Mixed:
|
|
return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED;
|
|
case StyleTextOrientation::Upright:
|
|
return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT;
|
|
case StyleTextOrientation::Sideways:
|
|
return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("unknown text-orientation");
|
|
return gfx::ShapedTextFlags();
|
|
}
|
|
|
|
case StyleWritingModeProperty::SidewaysLr:
|
|
return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT;
|
|
|
|
case StyleWritingModeProperty::SidewaysRl:
|
|
return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
|
|
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("unknown writing-mode");
|
|
return gfx::ShapedTextFlags();
|
|
}
|
|
}
|
|
|
|
/* 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->EnsureSizeAndPositionUpToDate();
|
|
|
|
RefPtr<nsPresContext> presContext = docShell->GetPresContext();
|
|
if (presContext) {
|
|
nsDeviceContext* context = presContext->DeviceContext();
|
|
if (context) {
|
|
return context;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentItem;
|
|
docShell->GetInProcessParent(getter_AddRefs(parentItem));
|
|
docShell = do_QueryInterface(parentItem);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::IsReallyFixedPos(const nsIFrame* aFrame) {
|
|
MOZ_ASSERT(aFrame->StyleDisplay()->mPosition == StylePositionProperty::Fixed,
|
|
"IsReallyFixedPos called on non-'position:fixed' frame");
|
|
return MayBeReallyFixedPos(aFrame);
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::MayBeReallyFixedPos(const nsIFrame* aFrame) {
|
|
MOZ_ASSERT(aFrame->GetParent(),
|
|
"MayBeReallyFixedPos called on frame not in tree");
|
|
LayoutFrameType parentType = aFrame->GetParent()->Type();
|
|
return parentType == LayoutFrameType::Viewport ||
|
|
parentType == LayoutFrameType::PageContent;
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::IsInPositionFixedSubtree(const nsIFrame* aFrame) {
|
|
for (const nsIFrame* f = aFrame; f; f = f->GetParent()) {
|
|
if (f->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
|
|
nsLayoutUtils::IsReallyFixedPos(f)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static RefPtr<SourceSurface> ScaleSourceSurface(SourceSurface& aSurface,
|
|
const IntSize& aTargetSize) {
|
|
const IntSize surfaceSize = aSurface.GetSize();
|
|
|
|
MOZ_ASSERT(surfaceSize != aTargetSize);
|
|
MOZ_ASSERT(!surfaceSize.IsEmpty());
|
|
MOZ_ASSERT(!aTargetSize.IsEmpty());
|
|
|
|
RefPtr<DrawTarget> dt = Factory::CreateDrawTarget(
|
|
gfxVars::ContentBackend(), aTargetSize, aSurface.GetFormat());
|
|
|
|
if (!dt || !dt->IsValid()) {
|
|
return nullptr;
|
|
}
|
|
|
|
dt->DrawSurface(&aSurface, Rect(Point(), Size(aTargetSize)),
|
|
Rect(Point(), Size(surfaceSize)));
|
|
return dt->GetBackingSurface();
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromOffscreenCanvas(
|
|
OffscreenCanvas* aOffscreenCanvas, uint32_t aSurfaceFlags,
|
|
RefPtr<DrawTarget>& aTarget) {
|
|
SurfaceFromElementResult result;
|
|
|
|
IntSize size = aOffscreenCanvas->GetWidthHeight();
|
|
if (size.IsEmpty()) {
|
|
return result;
|
|
}
|
|
|
|
result.mSourceSurface =
|
|
aOffscreenCanvas->GetSurfaceSnapshot(&result.mAlphaType);
|
|
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.
|
|
result.mSize = size;
|
|
result.mAlphaType = gfxAlphaType::Opaque;
|
|
RefPtr<DrawTarget> ref =
|
|
aTarget ? aTarget : gfxPlatform::ThreadLocalScreenReferenceDrawTarget();
|
|
if (ref->CanCreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8)) {
|
|
RefPtr<DrawTarget> dt =
|
|
ref->CreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8);
|
|
if (dt) {
|
|
result.mSourceSurface = dt->Snapshot();
|
|
}
|
|
}
|
|
} else {
|
|
result.mSize = result.mSourceSurface->GetSize();
|
|
|
|
// If we want an exact sized surface, then we need to scale if we don't
|
|
// match the intrinsic size.
|
|
const bool exactSize = aSurfaceFlags & SFE_EXACT_SIZE_SURFACE;
|
|
if (exactSize && size != result.mSize) {
|
|
result.mSize = size;
|
|
result.mSourceSurface = ScaleSourceSurface(*result.mSourceSurface, size);
|
|
}
|
|
|
|
if (aTarget && result.mSourceSurface) {
|
|
RefPtr<SourceSurface> opt =
|
|
aTarget->OptimizeSourceSurface(result.mSourceSurface);
|
|
if (opt) {
|
|
result.mSourceSurface = opt;
|
|
}
|
|
}
|
|
}
|
|
|
|
result.mHasSize = true;
|
|
result.mIntrinsicSize = size;
|
|
result.mIsWriteOnly = aOffscreenCanvas->IsWriteOnly();
|
|
|
|
nsIGlobalObject* global = aOffscreenCanvas->GetParentObject();
|
|
if (global) {
|
|
result.mPrincipal = global->PrincipalOrNull();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromVideoFrame(
|
|
VideoFrame* aVideoFrame, uint32_t aSurfaceFlags,
|
|
RefPtr<DrawTarget>& aTarget) {
|
|
SurfaceFromElementResult result;
|
|
|
|
RefPtr<layers::Image> layersImage = aVideoFrame->GetImage();
|
|
if (!layersImage) {
|
|
return result;
|
|
}
|
|
|
|
IntSize codedSize = aVideoFrame->NativeCodedSize();
|
|
IntRect visibleRect = aVideoFrame->NativeVisibleRect();
|
|
IntSize displaySize = aVideoFrame->NativeDisplaySize();
|
|
|
|
MOZ_ASSERT(layersImage->GetSize() == codedSize);
|
|
IntRect codedRect(IntPoint(0, 0), codedSize);
|
|
|
|
if (visibleRect.IsEqualEdges(codedRect) && displaySize == codedSize) {
|
|
// The display and coded rects are identical, which means we can just use
|
|
// the image as is.
|
|
result.mLayersImage = std::move(layersImage);
|
|
result.mSize = codedSize;
|
|
result.mIntrinsicSize = codedSize;
|
|
} else if (aSurfaceFlags & SFE_ALLOW_UNCROPPED_UNSCALED) {
|
|
// The caller supports cropping/scaling.
|
|
result.mLayersImage = std::move(layersImage);
|
|
result.mCropRect = Some(visibleRect);
|
|
result.mSize = codedSize;
|
|
result.mIntrinsicSize = displaySize;
|
|
} else {
|
|
// The caller does not support cropping/scaling. We need to on its behalf.
|
|
RefPtr<SourceSurface> surface = layersImage->GetAsSourceSurface();
|
|
if (!surface) {
|
|
return result;
|
|
}
|
|
|
|
RefPtr<DrawTarget> ref = aTarget
|
|
? aTarget
|
|
: gfxPlatform::GetPlatform()
|
|
->ThreadLocalScreenReferenceDrawTarget();
|
|
if (!ref->CanCreateSimilarDrawTarget(displaySize,
|
|
SurfaceFormat::B8G8R8A8)) {
|
|
return result;
|
|
}
|
|
|
|
RefPtr<DrawTarget> dt =
|
|
ref->CreateSimilarDrawTarget(displaySize, SurfaceFormat::B8G8R8A8);
|
|
if (!dt) {
|
|
return result;
|
|
}
|
|
|
|
gfx::Rect dstRect(0, 0, displaySize.Width(), displaySize.Height());
|
|
gfx::Rect srcRect(visibleRect.X(), visibleRect.Y(), visibleRect.Width(),
|
|
visibleRect.Height());
|
|
dt->DrawSurface(surface, dstRect, srcRect);
|
|
result.mSourceSurface = dt->Snapshot();
|
|
if (NS_WARN_IF(!result.mSourceSurface)) {
|
|
return result;
|
|
}
|
|
|
|
result.mSize = displaySize;
|
|
result.mIntrinsicSize = displaySize;
|
|
}
|
|
|
|
result.mAlphaType = gfxAlphaType::Premult;
|
|
Nullable<VideoPixelFormat> format = aVideoFrame->GetFormat();
|
|
if (!format.IsNull()) {
|
|
switch (format.Value()) {
|
|
case VideoPixelFormat::I420:
|
|
case VideoPixelFormat::I422:
|
|
case VideoPixelFormat::I444:
|
|
case VideoPixelFormat::NV12:
|
|
case VideoPixelFormat::RGBX:
|
|
case VideoPixelFormat::BGRX:
|
|
result.mAlphaType = gfxAlphaType::Opaque;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
result.mHasSize = true;
|
|
|
|
// We shouldn't have a VideoFrame if either of these is true.
|
|
result.mHadCrossOriginRedirects = false;
|
|
result.mIsWriteOnly = false;
|
|
|
|
nsIGlobalObject* global = aVideoFrame->GetParentObject();
|
|
if (global) {
|
|
result.mPrincipal = global->PrincipalOrNull();
|
|
}
|
|
|
|
if (aTarget) {
|
|
// They gave us a DrawTarget to optimize for, so even though we may have a
|
|
// layers::Image, we should unconditionally try to grab a SourceSurface and
|
|
// try to optimize it.
|
|
if (result.mLayersImage) {
|
|
MOZ_ASSERT(!result.mSourceSurface);
|
|
result.mSourceSurface = result.mLayersImage->GetAsSourceSurface();
|
|
}
|
|
|
|
if (result.mSourceSurface) {
|
|
RefPtr<SourceSurface> opt =
|
|
aTarget->OptimizeSourceSurface(result.mSourceSurface);
|
|
if (opt) {
|
|
result.mSourceSurface = std::move(opt);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromImageBitmap(
|
|
mozilla::dom::ImageBitmap* aImageBitmap, uint32_t aSurfaceFlags) {
|
|
return aImageBitmap->SurfaceFrom(aSurfaceFlags);
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
|
|
nsIImageLoadingContent* aElement, const Maybe<int32_t>& aResizeWidth,
|
|
const Maybe<int32_t>& aResizeHeight, 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
|
|
// HTMLImageElement, 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;
|
|
}
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
// Ensure that the image is oriented the same way as it's displayed
|
|
// if the image request is of the same origin.
|
|
auto orientation =
|
|
content->GetPrimaryFrame() &&
|
|
!(aSurfaceFlags & SFE_ORIENTATION_FROM_IMAGE)
|
|
? content->GetPrimaryFrame()->StyleVisibility()->UsedImageOrientation(
|
|
imgRequest)
|
|
: nsStyleVisibility::UsedImageOrientation(
|
|
imgRequest, StyleImageOrientation::FromImage);
|
|
imgContainer = OrientImage(imgContainer, orientation);
|
|
|
|
const bool noRasterize = aSurfaceFlags & SFE_NO_RASTERIZING_VECTORS;
|
|
|
|
uint32_t whichFrame = aSurfaceFlags & SFE_WANT_FIRST_FRAME_IF_IMAGE
|
|
? (uint32_t)imgIContainer::FRAME_FIRST
|
|
: (uint32_t)imgIContainer::FRAME_CURRENT;
|
|
const bool exactSize = aSurfaceFlags & SFE_EXACT_SIZE_SURFACE;
|
|
|
|
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_ALLOW_NON_PREMULT) {
|
|
frameFlags |= imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA;
|
|
}
|
|
|
|
int32_t imgWidth, imgHeight;
|
|
HTMLImageElement* element = HTMLImageElement::FromNodeOrNull(content);
|
|
if (aSurfaceFlags & SFE_USE_ELEMENT_SIZE_IF_VECTOR && element &&
|
|
imgContainer->GetType() == imgIContainer::TYPE_VECTOR) {
|
|
// We're holding a strong ref to "element" via "content".
|
|
imgWidth = MOZ_KnownLive(element)->Width();
|
|
imgHeight = MOZ_KnownLive(element)->Height();
|
|
} else {
|
|
auto res = imgContainer->GetResolution();
|
|
rv = imgContainer->GetWidth(&imgWidth);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
res.ApplyXTo(imgWidth);
|
|
} else if (aResizeWidth.isSome()) {
|
|
imgWidth = *aResizeWidth;
|
|
} else {
|
|
// As stated in css-sizing-3 Intrinsic Sizes, the fallback size of
|
|
// 300 x 150 for the width and height as needed.
|
|
//
|
|
// See https://drafts.csswg.org/css-sizing-3/#intrinsic-sizes
|
|
imgWidth = kFallbackIntrinsicWidthInPixels;
|
|
}
|
|
rv = imgContainer->GetHeight(&imgHeight);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
res.ApplyYTo(imgHeight);
|
|
} else if (aResizeHeight.isSome()) {
|
|
imgHeight = *aResizeHeight;
|
|
} else {
|
|
// As stated in css-sizing-3 Intrinsic Sizes, the fallback size of
|
|
// 300 x 150 for the width and height as needed.
|
|
//
|
|
// See https://drafts.csswg.org/css-sizing-3/#intrinsic-sizes
|
|
imgHeight = kFallbackIntrinsicHeightInPixels;
|
|
}
|
|
}
|
|
result.mSize = result.mIntrinsicSize = IntSize(imgWidth, imgHeight);
|
|
|
|
if (!noRasterize || imgContainer->GetType() == imgIContainer::TYPE_RASTER) {
|
|
result.mSourceSurface =
|
|
imgContainer->GetFrameAtSize(result.mSize, whichFrame, frameFlags);
|
|
if (!result.mSourceSurface) {
|
|
return result;
|
|
}
|
|
IntSize surfSize = result.mSourceSurface->GetSize();
|
|
if (exactSize && surfSize != result.mSize) {
|
|
result.mSourceSurface =
|
|
ScaleSourceSurface(*result.mSourceSurface, result.mSize);
|
|
if (!result.mSourceSurface) {
|
|
return result;
|
|
}
|
|
} else {
|
|
result.mSize = surfSize;
|
|
}
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
const auto& format = result.mSourceSurface->GetFormat();
|
|
if (IsOpaque(format)) {
|
|
result.mAlphaType = gfxAlphaType::Opaque;
|
|
} else if (frameFlags & imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA) {
|
|
result.mAlphaType = gfxAlphaType::NonPremult;
|
|
} else {
|
|
result.mAlphaType = gfxAlphaType::Premult;
|
|
}
|
|
} else {
|
|
result.mDrawInfo.mImgContainer = imgContainer;
|
|
result.mDrawInfo.mWhichFrame = whichFrame;
|
|
result.mDrawInfo.mDrawingFlags = frameFlags;
|
|
}
|
|
|
|
result.mCORSUsed = nsLayoutUtils::ImageRequestUsesCORS(imgRequest);
|
|
|
|
bool hadCrossOriginRedirects = true;
|
|
imgRequest->GetHadCrossOriginRedirects(&hadCrossOriginRedirects);
|
|
|
|
result.mPrincipal = std::move(principal);
|
|
result.mHadCrossOriginRedirects = hadCrossOriginRedirects;
|
|
result.mImageRequest = std::move(imgRequest);
|
|
result.mIsWriteOnly = CanvasUtils::CheckWriteOnlySecurity(
|
|
result.mCORSUsed, result.mPrincipal, result.mHadCrossOriginRedirects);
|
|
|
|
return result;
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
|
|
HTMLImageElement* aElement, uint32_t aSurfaceFlags,
|
|
RefPtr<DrawTarget>& aTarget) {
|
|
return SurfaceFromElement(static_cast<nsIImageLoadingContent*>(aElement),
|
|
Nothing(), Nothing(), aSurfaceFlags, aTarget);
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
|
|
HTMLCanvasElement* aElement, uint32_t aSurfaceFlags,
|
|
RefPtr<DrawTarget>& aTarget) {
|
|
SurfaceFromElementResult result;
|
|
|
|
IntSize size = aElement->GetSize();
|
|
if (size.IsEmpty()) {
|
|
return result;
|
|
}
|
|
|
|
auto pAlphaType = &result.mAlphaType;
|
|
if (!(aSurfaceFlags & SFE_ALLOW_NON_PREMULT)) {
|
|
pAlphaType =
|
|
nullptr; // Coersce GetSurfaceSnapshot to give us Opaque/Premult only.
|
|
}
|
|
result.mSourceSurface = aElement->GetSurfaceSnapshot(pAlphaType, aTarget);
|
|
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.
|
|
result.mSize = size;
|
|
result.mAlphaType = gfxAlphaType::Opaque;
|
|
RefPtr<DrawTarget> ref =
|
|
aTarget ? aTarget
|
|
: gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
|
|
if (ref->CanCreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8)) {
|
|
RefPtr<DrawTarget> dt =
|
|
ref->CreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8);
|
|
if (dt) {
|
|
result.mSourceSurface = dt->Snapshot();
|
|
}
|
|
}
|
|
} else {
|
|
result.mSize = result.mSourceSurface->GetSize();
|
|
|
|
// If we want an exact sized surface, then we need to scale if we don't
|
|
// match the intrinsic size.
|
|
const bool exactSize = aSurfaceFlags & SFE_EXACT_SIZE_SURFACE;
|
|
if (exactSize && size != result.mSize) {
|
|
result.mSize = size;
|
|
result.mSourceSurface = ScaleSourceSurface(*result.mSourceSurface, size);
|
|
}
|
|
|
|
if (aTarget && result.mSourceSurface) {
|
|
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.mIntrinsicSize = size;
|
|
result.mPrincipal = aElement->NodePrincipal();
|
|
result.mHadCrossOriginRedirects = false;
|
|
result.mIsWriteOnly = aElement->IsWriteOnly();
|
|
|
|
return result;
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
|
|
HTMLVideoElement* aElement, uint32_t aSurfaceFlags,
|
|
RefPtr<DrawTarget>& aTarget) {
|
|
SurfaceFromElementResult result;
|
|
result.mAlphaType = gfxAlphaType::Opaque; // Assume opaque.
|
|
|
|
if (aElement->ContainsRestrictedContent()) {
|
|
return result;
|
|
}
|
|
|
|
uint16_t readyState = aElement->ReadyState();
|
|
if (readyState == HAVE_NOTHING || readyState == 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;
|
|
}
|
|
|
|
result.mLayersImage = aElement->GetCurrentImage();
|
|
if (!result.mLayersImage) {
|
|
return result;
|
|
}
|
|
|
|
result.mCORSUsed = aElement->GetCORSMode() != CORS_NONE;
|
|
result.mHasSize = true;
|
|
result.mSize = result.mLayersImage->GetSize();
|
|
result.mIntrinsicSize =
|
|
gfx::IntSize(aElement->VideoWidth(), aElement->VideoHeight());
|
|
result.mPrincipal = std::move(principal);
|
|
result.mHadCrossOriginRedirects = aElement->HadCrossOriginRedirects();
|
|
result.mIsWriteOnly = CanvasUtils::CheckWriteOnlySecurity(
|
|
result.mCORSUsed, result.mPrincipal, result.mHadCrossOriginRedirects);
|
|
|
|
if (aTarget) {
|
|
// They gave us a DrawTarget to optimize for, so even though we have a
|
|
// layers::Image, we should unconditionally try to grab a SourceSurface and
|
|
// try to optimize it.
|
|
if ((result.mSourceSurface = result.mLayersImage->GetAsSourceSurface())) {
|
|
RefPtr<SourceSurface> opt =
|
|
aTarget->OptimizeSourceSurface(result.mSourceSurface);
|
|
if (opt) {
|
|
result.mSourceSurface = opt;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
|
|
dom::Element* aElement, const Maybe<int32_t>& aResizeWidth,
|
|
const Maybe<int32_t>& aResizeHeight, 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::FromNodeOrNull(aElement)) {
|
|
return SurfaceFromElement(canvas, aSurfaceFlags, aTarget);
|
|
}
|
|
|
|
// Maybe it's <video>?
|
|
if (HTMLVideoElement* video = HTMLVideoElement::FromNodeOrNull(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, aResizeWidth, aResizeHeight,
|
|
aSurfaceFlags, aTarget);
|
|
}
|
|
|
|
/* static */
|
|
Element* nsLayoutUtils::GetEditableRootContentByContentEditable(
|
|
Document* aDocument) {
|
|
// If the document is in designMode we should return nullptr.
|
|
if (!aDocument || aDocument->IsInDesignMode()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// contenteditable only works with HTML document.
|
|
// XXXbz should this test IsHTMLOrXHTML(), or just IsHTML()?
|
|
if (!aDocument->IsHTMLOrXHTML()) {
|
|
return nullptr;
|
|
}
|
|
|
|
Element* rootElement = aDocument->GetRootElement();
|
|
if (rootElement && rootElement->IsEditable()) {
|
|
return rootElement;
|
|
}
|
|
|
|
// If there is no editable root element, check its <body> element.
|
|
// Note that the body element could be <frameset> element.
|
|
Element* bodyElement = aDocument->GetBody();
|
|
if (bodyElement && bodyElement->IsEditable()) {
|
|
return bodyElement;
|
|
}
|
|
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->IsLetterFrame()) {
|
|
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.
|
|
auto [start, end] = aSubtreeRoot->GetOffsets();
|
|
// 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");
|
|
|
|
for (const auto& childList : aSubtreeRoot->ChildLists()) {
|
|
for (nsIFrame* child : childList.mList) {
|
|
nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(child);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void GetFontFacesForFramesInner(
|
|
nsIFrame* aFrame, nsLayoutUtils::UsedFontFaceList& aResult,
|
|
nsLayoutUtils::UsedFontFaceTable& aFontFaces, uint32_t aMaxRanges,
|
|
bool aSkipCollapsedWhitespace) {
|
|
MOZ_ASSERT(aFrame, "NULL frame pointer");
|
|
|
|
if (aFrame->IsTextFrame()) {
|
|
if (!aFrame->GetPrevContinuation()) {
|
|
nsLayoutUtils::GetFontFacesForText(aFrame, 0, INT32_MAX, true, aResult,
|
|
aFontFaces, aMaxRanges,
|
|
aSkipCollapsedWhitespace);
|
|
}
|
|
return;
|
|
}
|
|
|
|
FrameChildListID childLists[] = {FrameChildListID::Principal,
|
|
FrameChildListID::Popup};
|
|
for (size_t i = 0; i < ArrayLength(childLists); ++i) {
|
|
for (nsIFrame* child : aFrame->GetChildList(childLists[i])) {
|
|
child = nsPlaceholderFrame::GetRealFrameFor(child);
|
|
GetFontFacesForFramesInner(child, aResult, aFontFaces, aMaxRanges,
|
|
aSkipCollapsedWhitespace);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
nsresult nsLayoutUtils::GetFontFacesForFrames(nsIFrame* aFrame,
|
|
UsedFontFaceList& aResult,
|
|
UsedFontFaceTable& aFontFaces,
|
|
uint32_t aMaxRanges,
|
|
bool aSkipCollapsedWhitespace) {
|
|
MOZ_ASSERT(aFrame, "NULL frame pointer");
|
|
|
|
while (aFrame) {
|
|
GetFontFacesForFramesInner(aFrame, aResult, aFontFaces, aMaxRanges,
|
|
aSkipCollapsedWhitespace);
|
|
aFrame = GetNextContinuationOrIBSplitSibling(aFrame);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
static void AddFontsFromTextRun(gfxTextRun* aTextRun, nsTextFrame* aFrame,
|
|
gfxSkipCharsIterator& aSkipIter,
|
|
const gfxTextRun::Range& aRange,
|
|
nsLayoutUtils::UsedFontFaceList& aResult,
|
|
nsLayoutUtils::UsedFontFaceTable& aFontFaces,
|
|
uint32_t aMaxRanges) {
|
|
nsIContent* content = aFrame->GetContent();
|
|
int32_t contentLimit =
|
|
aFrame->GetContentOffset() + aFrame->GetInFlowContentLength();
|
|
for (gfxTextRun::GlyphRunIterator glyphRuns(aTextRun, aRange);
|
|
!glyphRuns.AtEnd(); glyphRuns.NextRun()) {
|
|
gfxFontEntry* fe = glyphRuns.GlyphRun()->mFont->GetFontEntry();
|
|
// if we have already listed this face, just make sure the match type is
|
|
// recorded
|
|
InspectorFontFace* fontFace = aFontFaces.Get(fe);
|
|
if (fontFace) {
|
|
fontFace->AddMatchType(glyphRuns.GlyphRun()->mMatchType);
|
|
} else {
|
|
// A new font entry we haven't seen before
|
|
fontFace = new InspectorFontFace(fe, aTextRun->GetFontGroup(),
|
|
glyphRuns.GlyphRun()->mMatchType);
|
|
aFontFaces.InsertOrUpdate(fe, fontFace);
|
|
aResult.AppendElement(fontFace);
|
|
}
|
|
|
|
// Add this glyph run to the fontFace's list of ranges, unless we have
|
|
// already collected as many as wanted.
|
|
if (fontFace->RangeCount() < aMaxRanges) {
|
|
int32_t start =
|
|
aSkipIter.ConvertSkippedToOriginal(glyphRuns.StringStart());
|
|
int32_t end = aSkipIter.ConvertSkippedToOriginal(glyphRuns.StringEnd());
|
|
|
|
// Mapping back from textrun offsets ("skipped" offsets that reflect the
|
|
// text after whitespace collapsing, etc) to DOM content offsets in the
|
|
// original text is ambiguous, because many original characters can
|
|
// map to a single skipped offset. aSkipIter.ConvertSkippedToOriginal()
|
|
// will return an "original" offset that corresponds to the *end* of
|
|
// a collapsed run of characters in this case; but that might extend
|
|
// beyond the current content node if the textrun mapped multiple nodes.
|
|
// So we clamp the end offset to keep it valid for the content node
|
|
// that corresponds to the current textframe.
|
|
end = std::min(end, contentLimit);
|
|
|
|
if (end > start) {
|
|
RefPtr<nsRange> range =
|
|
nsRange::Create(content, start, content, end, IgnoreErrors());
|
|
NS_WARNING_ASSERTION(range,
|
|
"nsRange::Create() failed to create valid range");
|
|
if (range) {
|
|
fontFace->AddRange(range);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::GetFontFacesForText(nsIFrame* aFrame, int32_t aStartOffset,
|
|
int32_t aEndOffset,
|
|
bool aFollowContinuations,
|
|
UsedFontFaceList& aResult,
|
|
UsedFontFaceTable& aFontFaces,
|
|
uint32_t aMaxRanges,
|
|
bool aSkipCollapsedWhitespace) {
|
|
MOZ_ASSERT(aFrame, "NULL frame pointer");
|
|
|
|
if (!aFrame->IsTextFrame()) {
|
|
return;
|
|
}
|
|
|
|
if (!aFrame->StyleVisibility()->IsVisible()) {
|
|
return;
|
|
}
|
|
|
|
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);
|
|
if (!textRun) {
|
|
NS_WARNING("failed to get textRun, low memory?");
|
|
return;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
if (!aSkipCollapsedWhitespace || (curr->HasAnyNoncollapsedCharacters() &&
|
|
curr->HasNonSuppressedText())) {
|
|
gfxTextRun::Range range(iter.ConvertOriginalToSkipped(fstart),
|
|
iter.ConvertOriginalToSkipped(fend));
|
|
AddFontsFromTextRun(textRun, curr, iter, range, aResult, aFontFaces,
|
|
aMaxRanges);
|
|
}
|
|
|
|
curr = next;
|
|
} while (aFollowContinuations && curr);
|
|
}
|
|
|
|
/* static */
|
|
size_t nsLayoutUtils::SizeOfTextRunsForFrames(nsIFrame* aFrame,
|
|
MallocSizeOf aMallocSizeOf,
|
|
bool clear) {
|
|
MOZ_ASSERT(aFrame, "NULL frame pointer");
|
|
|
|
size_t total = 0;
|
|
|
|
if (aFrame->IsTextFrame()) {
|
|
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;
|
|
}
|
|
|
|
for (const auto& childList : aFrame->ChildLists()) {
|
|
for (nsIFrame* f : childList.mList) {
|
|
total += SizeOfTextRunsForFrames(f, aMallocSizeOf, clear);
|
|
}
|
|
}
|
|
return total;
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::RecomputeSmoothScrollDefault() {
|
|
if (nsContentUtils::ShouldResistFingerprinting(
|
|
"We use the global RFP pref to maintain consistent scroll behavior "
|
|
"in the browser.",
|
|
RFPTarget::CSSPrefersReducedMotion)) {
|
|
// When resist fingerprinting is enabled, we should not default disable
|
|
// smooth scrolls when the user prefers-reduced-motion to avoid leaking
|
|
// the value of the OS pref to sites.
|
|
Preferences::SetBool(StaticPrefs::GetPrefName_general_smoothScroll(), true,
|
|
PrefValueKind::Default);
|
|
} else {
|
|
// We want prefers-reduced-motion to determine the default
|
|
// value of the general.smoothScroll pref. If the user
|
|
// changed the pref we want to respect the change.
|
|
Preferences::SetBool(
|
|
StaticPrefs::GetPrefName_general_smoothScroll(),
|
|
!LookAndFeel::GetInt(LookAndFeel::IntID::PrefersReducedMotion, 0),
|
|
PrefValueKind::Default);
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::IsSmoothScrollingEnabled() {
|
|
return StaticPrefs::general_smoothScroll();
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::Initialize() {
|
|
nsComputedDOMStyle::RegisterPrefChangeCallbacks();
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::Shutdown() {
|
|
if (sContentMap) {
|
|
sContentMap = nullptr;
|
|
}
|
|
|
|
nsComputedDOMStyle::UnregisterPrefChangeCallbacks();
|
|
}
|
|
|
|
/* 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) {
|
|
aPresContext->RefreshDriver()->AddImageRequest(aRequest);
|
|
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) {
|
|
aPresContext->RefreshDriver()->AddImageRequest(aRequest);
|
|
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,
|
|
RestyleHint aRestyleHint,
|
|
nsChangeHint aMinChangeHint) {
|
|
if (Document* doc = aElement->GetComposedDoc()) {
|
|
if (nsPresContext* presContext = doc->GetPresContext()) {
|
|
presContext->RestyleManager()->PostRestyleEvent(aElement, aRestyleHint,
|
|
aMinChangeHint);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsSetAttrRunnable::nsSetAttrRunnable(Element* aElement, nsAtom* aAttrName,
|
|
const nsAString& aValue)
|
|
: mozilla::Runnable("nsSetAttrRunnable"),
|
|
mElement(aElement),
|
|
mAttrName(aAttrName),
|
|
mValue(aValue) {
|
|
NS_ASSERTION(aElement && aAttrName, "Missing stuff, prepare to crash");
|
|
}
|
|
|
|
nsSetAttrRunnable::nsSetAttrRunnable(Element* aElement, nsAtom* aAttrName,
|
|
int32_t aValue)
|
|
: mozilla::Runnable("nsSetAttrRunnable"),
|
|
mElement(aElement),
|
|
mAttrName(aAttrName) {
|
|
NS_ASSERTION(aElement && aAttrName, "Missing stuff, prepare to crash");
|
|
mValue.AppendInt(aValue);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSetAttrRunnable::Run() {
|
|
return mElement->SetAttr(kNameSpaceID_None, mAttrName, mValue, true);
|
|
}
|
|
|
|
nsUnsetAttrRunnable::nsUnsetAttrRunnable(Element* aElement, nsAtom* aAttrName)
|
|
: mozilla::Runnable("nsUnsetAttrRunnable"),
|
|
mElement(aElement),
|
|
mAttrName(aAttrName) {
|
|
NS_ASSERTION(aElement && aAttrName, "Missing stuff, prepare to crash");
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsUnsetAttrRunnable::Run() {
|
|
return mElement->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) {
|
|
PresShell* presShell = aPresContext->PresShell();
|
|
|
|
uint32_t emPerLine = presShell->FontSizeInflationEmPerLine();
|
|
uint32_t minTwips = presShell->FontSizeInflationMinTwips();
|
|
if (emPerLine == 0 && minTwips == 0) {
|
|
return 0;
|
|
}
|
|
|
|
nscoord byLine = 0, byInch = 0;
|
|
if (emPerLine != 0) {
|
|
byLine = aContainerISize / 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(aContainerISize / (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.ToAppUnits();
|
|
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();
|
|
LayoutFrameType fType = f->Type();
|
|
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 != LayoutFrameType::Inline &&
|
|
// ignore width on radios and checkboxes since we enlarge them and
|
|
// they have width/height in ua.css
|
|
fType != LayoutFrameType::CheckboxRadio) {
|
|
// ruby annotations should have the same inflation as its
|
|
// grandparent, which is the ruby frame contains the annotation.
|
|
if (fType == LayoutFrameType::RubyText) {
|
|
MOZ_ASSERT(parent && parent->IsRubyTextContainerFrame());
|
|
nsIFrame* grandparent = parent->GetParent();
|
|
MOZ_ASSERT(grandparent && grandparent->IsRubyFrame());
|
|
return FontSizeInflationFor(grandparent);
|
|
}
|
|
WritingMode wm = f->GetWritingMode();
|
|
const auto& stylePosISize = f->StylePosition()->ISize(wm);
|
|
const auto& stylePosBSize = f->StylePosition()->BSize(wm);
|
|
if (!stylePosISize.IsAuto() ||
|
|
!stylePosBSize.BehavesLikeInitialValueOnBlockAxis()) {
|
|
return 1.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t interceptParam = StaticPrefs::font_size_inflation_mappingIntercept();
|
|
float maxRatio = (float)StaticPrefs::font_size_inflation_maxRatio() / 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 != StyleTextSizeAdjust::None &&
|
|
!aFrame->HasAnyStateBits(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->UsableISize());
|
|
}
|
|
}
|
|
|
|
MOZ_ASSERT(false, "root should always be container");
|
|
|
|
return 0;
|
|
}
|
|
|
|
float nsLayoutUtils::FontSizeInflationFor(const nsIFrame* aFrame) {
|
|
if (aFrame->IsInSVGTextSubtree()) {
|
|
const nsIFrame* container = aFrame;
|
|
while (!container->IsSVGTextFrame()) {
|
|
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) {
|
|
PresShell* presShell = aPresContext->GetPresShell();
|
|
if (!presShell) {
|
|
return false;
|
|
}
|
|
return presShell->FontSizeInflationEnabled();
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::GetBoxShadowRectForFrame(nsIFrame* aFrame,
|
|
const nsSize& aFrameSize) {
|
|
auto boxShadows = aFrame->StyleEffects()->mBoxShadow.AsSpan();
|
|
if (boxShadows.IsEmpty()) {
|
|
return nsRect();
|
|
}
|
|
|
|
nsRect inputRect(nsPoint(0, 0), aFrameSize);
|
|
|
|
// According to the CSS spec, box-shadow should be based on the border box.
|
|
// However, that looks broken when the background extends outside the border
|
|
// box, as can be the case with native theming. To fix that we expand the
|
|
// area that we shadow to include the bounds of any native theme drawing.
|
|
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.
|
|
if (transparency != nsITheme::eOpaque) {
|
|
nsPresContext* presContext = aFrame->PresContext();
|
|
presContext->Theme()->GetWidgetOverflow(
|
|
presContext->DeviceContext(), aFrame,
|
|
styleDisplay->EffectiveAppearance(), &inputRect);
|
|
}
|
|
}
|
|
|
|
nsRect shadows;
|
|
int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
|
|
for (auto& shadow : boxShadows) {
|
|
nsRect tmpRect = inputRect;
|
|
|
|
// inset shadows are never painted outside the frame
|
|
if (shadow.inset) {
|
|
continue;
|
|
}
|
|
|
|
tmpRect.MoveBy(nsPoint(shadow.base.horizontal.ToAppUnits(),
|
|
shadow.base.vertical.ToAppUnits()));
|
|
tmpRect.Inflate(shadow.spread.ToAppUnits());
|
|
tmpRect.Inflate(nsContextBoxBlur::GetBlurRadiusMargin(
|
|
shadow.base.blur.ToAppUnits(), A2D));
|
|
shadows.UnionRect(shadows, tmpRect);
|
|
}
|
|
return shadows;
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::GetContentViewerSize(
|
|
const nsPresContext* aPresContext, LayoutDeviceIntSize& aOutSize,
|
|
SubtractDynamicToolbar aSubtractDynamicToolbar) {
|
|
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);
|
|
|
|
if (aPresContext->IsRootContentDocumentCrossProcess() &&
|
|
aSubtractDynamicToolbar == SubtractDynamicToolbar::Yes &&
|
|
aPresContext->HasDynamicToolbar() && !bounds.IsEmpty()) {
|
|
MOZ_ASSERT(aPresContext->IsRootContentDocumentCrossProcess());
|
|
bounds.height -= aPresContext->GetDynamicToolbarMaxHeight();
|
|
// Collapse the size in the case the dynamic toolbar max height is greater
|
|
// than the content bound height so that hopefully embedders of GeckoView
|
|
// may notice they set wrong dynamic toolbar max height.
|
|
if (bounds.height < 0) {
|
|
bounds.height = 0;
|
|
}
|
|
}
|
|
|
|
aOutSize = LayoutDeviceIntRect::FromUnknownRect(bounds).Size();
|
|
return true;
|
|
}
|
|
|
|
bool nsLayoutUtils::UpdateCompositionBoundsForRCDRSF(
|
|
ParentLayerRect& aCompBounds, const nsPresContext* aPresContext,
|
|
IncludeDynamicToolbar aIncludeDynamicToolbar) {
|
|
SubtractDynamicToolbar shouldSubtractDynamicToolbar =
|
|
aIncludeDynamicToolbar == IncludeDynamicToolbar::Force
|
|
? SubtractDynamicToolbar::No
|
|
: aPresContext->IsRootContentDocumentCrossProcess() &&
|
|
aPresContext->HasDynamicToolbar()
|
|
? SubtractDynamicToolbar::Yes
|
|
: SubtractDynamicToolbar::No;
|
|
|
|
if (shouldSubtractDynamicToolbar == SubtractDynamicToolbar::Yes) {
|
|
if (RefPtr<MobileViewportManager> MVM =
|
|
aPresContext->PresShell()->GetMobileViewportManager()) {
|
|
// Convert the intrinsic composition size to app units here since
|
|
// the returned size of below CalculateScrollableRectForFrame call has
|
|
// been already converted/rounded to app units.
|
|
nsSize intrinsicCompositionSize =
|
|
CSSSize::ToAppUnits(MVM->GetIntrinsicCompositionSize());
|
|
|
|
if (nsIScrollableFrame* rootScrollableFrame =
|
|
aPresContext->PresShell()->GetRootScrollFrameAsScrollable()) {
|
|
// Expand the composition size to include the area initially covered by
|
|
// the dynamic toolbar only if the content is taller than the intrinsic
|
|
// composition size (i.e. the dynamic toolbar should be able to move
|
|
// only if the content is vertically scrollable).
|
|
if (intrinsicCompositionSize.height <
|
|
CalculateScrollableRectForFrame(rootScrollableFrame, nullptr)
|
|
.Height()) {
|
|
shouldSubtractDynamicToolbar = SubtractDynamicToolbar::No;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LayoutDeviceIntSize contentSize;
|
|
if (!GetContentViewerSize(aPresContext, contentSize,
|
|
shouldSubtractDynamicToolbar)) {
|
|
return false;
|
|
}
|
|
aCompBounds.SizeTo(ViewAs<ParentLayerPixel>(
|
|
LayoutDeviceSize(contentSize),
|
|
PixelCastJustification::LayoutDeviceIsParentLayerForRCDRSF));
|
|
return true;
|
|
}
|
|
|
|
/* static */
|
|
nsMargin nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(
|
|
const nsIFrame* aScrollFrame) {
|
|
if (!aScrollFrame || !aScrollFrame->GetScrollTargetFrame()) {
|
|
return nsMargin();
|
|
}
|
|
nsPresContext* presContext = aScrollFrame->PresContext();
|
|
PresShell* presShell = presContext->GetPresShell();
|
|
if (!presShell) {
|
|
return nsMargin();
|
|
}
|
|
bool isRootScrollFrame = aScrollFrame == presShell->GetRootScrollFrame();
|
|
bool isRootContentDocRootScrollFrame =
|
|
isRootScrollFrame && presContext->IsRootContentDocumentCrossProcess();
|
|
if (!isRootContentDocRootScrollFrame) {
|
|
return nsMargin();
|
|
}
|
|
if (presContext->UseOverlayScrollbars()) {
|
|
return nsMargin();
|
|
}
|
|
nsIScrollableFrame* scrollableFrame = aScrollFrame->GetScrollTargetFrame();
|
|
if (!scrollableFrame) {
|
|
return nsMargin();
|
|
}
|
|
return scrollableFrame->GetActualScrollbarSizes(
|
|
nsIScrollableFrame::ScrollbarSizesOptions::
|
|
INCLUDE_VISUAL_VIEWPORT_SCROLLBARS);
|
|
}
|
|
|
|
/* static */
|
|
nsSize nsLayoutUtils::CalculateCompositionSizeForFrame(
|
|
nsIFrame* aFrame, bool aSubtractScrollbars,
|
|
const nsSize* aOverrideScrollPortSize,
|
|
IncludeDynamicToolbar aIncludeDynamicToolbar) {
|
|
// 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 =
|
|
aOverrideScrollPortSize ? *aOverrideScrollPortSize : rect.Size();
|
|
|
|
nsPresContext* presContext = aFrame->PresContext();
|
|
PresShell* presShell = presContext->PresShell();
|
|
|
|
bool isRootContentDocRootScrollFrame =
|
|
presContext->IsRootContentDocumentCrossProcess() &&
|
|
aFrame == presShell->GetRootScrollFrame();
|
|
if (isRootContentDocRootScrollFrame) {
|
|
ParentLayerRect compBounds;
|
|
if (UpdateCompositionBoundsForRCDRSF(compBounds, presContext,
|
|
aIncludeDynamicToolbar)) {
|
|
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::CalculateBoundingCompositionSize(
|
|
const 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->GetInProcessRootContentDocumentPresContext();
|
|
if (!rootPresContext) {
|
|
rootPresContext = presContext->GetRootPresContext();
|
|
}
|
|
PresShell* rootPresShell = nullptr;
|
|
if (rootPresContext) {
|
|
rootPresShell = rootPresContext->PresShell();
|
|
if (nsIFrame* rootFrame = rootPresShell->GetRootFrame()) {
|
|
ParentLayerRect compBounds;
|
|
if (UpdateCompositionBoundsForRCDRSF(compBounds, rootPresContext)) {
|
|
rootCompositionSize = ViewAs<ScreenPixel>(
|
|
compBounds.Size(),
|
|
PixelCastJustification::ScreenIsParentLayerForRoot);
|
|
} else {
|
|
// LayoutDeviceToScreenScale2D =
|
|
// LayoutDeviceToParentLayerScale *
|
|
// ParentLayerToScreenScale2D
|
|
LayoutDeviceToScreenScale2D cumulativeResolution =
|
|
LayoutDeviceToParentLayerScale(
|
|
rootPresShell->GetCumulativeResolution()) *
|
|
GetTransformToAncestorScaleCrossProcessForFrameMetrics(rootFrame);
|
|
|
|
int32_t rootAUPerDevPixel = rootPresContext->AppUnitsPerDevPixel();
|
|
rootCompositionSize = (LayoutDeviceRect::FromAppUnits(
|
|
rootFrame->GetRect(), rootAUPerDevPixel) *
|
|
cumulativeResolution)
|
|
.Size();
|
|
}
|
|
}
|
|
} 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();
|
|
|
|
CSSSize result =
|
|
rootCompositionSize / aMetrics.DisplayportPixelsPerCSSPixel();
|
|
|
|
// If this is a nested content process, the in-process root content document's
|
|
// composition size may still be arbitrarily large, so bound it further by
|
|
// how much of the in-process RCD is visible in the top-level (cross-process
|
|
// RCD) viewport.
|
|
if (rootPresShell) {
|
|
if (BrowserChild* bc = BrowserChild::GetFrom(rootPresShell)) {
|
|
if (const auto& visibleRect =
|
|
bc->GetTopLevelViewportVisibleRectInSelfCoords()) {
|
|
CSSSize cssVisibleRect =
|
|
visibleRect->Size() / rootPresContext->CSSToDevPixelScale();
|
|
result = Min(result, cssVisibleRect);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::CalculateScrollableRectForFrame(
|
|
const nsIScrollableFrame* aScrollableFrame, const nsIFrame* aRootFrame) {
|
|
nsRect contentBounds;
|
|
if (aScrollableFrame) {
|
|
contentBounds = aScrollableFrame->GetScrollRange();
|
|
|
|
nsPoint scrollPosition = aScrollableFrame->GetScrollPosition();
|
|
if (aScrollableFrame->GetScrollStyles().mVertical ==
|
|
StyleOverflow::Hidden) {
|
|
contentBounds.y = scrollPosition.y;
|
|
contentBounds.height = 0;
|
|
}
|
|
if (aScrollableFrame->GetScrollStyles().mHorizontal ==
|
|
StyleOverflow::Hidden) {
|
|
contentBounds.x = scrollPosition.x;
|
|
contentBounds.width = 0;
|
|
}
|
|
|
|
contentBounds.width += aScrollableFrame->GetScrollPortRect().width;
|
|
contentBounds.height += aScrollableFrame->GetScrollPortRect().height;
|
|
} else {
|
|
contentBounds = aRootFrame->GetRect();
|
|
// Clamp to (0, 0) if there is no corresponding scrollable frame for the
|
|
// given |aRootFrame|.
|
|
contentBounds.MoveTo(0, 0);
|
|
}
|
|
return contentBounds;
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::CalculateExpandedScrollableRect(nsIFrame* aFrame) {
|
|
nsRect scrollableRect = CalculateScrollableRectForFrame(
|
|
aFrame->GetScrollTargetFrame(), aFrame->PresShell()->GetRootFrame());
|
|
nsSize compSize = CalculateCompositionSizeForFrame(aFrame);
|
|
|
|
if (aFrame == aFrame->PresShell()->GetRootScrollFrame()) {
|
|
// the composition size for the root scroll frame does not include the
|
|
// local resolution, so we adjust.
|
|
float res = aFrame->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(WebRenderLayerManager* aManager,
|
|
ViewID aScrollId,
|
|
const std::string& aKey,
|
|
const std::string& aValue) {
|
|
MOZ_ASSERT(nsLayoutUtils::IsAPZTestLoggingEnabled(), "don't call me");
|
|
aManager->LogTestDataForCurrentPaint(aScrollId, aKey, aValue);
|
|
}
|
|
|
|
void nsLayoutUtils::LogAdditionalTestData(nsDisplayListBuilder* aBuilder,
|
|
const std::string& aKey,
|
|
const std::string& aValue) {
|
|
WebRenderLayerManager* manager = aBuilder->GetWidgetLayerManager(nullptr);
|
|
if (!manager) {
|
|
return;
|
|
}
|
|
manager->LogAdditionalTestData(aKey, aValue);
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::IsAPZTestLoggingEnabled() {
|
|
return StaticPrefs::apz_test_logging_enabled();
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
// SurfaceFromElementResult
|
|
|
|
SurfaceFromElementResult::SurfaceFromElementResult()
|
|
// Use safe default values here
|
|
: mHadCrossOriginRedirects(false),
|
|
mIsWriteOnly(true),
|
|
mIsStillLoading(false),
|
|
mHasSize(false),
|
|
mCORSUsed(false),
|
|
mAlphaType(gfxAlphaType::Opaque) {}
|
|
|
|
const RefPtr<mozilla::gfx::SourceSurface>&
|
|
SurfaceFromElementResult::GetSourceSurface() {
|
|
if (!mSourceSurface && mLayersImage) {
|
|
mSourceSurface = mLayersImage->GetAsSourceSurface();
|
|
}
|
|
|
|
return mSourceSurface;
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
bool nsLayoutUtils::IsNonWrapperBlock(nsIFrame* aFrame) {
|
|
MOZ_ASSERT(aFrame);
|
|
return aFrame->IsBlockFrameOrSubclass() && !aFrame->IsBlockWrapper();
|
|
}
|
|
|
|
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;
|
|
mOldValue = false;
|
|
}
|
|
}
|
|
|
|
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 mozilla
|
|
|
|
/* 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.IsAlphabeticalBaseline()
|
|
? aLineWM.IsLineInverted() ? fm->MaxDescent() : fm->MaxAscent()
|
|
: fm->MaxHeight() / 2);
|
|
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 */
|
|
// _BOUNDARY because Dispatch() with `targets` must not handle the event.
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY bool
|
|
nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(
|
|
PresShell* aPresShell) {
|
|
if (RefPtr<Document> doc = aPresShell->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 */
|
|
bool nsLayoutUtils::CanScrollOriginClobberApz(ScrollOrigin aScrollOrigin) {
|
|
switch (aScrollOrigin) {
|
|
case ScrollOrigin::None:
|
|
case ScrollOrigin::NotSpecified:
|
|
case ScrollOrigin::Apz:
|
|
case ScrollOrigin::Restore:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
ScrollMetadata nsLayoutUtils::ComputeScrollMetadata(
|
|
const nsIFrame* aForFrame, const nsIFrame* aScrollFrame,
|
|
nsIContent* aContent, const nsIFrame* aItemFrame,
|
|
const nsPoint& aOffsetToReferenceFrame,
|
|
WebRenderLayerManager* aLayerManager, ViewID aScrollParentId,
|
|
const nsSize& aScrollPortSize, bool aIsRootContent) {
|
|
const nsPresContext* presContext = aForFrame->PresContext();
|
|
int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
|
|
|
|
PresShell* presShell = presContext->GetPresShell();
|
|
ScrollMetadata metadata;
|
|
FrameMetrics& metrics = metadata.GetMetrics();
|
|
metrics.SetLayoutViewport(
|
|
CSSRect(CSSPoint(), CSSSize::FromAppUnits(aScrollPortSize)));
|
|
|
|
nsIDocShell* docShell = presContext->GetDocShell();
|
|
const BrowsingContext* bc =
|
|
docShell ? docShell->GetBrowsingContext() : nullptr;
|
|
bool isTouchEventsEnabled =
|
|
bc &&
|
|
bc->TouchEventsOverride() == mozilla::dom::TouchEventsOverride::Enabled;
|
|
|
|
if (bc && bc->InRDMPane() && isTouchEventsEnabled) {
|
|
metadata.SetIsRDMTouchSimulationActive(true);
|
|
}
|
|
|
|
ViewID scrollId = ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
if (aContent) {
|
|
if (void* paintRequestTime =
|
|
aContent->GetProperty(nsGkAtoms::paintRequestTime)) {
|
|
metrics.SetPaintRequestTime(*static_cast<TimeStamp*>(paintRequestTime));
|
|
aContent->RemoveProperty(nsGkAtoms::paintRequestTime);
|
|
}
|
|
scrollId = nsLayoutUtils::FindOrCreateIDFor(aContent);
|
|
nsRect dp;
|
|
if (DisplayPortUtils::GetDisplayPort(aContent, &dp)) {
|
|
metrics.SetDisplayPort(CSSRect::FromAppUnits(dp));
|
|
DisplayPortUtils::MarkDisplayPortAsPainted(aContent);
|
|
}
|
|
|
|
metrics.SetHasNonZeroDisplayPortMargins(false);
|
|
if (DisplayPortMarginsPropertyData* currentData =
|
|
static_cast<DisplayPortMarginsPropertyData*>(
|
|
aContent->GetProperty(nsGkAtoms::DisplayPortMargins))) {
|
|
if (currentData->mMargins.mMargins != ScreenMargin()) {
|
|
metrics.SetHasNonZeroDisplayPortMargins(true);
|
|
}
|
|
}
|
|
|
|
// Note: GetProperty() will return nullptr both in the case where
|
|
// the property hasn't been set, and in the case where the property
|
|
// has been set to false (in which case the property value is
|
|
// `reinterpret_cast<void*>(false)` which is nullptr.
|
|
if (aContent->GetProperty(nsGkAtoms::forceMousewheelAutodir)) {
|
|
metadata.SetForceMousewheelAutodir(true);
|
|
}
|
|
|
|
if (aContent->GetProperty(nsGkAtoms::forceMousewheelAutodirHonourRoot)) {
|
|
metadata.SetForceMousewheelAutodirHonourRoot(true);
|
|
}
|
|
|
|
if (IsAPZTestLoggingEnabled()) {
|
|
LogTestDataForPaint(aLayerManager, scrollId, "displayport",
|
|
metrics.GetDisplayPort());
|
|
}
|
|
|
|
metrics.SetMinimalDisplayPort(
|
|
aContent->GetProperty(nsGkAtoms::MinimalDisplayPort));
|
|
}
|
|
|
|
nsIScrollableFrame* scrollableFrame = nullptr;
|
|
if (aScrollFrame) scrollableFrame = aScrollFrame->GetScrollTargetFrame();
|
|
|
|
metrics.SetScrollableRect(
|
|
CSSRect::FromAppUnits(nsLayoutUtils::CalculateScrollableRectForFrame(
|
|
scrollableFrame, aForFrame)));
|
|
|
|
if (scrollableFrame) {
|
|
CSSPoint layoutScrollOffset =
|
|
CSSPoint::FromAppUnits(scrollableFrame->GetScrollPosition());
|
|
CSSPoint visualScrollOffset =
|
|
aIsRootContent
|
|
? CSSPoint::FromAppUnits(presShell->GetVisualViewportOffset())
|
|
: layoutScrollOffset;
|
|
metrics.SetVisualScrollOffset(visualScrollOffset);
|
|
// APZ sometimes reads this even if we haven't set a visual scroll
|
|
// update type (specifically, in the isFirstPaint case), so always
|
|
// set it.
|
|
metrics.SetVisualDestination(visualScrollOffset);
|
|
|
|
if (aIsRootContent) {
|
|
if (aLayerManager->GetIsFirstPaint() &&
|
|
presShell->IsVisualViewportOffsetSet()) {
|
|
// Restore the visual viewport offset to the copy stored on the
|
|
// main thread.
|
|
presShell->ScrollToVisual(presShell->GetVisualViewportOffset(),
|
|
FrameMetrics::eRestore, ScrollMode::Instant);
|
|
}
|
|
}
|
|
|
|
if (scrollableFrame->IsRootScrollFrameOfDocument()) {
|
|
if (const Maybe<PresShell::VisualScrollUpdate>& visualUpdate =
|
|
presShell->GetPendingVisualScrollUpdate()) {
|
|
metrics.SetVisualDestination(
|
|
CSSPoint::FromAppUnits(visualUpdate->mVisualScrollOffset));
|
|
metrics.SetVisualScrollUpdateType(visualUpdate->mUpdateType);
|
|
presShell->AcknowledgePendingVisualScrollUpdate();
|
|
}
|
|
}
|
|
|
|
if (aIsRootContent) {
|
|
// Expand the layout viewport to the size including the area covered by
|
|
// the dynamic toolbar in the case where the dynamic toolbar is being
|
|
// used, otherwise when the dynamic toolbar transitions on the compositor,
|
|
// the layout viewport will be smaller than the visual viewport on the
|
|
// compositor, thus the layout viewport offset will be forced to be moved
|
|
// in FrameMetrics::KeepLayoutViewportEnclosingVisualViewport.
|
|
if (presContext->HasDynamicToolbar()) {
|
|
CSSRect viewport = metrics.GetLayoutViewport();
|
|
viewport.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar(
|
|
presContext, viewport.Size()));
|
|
metrics.SetLayoutViewport(viewport);
|
|
|
|
// We need to set 'fixed margins' to adjust 'fixed margins' value on the
|
|
// composiutor in the case where the dynamic toolbar is completely
|
|
// hidden because the margin value on the compositor is offset from the
|
|
// position where the dynamic toolbar is completely VISIBLE but now the
|
|
// toolbar is completely HIDDEN we need to adjust the difference on the
|
|
// compositor.
|
|
if (presContext->GetDynamicToolbarState() ==
|
|
DynamicToolbarState::Collapsed) {
|
|
metrics.SetFixedLayerMargins(ScreenMargin(
|
|
0, 0,
|
|
ScreenCoord(presContext->GetDynamicToolbarHeight() -
|
|
presContext->GetDynamicToolbarMaxHeight()),
|
|
0));
|
|
}
|
|
}
|
|
}
|
|
|
|
metrics.SetScrollGeneration(scrollableFrame->CurrentScrollGeneration());
|
|
|
|
CSSRect viewport = metrics.GetLayoutViewport();
|
|
viewport.MoveTo(layoutScrollOffset);
|
|
metrics.SetLayoutViewport(viewport);
|
|
|
|
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()) {
|
|
metadata.SetDisregardedDirection(
|
|
WheelHandlingUtils::GetDisregardedWheelScrollDirection(
|
|
aScrollFrame->GetParent()));
|
|
}
|
|
|
|
metadata.SetSnapInfo(scrollableFrame->GetScrollSnapInfo());
|
|
metadata.SetOverscrollBehavior(
|
|
scrollableFrame->GetOverscrollBehaviorInfo());
|
|
metadata.SetScrollUpdates(scrollableFrame->GetScrollUpdates());
|
|
}
|
|
|
|
// 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 == ScrollableLayerGuid::NULL_SCROLL_ID ||
|
|
scrollId != aScrollParentId);
|
|
metrics.SetScrollId(scrollId);
|
|
metrics.SetIsRootContent(aIsRootContent);
|
|
metadata.SetScrollParentId(aScrollParentId);
|
|
|
|
const nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
|
|
bool isRootScrollFrame = aScrollFrame == rootScrollFrame;
|
|
Document* document = presShell->GetDocument();
|
|
|
|
if (scrollId != ScrollableLayerGuid::NULL_SCROLL_ID &&
|
|
!presContext->GetParentPresContext()) {
|
|
if ((aScrollFrame && isRootScrollFrame)) {
|
|
metadata.SetIsLayersIdRoot(true);
|
|
} else {
|
|
MOZ_ASSERT(document, "A non-root-scroll frame must be in a document");
|
|
if (aContent == document->GetDocumentElement()) {
|
|
metadata.SetIsLayersIdRoot(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get whether the root content is RTL(E.g. it's true either if
|
|
// "writing-mode: vertical-rl", or if
|
|
// "writing-mode: horizontal-tb; direction: rtl;" in CSS).
|
|
// For the concept of this and the reason why we need to get this kind of
|
|
// information, see the definition of |mIsAutoDirRootContentRTL| in struct
|
|
// |ScrollMetadata|.
|
|
const Element* bodyElement = document ? document->GetBodyElement() : nullptr;
|
|
const nsIFrame* primaryFrame =
|
|
bodyElement ? bodyElement->GetPrimaryFrame() : rootScrollFrame;
|
|
if (!primaryFrame) {
|
|
primaryFrame = rootScrollFrame;
|
|
}
|
|
if (primaryFrame) {
|
|
WritingMode writingModeOfRootScrollFrame = primaryFrame->GetWritingMode();
|
|
WritingMode::BlockDir blockDirOfRootScrollFrame =
|
|
writingModeOfRootScrollFrame.GetBlockDir();
|
|
WritingMode::InlineDir inlineDirOfRootScrollFrame =
|
|
writingModeOfRootScrollFrame.GetInlineDir();
|
|
if (blockDirOfRootScrollFrame == WritingMode::BlockDir::eBlockRL ||
|
|
(blockDirOfRootScrollFrame == WritingMode::BlockDir::eBlockTB &&
|
|
inlineDirOfRootScrollFrame == WritingMode::InlineDir::eInlineRTL)) {
|
|
metadata.SetIsAutoDirRootContentRTL(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 (isRootScrollFrame) {
|
|
metrics.SetPresShellResolution(presShell->GetResolution());
|
|
} else {
|
|
metrics.SetPresShellResolution(1.0f);
|
|
}
|
|
|
|
if (presShell->IsResolutionUpdated()) {
|
|
metadata.SetResolutionUpdated(true);
|
|
}
|
|
|
|
// 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... except if we're in WebRender in which case we
|
|
// don't have a aContainerParameters. In that case we're also not rasterizing
|
|
// in Gecko anyway, so the only resolution we care about here is the presShell
|
|
// resolution which we need to propagate to WebRender.
|
|
metrics.SetCumulativeResolution(
|
|
LayoutDeviceToLayerScale(presShell->GetCumulativeResolution()));
|
|
|
|
metrics.SetTransformToAncestorScale(
|
|
GetTransformToAncestorScaleCrossProcessForFrameMetrics(
|
|
aScrollFrame ? aScrollFrame : aForFrame));
|
|
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.
|
|
const nsIFrame* frameForCompositionBoundsCalculation =
|
|
aScrollFrame ? aScrollFrame : aForFrame;
|
|
nsRect compositionBounds(
|
|
frameForCompositionBoundsCalculation->GetOffsetToCrossDoc(aItemFrame) +
|
|
aOffsetToReferenceFrame,
|
|
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;
|
|
|
|
// 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 isRootContentDocRootScrollFrame =
|
|
isRootScrollFrame && presContext->IsRootContentDocumentCrossProcess();
|
|
if (isRootContentDocRootScrollFrame) {
|
|
UpdateCompositionBoundsForRCDRSF(frameBounds, presContext);
|
|
if (RefPtr<MobileViewportManager> MVM =
|
|
presContext->PresShell()->GetMobileViewportManager()) {
|
|
metrics.SetCompositionSizeWithoutDynamicToolbar(
|
|
MVM->GetCompositionSizeWithoutDynamicToolbar());
|
|
}
|
|
}
|
|
|
|
metrics.SetCompositionBoundsWidthIgnoringScrollbars(frameBounds.width);
|
|
|
|
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.SetBoundingCompositionSize(
|
|
nsLayoutUtils::CalculateBoundingCompositionSize(
|
|
aScrollFrame ? aScrollFrame : aForFrame,
|
|
isRootContentDocRootScrollFrame, metrics));
|
|
|
|
if (StaticPrefs::apz_printtree() || StaticPrefs::apz_test_logging_enabled()) {
|
|
if (const nsIContent* content =
|
|
frameForCompositionBoundsCalculation->GetContent()) {
|
|
nsAutoString contentDescription;
|
|
if (content->IsElement()) {
|
|
content->AsElement()->Describe(contentDescription);
|
|
} else {
|
|
contentDescription.AssignLiteral("(not an element)");
|
|
}
|
|
metadata.SetContentDescription(
|
|
NS_LossyConvertUTF16toASCII(contentDescription));
|
|
if (IsAPZTestLoggingEnabled()) {
|
|
LogTestDataForPaint(aLayerManager, 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);
|
|
}
|
|
|
|
if (ShouldDisableApzForElement(aContent)) {
|
|
metadata.SetForceDisableApz(true);
|
|
}
|
|
|
|
metadata.SetIsPaginatedPresentation(presContext->Type() !=
|
|
nsPresContext::eContext_Galley);
|
|
|
|
return metadata;
|
|
}
|
|
|
|
/*static*/
|
|
Maybe<ScrollMetadata> nsLayoutUtils::GetRootMetadata(
|
|
nsDisplayListBuilder* aBuilder, WebRenderLayerManager* aLayerManager,
|
|
const std::function<bool(ViewID& aScrollId)>& aCallback) {
|
|
nsIFrame* frame = aBuilder->RootReferenceFrame();
|
|
nsPresContext* presContext = frame->PresContext();
|
|
PresShell* presShell = presContext->PresShell();
|
|
Document* document = presShell->GetDocument();
|
|
|
|
// There is one case where we want the root container layer to have metrics.
|
|
// If the parent process is using XUL windows, there is no root scrollframe,
|
|
// and without explicitly creating metrics there will be no guaranteed
|
|
// top-level APZC.
|
|
bool addMetrics = XRE_IsParentProcess() && !presShell->GetRootScrollFrame();
|
|
|
|
// Add metrics if there are none in the layer tree with the id (create an id
|
|
// if there isn't one already) of the root scroll frame/root content.
|
|
bool ensureMetricsForRootId = nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
|
|
aBuilder->IsPaintingToWindow() &&
|
|
!presContext->GetParentPresContext();
|
|
|
|
nsIContent* content = nullptr;
|
|
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
|
|
if (rootScrollFrame) {
|
|
content = rootScrollFrame->GetContent();
|
|
} else {
|
|
// If there is no root scroll frame, pick the document element instead.
|
|
// The only case we don't want to do this is in non-APZ fennec, where
|
|
// we want the root xul document to get a null scroll id so that the root
|
|
// content document gets the first non-null scroll id.
|
|
content = document->GetDocumentElement();
|
|
}
|
|
|
|
if (ensureMetricsForRootId && content) {
|
|
ViewID scrollId = nsLayoutUtils::FindOrCreateIDFor(content);
|
|
if (aCallback(scrollId)) {
|
|
ensureMetricsForRootId = false;
|
|
}
|
|
}
|
|
|
|
if (addMetrics || ensureMetricsForRootId) {
|
|
bool isRootContent = presContext->IsRootContentDocumentCrossProcess();
|
|
|
|
nsSize scrollPortSize = frame->GetSize();
|
|
if (isRootContent && rootScrollFrame) {
|
|
nsIScrollableFrame* scrollableFrame =
|
|
rootScrollFrame->GetScrollTargetFrame();
|
|
scrollPortSize = scrollableFrame->GetScrollPortRect().Size();
|
|
}
|
|
return Some(nsLayoutUtils::ComputeScrollMetadata(
|
|
frame, rootScrollFrame, content, frame,
|
|
aBuilder->ToReferenceFrame(frame), aLayerManager,
|
|
ScrollableLayerGuid::NULL_SCROLL_ID, scrollPortSize, isRootContent));
|
|
}
|
|
|
|
return Nothing();
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::TransformToAncestorAndCombineRegions(
|
|
const nsRegion& aRegion, nsIFrame* aFrame, const nsIFrame* aAncestorFrame,
|
|
nsRegion* aPreciseTargetDest, nsRegion* aImpreciseTargetDest,
|
|
Maybe<Matrix4x4Flagged>* aMatrixCache, const DisplayItemClip* aClip) {
|
|
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);
|
|
if (aClip) {
|
|
transformed = aClip->ApplyNonRoundedIntersection(transformed);
|
|
if (aClip->GetRoundedRectCount() > 0) {
|
|
isPrecise = false;
|
|
}
|
|
}
|
|
transformedRegion.OrWith(transformed);
|
|
}
|
|
nsRegion* dest = isPrecise ? aPreciseTargetDest : aImpreciseTargetDest;
|
|
dest->OrWith(transformedRegion.ToRegion());
|
|
// If the region becomes too complex this has a large performance impact.
|
|
// We limit its complexity here.
|
|
if (dest->GetNumRects() > 12) {
|
|
dest->SimplifyOutward(6);
|
|
if (isPrecise) {
|
|
aPreciseTargetDest->OrWith(*aImpreciseTargetDest);
|
|
*aImpreciseTargetDest = std::move(*aPreciseTargetDest);
|
|
aImpreciseTargetDest->SimplifyOutward(6);
|
|
*aPreciseTargetDest = nsRegion();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::ShouldUseNoFramesSheet(Document* 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->IsTextFrame()) {
|
|
auto* const textFrame = static_cast<nsTextFrame*>(aFrame);
|
|
const auto offset = AssertedCast<uint32_t>(textFrame->GetContentOffset());
|
|
const auto length = AssertedCast<uint32_t>(textFrame->GetContentLength());
|
|
textFrame->TextFragment()->AppendTo(aResult, offset, length);
|
|
} else {
|
|
for (nsIFrame* child : aFrame->PrincipalChildList()) {
|
|
AppendFrameTextContent(child, aResult);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::GetSelectionBoundingRect(const 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 {
|
|
RectAccumulator accumulator;
|
|
const uint32_t rangeCount = aSel->RangeCount();
|
|
for (const uint32_t idx : IntegerRange(rangeCount)) {
|
|
MOZ_ASSERT(aSel->RangeCount() == rangeCount);
|
|
nsRange* range = aSel->GetRangeAt(idx);
|
|
nsRange::CollectClientRectsAndText(
|
|
&accumulator, nullptr, range, range->GetStartContainer(),
|
|
range->StartOffset(), range->GetEndContainer(), 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 || ancestor->IsBlockFrameOrSubclass(),
|
|
"Float containing block can only be block frame");
|
|
return static_cast<nsBlockFrame*>(ancestor);
|
|
}
|
|
|
|
// The implementations of this calculation are adapted from
|
|
// Element::GetBoundingClientRect().
|
|
/* static */
|
|
CSSRect nsLayoutUtils::GetBoundingContentRect(
|
|
const nsIContent* aContent, const nsIScrollableFrame* aRootScrollFrame,
|
|
Maybe<CSSRect>* aOutNearestScrollClip) {
|
|
if (nsIFrame* frame = aContent->GetPrimaryFrame()) {
|
|
return GetBoundingFrameRect(frame, aRootScrollFrame, aOutNearestScrollClip);
|
|
}
|
|
return CSSRect();
|
|
}
|
|
|
|
/* static */
|
|
CSSRect nsLayoutUtils::GetBoundingFrameRect(
|
|
nsIFrame* aFrame, const nsIScrollableFrame* aRootScrollFrame,
|
|
Maybe<CSSRect>* aOutNearestScrollClip) {
|
|
CSSRect result;
|
|
nsIFrame* relativeTo = aRootScrollFrame->GetScrolledFrame();
|
|
result = CSSRect::FromAppUnits(nsLayoutUtils::GetAllInFlowRectsUnion(
|
|
aFrame, 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(
|
|
aFrame, SCROLLABLE_INCLUDE_HIDDEN | SCROLLABLE_FIXEDPOS_FINDS_ROOT);
|
|
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|.
|
|
nsRect subFrameRect = subFrame->GetRectRelativeToSelf();
|
|
TransformResult res =
|
|
nsLayoutUtils::TransformRect(subFrame, relativeTo, subFrameRect);
|
|
MOZ_ASSERT(res == TRANSFORM_SUCCEEDED || res == NONINVERTIBLE_TRANSFORM);
|
|
if (res == TRANSFORM_SUCCEEDED) {
|
|
CSSRect subFrameRectCSS = CSSRect::FromAppUnits(subFrameRect);
|
|
if (aOutNearestScrollClip) {
|
|
*aOutNearestScrollClip = Some(subFrameRectCSS);
|
|
}
|
|
|
|
result = subFrameRectCSS.Intersect(result);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* 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> lastContent;
|
|
bool seenRcdRsf = false;
|
|
|
|
// Helper lambda to apply the callback transform for a single frame.
|
|
auto applyCallbackTransformForFrame = [&](nsIFrame* frame) {
|
|
if (frame) {
|
|
nsCOMPtr<nsIContent> content = frame->GetContent();
|
|
if (content && (content != lastContent)) {
|
|
void* property = content->GetProperty(nsGkAtoms::apzCallbackTransform);
|
|
if (property) {
|
|
delta += *static_cast<CSSPoint*>(property);
|
|
}
|
|
}
|
|
lastContent = content;
|
|
}
|
|
};
|
|
|
|
while (frame) {
|
|
// Apply the callback transform for the current frame.
|
|
applyCallbackTransformForFrame(frame);
|
|
|
|
// Keep track of whether we've encountered the RCD-RSF's content element.
|
|
nsPresContext* pc = frame->PresContext();
|
|
if (pc->IsRootContentDocumentCrossProcess()) {
|
|
if (PresShell* shell = pc->GetPresShell()) {
|
|
if (nsIFrame* rsf = shell->GetRootScrollFrame()) {
|
|
if (frame->GetContent() == rsf->GetContent()) {
|
|
seenRcdRsf = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we reach the RCD's viewport frame, but have not encountered
|
|
// the RCD-RSF, we were inside fixed content in the RCD.
|
|
// We still want to apply the RCD-RSF's callback transform because
|
|
// it contains the offset between the visual and layout viewports
|
|
// which applies to fixed content as well.
|
|
ViewportFrame* viewportFrame = do_QueryFrame(frame);
|
|
if (viewportFrame) {
|
|
if (pc->IsRootContentDocumentCrossProcess() && !seenRcdRsf) {
|
|
applyCallbackTransformForFrame(pc->PresShell()->GetRootScrollFrame());
|
|
}
|
|
}
|
|
|
|
// Proceed to the parent frame.
|
|
frame = GetCrossDocParentFrameInProcess(frame);
|
|
}
|
|
return delta;
|
|
}
|
|
|
|
static nsSize ComputeMaxSizeForPartialPrerender(nsIFrame* aFrame,
|
|
nsSize aMaxSize) {
|
|
Matrix4x4Flagged transform = nsLayoutUtils::GetTransformToAncestor(
|
|
RelativeTo{aFrame},
|
|
RelativeTo{nsLayoutUtils::GetDisplayRootFrame(aFrame)});
|
|
|
|
Matrix transform2D;
|
|
if (!transform.Is2D(&transform2D)) {
|
|
return aMaxSize;
|
|
}
|
|
|
|
gfx::Rect result(0, 0, aMaxSize.width, aMaxSize.height);
|
|
auto scale = transform2D.ScaleFactors();
|
|
if (scale.xScale != 0 && scale.yScale != 0) {
|
|
result.width /= scale.xScale;
|
|
result.height /= scale.yScale;
|
|
}
|
|
|
|
// Don't apply translate.
|
|
transform2D._31 = 0.0f;
|
|
transform2D._32 = 0.0f;
|
|
|
|
// Don't apply scale.
|
|
if (scale.xScale != 0 && scale.yScale != 0) {
|
|
transform2D._11 /= scale.xScale;
|
|
transform2D._12 /= scale.xScale;
|
|
transform2D._21 /= scale.yScale;
|
|
transform2D._22 /= scale.yScale;
|
|
}
|
|
|
|
// Theoretically we should use transform2D.Inverse() here but in this case
|
|
// |transform2D| is a pure rotation matrix, no scaling, no translate at all,
|
|
// so that the result bound's width and height would be pretty much same
|
|
// as the one rotated by the inverse matrix.
|
|
result = transform2D.TransformBounds(result);
|
|
return nsSize(
|
|
result.width < (float)nscoord_MAX ? result.width : nscoord_MAX,
|
|
result.height < (float)nscoord_MAX ? result.height : nscoord_MAX);
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::ComputePartialPrerenderArea(
|
|
nsIFrame* aFrame, const nsRect& aDirtyRect, const nsRect& aOverflow,
|
|
const nsSize& aPrerenderSize) {
|
|
nsSize maxSizeForPartialPrerender =
|
|
ComputeMaxSizeForPartialPrerender(aFrame, aPrerenderSize);
|
|
// Simple calculation for now: center the pre-render area on the dirty rect,
|
|
// and clamp to the overflow area. Later we can do more advanced things like
|
|
// redistributing from one axis to another, or from one side to another.
|
|
nscoord xExcess =
|
|
std::max(maxSizeForPartialPrerender.width - aDirtyRect.width, 0);
|
|
nscoord yExcess =
|
|
std::max(maxSizeForPartialPrerender.height - aDirtyRect.height, 0);
|
|
nsRect result = aDirtyRect;
|
|
result.Inflate(xExcess / 2, yExcess / 2);
|
|
return result.MoveInsideAndClamp(aOverflow);
|
|
}
|
|
|
|
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->IsInlineFrame()) {
|
|
for (nsIFrame* child : aFrame->PrincipalChildList()) {
|
|
if (LineHasNonEmptyContentWorker(child)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
if (!aFrame->IsBrFrame() && !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->IsBrFrame()) {
|
|
return false;
|
|
}
|
|
|
|
nsContainerFrame* f = frame->GetParent();
|
|
while (f && f->IsFrameOfType(nsIFrame::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 nsLayoutUtils::ComputeSVGOriginBox(SVGViewportElement* aElement) {
|
|
if (!aElement) {
|
|
return {};
|
|
}
|
|
|
|
if (aElement->HasViewBox()) {
|
|
// Return the "origin box", which is defined as a rect positioned at the
|
|
// origin, but with the width and height given by the viewBox attribute
|
|
//
|
|
// https://drafts.csswg.org/css-box-3/#valdef-box-view-box
|
|
//
|
|
// For more discussion see
|
|
// https://github.com/web-platform-tests/interop/issues/509
|
|
const SVGViewBox& value = aElement->GetAnimatedViewBox()->GetAnimValue();
|
|
return nsRect(0, 0, nsPresContext::CSSPixelsToAppUnits(value.width),
|
|
nsPresContext::CSSPixelsToAppUnits(value.height));
|
|
}
|
|
|
|
// No viewBox is specified, uses the nearest SVG viewport as reference
|
|
// box.
|
|
svgFloatSize viewportSize = aElement->GetViewportSize();
|
|
return nsRect(0, 0, nsPresContext::CSSPixelsToAppUnits(viewportSize.width),
|
|
nsPresContext::CSSPixelsToAppUnits(viewportSize.height));
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::ComputeSVGReferenceRect(nsIFrame* aFrame,
|
|
StyleGeometryBox aGeometryBox) {
|
|
MOZ_ASSERT(aFrame->GetContent()->IsSVGElement());
|
|
nsRect r;
|
|
|
|
switch (aGeometryBox) {
|
|
case StyleGeometryBox::StrokeBox: {
|
|
// XXX Bug 1299876
|
|
// The size of stroke-box is not correct if this graphic element has
|
|
// specific stroke-linejoin or stroke-linecap.
|
|
gfxRect bbox =
|
|
SVGUtils::GetBBox(aFrame, SVGUtils::eBBoxIncludeFillGeometry |
|
|
SVGUtils::eBBoxIncludeStroke);
|
|
r = nsLayoutUtils::RoundGfxRectToAppRect(bbox, AppUnitsPerCSSPixel());
|
|
break;
|
|
}
|
|
case StyleGeometryBox::ViewBox: {
|
|
SVGViewportElement* viewportElement =
|
|
SVGElement::FromNode(aFrame->GetContent())->GetCtx();
|
|
if (!viewportElement) {
|
|
// We should not render without a viewport so return an empty rect.
|
|
break;
|
|
}
|
|
r = nsLayoutUtils::ComputeSVGOriginBox(viewportElement);
|
|
break;
|
|
}
|
|
case StyleGeometryBox::FillBox: {
|
|
gfxRect bbox =
|
|
SVGUtils::GetBBox(aFrame, SVGUtils::eBBoxIncludeFillGeometry);
|
|
r = nsLayoutUtils::RoundGfxRectToAppRect(bbox, AppUnitsPerCSSPixel());
|
|
break;
|
|
}
|
|
default: {
|
|
MOZ_ASSERT_UNREACHABLE("unsupported SVG box");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/* static */
|
|
nsRect nsLayoutUtils::ComputeHTMLReferenceRect(const nsIFrame* aFrame,
|
|
StyleGeometryBox aGeometryBox) {
|
|
nsRect r;
|
|
|
|
switch (aGeometryBox) {
|
|
case StyleGeometryBox::ContentBox:
|
|
r = aFrame->GetContentRectRelativeToSelf();
|
|
break;
|
|
case StyleGeometryBox::PaddingBox:
|
|
r = aFrame->GetPaddingRectRelativeToSelf();
|
|
break;
|
|
case StyleGeometryBox::MarginBox:
|
|
r = aFrame->GetMarginRectRelativeToSelf();
|
|
break;
|
|
case StyleGeometryBox::BorderBox:
|
|
r = aFrame->GetRectRelativeToSelf();
|
|
break;
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("unsupported CSS box");
|
|
break;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
static StyleGeometryBox ShapeBoxToGeometryBox(const StyleShapeBox& aBox) {
|
|
switch (aBox) {
|
|
case StyleShapeBox::BorderBox:
|
|
return StyleGeometryBox::BorderBox;
|
|
case StyleShapeBox::ContentBox:
|
|
return StyleGeometryBox::ContentBox;
|
|
case StyleShapeBox::MarginBox:
|
|
return StyleGeometryBox::MarginBox;
|
|
case StyleShapeBox::PaddingBox:
|
|
return StyleGeometryBox::PaddingBox;
|
|
}
|
|
MOZ_ASSERT_UNREACHABLE("Unknown shape box type");
|
|
return StyleGeometryBox::MarginBox;
|
|
}
|
|
|
|
static StyleGeometryBox ClipPathBoxToGeometryBox(
|
|
const StyleShapeGeometryBox& aBox) {
|
|
using Tag = StyleShapeGeometryBox::Tag;
|
|
switch (aBox.tag) {
|
|
case Tag::ShapeBox:
|
|
return ShapeBoxToGeometryBox(aBox.AsShapeBox());
|
|
case Tag::ElementDependent:
|
|
return StyleGeometryBox::NoBox;
|
|
case Tag::FillBox:
|
|
return StyleGeometryBox::FillBox;
|
|
case Tag::StrokeBox:
|
|
return StyleGeometryBox::StrokeBox;
|
|
case Tag::ViewBox:
|
|
return StyleGeometryBox::ViewBox;
|
|
}
|
|
MOZ_ASSERT_UNREACHABLE("Unknown shape box type");
|
|
return StyleGeometryBox::NoBox;
|
|
}
|
|
|
|
// The mapping is from
|
|
// https://drafts.fxtf.org/css-masking-1/#typedef-geometry-box
|
|
/* static */
|
|
nsRect nsLayoutUtils::ComputeClipPathGeometryBox(
|
|
nsIFrame* aFrame, const StyleShapeGeometryBox& aBox) {
|
|
StyleGeometryBox box = ClipPathBoxToGeometryBox(aBox);
|
|
|
|
if (aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
|
|
// For SVG elements without associated CSS layout box, the used value for
|
|
// content-box and padding-box is fill-box and for border-box and margin-box
|
|
// is stroke-box.
|
|
switch (box) {
|
|
case StyleGeometryBox::ContentBox:
|
|
case StyleGeometryBox::PaddingBox:
|
|
case StyleGeometryBox::FillBox:
|
|
return ComputeSVGReferenceRect(aFrame, StyleGeometryBox::FillBox);
|
|
case StyleGeometryBox::NoBox:
|
|
case StyleGeometryBox::BorderBox:
|
|
case StyleGeometryBox::MarginBox:
|
|
case StyleGeometryBox::StrokeBox:
|
|
return ComputeSVGReferenceRect(aFrame, StyleGeometryBox::StrokeBox);
|
|
case StyleGeometryBox::ViewBox:
|
|
return ComputeSVGReferenceRect(aFrame, StyleGeometryBox::ViewBox);
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("Unknown clip-path geometry box");
|
|
// Use default, border-box (as stroke-box in SVG layout).
|
|
return ComputeSVGReferenceRect(aFrame, StyleGeometryBox::StrokeBox);
|
|
}
|
|
}
|
|
|
|
// For elements with associated CSS layout box, the used value for fill-box is
|
|
// content-box and for stroke-box and view-box is border-box.
|
|
switch (box) {
|
|
case StyleGeometryBox::FillBox:
|
|
case StyleGeometryBox::ContentBox:
|
|
return ComputeHTMLReferenceRect(aFrame, StyleGeometryBox::ContentBox);
|
|
case StyleGeometryBox::NoBox:
|
|
case StyleGeometryBox::StrokeBox:
|
|
case StyleGeometryBox::ViewBox:
|
|
case StyleGeometryBox::BorderBox:
|
|
return ComputeHTMLReferenceRect(aFrame, StyleGeometryBox::BorderBox);
|
|
case StyleGeometryBox::PaddingBox:
|
|
return ComputeHTMLReferenceRect(aFrame, StyleGeometryBox::PaddingBox);
|
|
case StyleGeometryBox::MarginBox:
|
|
return ComputeHTMLReferenceRect(aFrame, StyleGeometryBox::MarginBox);
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("Unknown clip-path geometry box");
|
|
// Use default, border-box.
|
|
return ComputeHTMLReferenceRect(aFrame, StyleGeometryBox::BorderBox);
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
nsPoint nsLayoutUtils::ComputeOffsetToUserSpace(nsDisplayListBuilder* aBuilder,
|
|
nsIFrame* aFrame) {
|
|
nsPoint offsetToBoundingBox =
|
|
aBuilder->ToReferenceFrame(aFrame) -
|
|
SVGIntegrationUtils::GetOffsetToBoundingBox(aFrame);
|
|
if (!aFrame->IsFrameOfType(nsIFrame::eSVG)) {
|
|
// Snap the offset if the reference frame is not a SVG frame, since other
|
|
// frames will be snapped to pixel when rendering.
|
|
offsetToBoundingBox =
|
|
nsPoint(aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(
|
|
offsetToBoundingBox.x),
|
|
aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(
|
|
offsetToBoundingBox.y));
|
|
}
|
|
|
|
// During SVG painting, the offset computed here is applied to the gfxContext
|
|
// "ctx" used to paint the mask. After applying only "offsetToBoundingBox",
|
|
// "ctx" would have its origin at the top left corner of frame's bounding box
|
|
// (over all continuations).
|
|
// However, SVG painting needs the origin to be located at the origin of the
|
|
// SVG frame's "user space", i.e. the space in which, for example, the
|
|
// frame's BBox lives.
|
|
// SVG geometry frames and foreignObject frames apply their own offsets, so
|
|
// their position is relative to their user space. So for these frame types,
|
|
// if we want "ctx" to be in user space, we first need to subtract the
|
|
// frame's position so that SVG painting can later add it again and the
|
|
// frame is painted in the right place.
|
|
gfxPoint toUserSpaceGfx =
|
|
SVGUtils::FrameSpaceInCSSPxToUserSpaceOffset(aFrame);
|
|
nsPoint toUserSpace =
|
|
nsPoint(nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.x)),
|
|
nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.y)));
|
|
|
|
return (offsetToBoundingBox - toUserSpace);
|
|
}
|
|
|
|
/* static */
|
|
already_AddRefed<nsFontMetrics> nsLayoutUtils::GetMetricsFor(
|
|
nsPresContext* aPresContext, bool aIsVertical,
|
|
const nsStyleFont* aStyleFont, Length aFontSize, bool aUseUserFontSet) {
|
|
nsFont font = aStyleFont->mFont;
|
|
font.size = aFontSize;
|
|
gfxFont::Orientation orientation =
|
|
aIsVertical ? nsFontMetrics::eVertical : nsFontMetrics::eHorizontal;
|
|
nsFontMetrics::Params params;
|
|
params.language = aStyleFont->mLanguage;
|
|
params.explicitLanguage = aStyleFont->mExplicitLanguage;
|
|
params.orientation = orientation;
|
|
params.userFontSet =
|
|
aUseUserFontSet ? aPresContext->GetUserFontSet() : nullptr;
|
|
params.textPerf = aPresContext->GetTextPerfMetrics();
|
|
params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
|
|
return aPresContext->GetMetricsFor(font, params);
|
|
}
|
|
|
|
/* static */
|
|
void nsLayoutUtils::ComputeSystemFont(nsFont* aSystemFont,
|
|
LookAndFeel::FontID aFontID,
|
|
const nsFont& aDefaultVariableFont,
|
|
const Document* aDocument) {
|
|
gfxFontStyle fontStyle;
|
|
nsAutoString systemFontName;
|
|
if (!LookAndFeel::GetFont(aFontID, systemFontName, fontStyle)) {
|
|
return;
|
|
}
|
|
systemFontName.Trim("\"'");
|
|
NS_ConvertUTF16toUTF8 nameu8(systemFontName);
|
|
Servo_FontFamily_ForSystemFont(&nameu8, &aSystemFont->family);
|
|
aSystemFont->style = fontStyle.style;
|
|
aSystemFont->family.is_system_font = fontStyle.systemFont;
|
|
aSystemFont->weight = fontStyle.weight;
|
|
aSystemFont->stretch = fontStyle.stretch;
|
|
aSystemFont->size = Length::FromPixels(fontStyle.size);
|
|
|
|
// aSystemFont->langGroup = fontStyle.langGroup;
|
|
|
|
switch (StyleFontSizeAdjust::Tag(fontStyle.sizeAdjustBasis)) {
|
|
case StyleFontSizeAdjust::Tag::None:
|
|
aSystemFont->sizeAdjust = StyleFontSizeAdjust::None();
|
|
break;
|
|
case StyleFontSizeAdjust::Tag::ExHeight:
|
|
aSystemFont->sizeAdjust =
|
|
StyleFontSizeAdjust::ExHeight(fontStyle.sizeAdjust);
|
|
break;
|
|
case StyleFontSizeAdjust::Tag::CapHeight:
|
|
aSystemFont->sizeAdjust =
|
|
StyleFontSizeAdjust::CapHeight(fontStyle.sizeAdjust);
|
|
break;
|
|
case StyleFontSizeAdjust::Tag::ChWidth:
|
|
aSystemFont->sizeAdjust =
|
|
StyleFontSizeAdjust::ChWidth(fontStyle.sizeAdjust);
|
|
break;
|
|
case StyleFontSizeAdjust::Tag::IcWidth:
|
|
aSystemFont->sizeAdjust =
|
|
StyleFontSizeAdjust::IcWidth(fontStyle.sizeAdjust);
|
|
break;
|
|
case StyleFontSizeAdjust::Tag::IcHeight:
|
|
aSystemFont->sizeAdjust =
|
|
StyleFontSizeAdjust::IcHeight(fontStyle.sizeAdjust);
|
|
break;
|
|
}
|
|
|
|
if (aFontID == LookAndFeel::FontID::MozField ||
|
|
aFontID == LookAndFeel::FontID::MozButton ||
|
|
aFontID == LookAndFeel::FontID::MozList) {
|
|
// For textfields, buttons and selects, we use whatever font is defined by
|
|
// the system. Which it appears (and the assumption is) it is always a
|
|
// proportional font. Then we always use 2 points smaller than what the
|
|
// browser has defined as the default proportional font.
|
|
//
|
|
// This matches historical Windows behavior and other browsers.
|
|
auto newSize =
|
|
aDefaultVariableFont.size.ToCSSPixels() - CSSPixel::FromPoints(2.0f);
|
|
aSystemFont->size = Length::FromPixels(std::max(float(newSize), 0.0f));
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
bool nsLayoutUtils::ShouldHandleMetaViewport(const Document* aDocument) {
|
|
auto metaViewportOverride = nsIDocShell::META_VIEWPORT_OVERRIDE_NONE;
|
|
if (aDocument) {
|
|
if (nsIDocShell* docShell = aDocument->GetDocShell()) {
|
|
metaViewportOverride = docShell->GetMetaViewportOverride();
|
|
}
|
|
}
|
|
switch (metaViewportOverride) {
|
|
case nsIDocShell::META_VIEWPORT_OVERRIDE_ENABLED:
|
|
return true;
|
|
case nsIDocShell::META_VIEWPORT_OVERRIDE_DISABLED:
|
|
return false;
|
|
default:
|
|
MOZ_ASSERT(metaViewportOverride ==
|
|
nsIDocShell::META_VIEWPORT_OVERRIDE_NONE);
|
|
// The META_VIEWPORT_OVERRIDE_NONE case means that there is no override
|
|
// and we rely solely on the StaticPrefs.
|
|
return StaticPrefs::dom_meta_viewport_enabled();
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
ComputedStyle* nsLayoutUtils::StyleForScrollbar(
|
|
const nsIFrame* aScrollbarPart) {
|
|
// Get the closest content node which is not an anonymous scrollbar
|
|
// part. It should be the originating element of the scrollbar part.
|
|
nsIContent* content = aScrollbarPart->GetContent();
|
|
// Note that the content may be a normal element with scrollbar part
|
|
// value specified for its -moz-appearance, so don't rely on it being
|
|
// a native anonymous. Also note that we have to check the node name
|
|
// because anonymous element like generated content may originate a
|
|
// scrollbar.
|
|
MOZ_ASSERT(content, "No content for the scrollbar part?");
|
|
while (content && content->IsInNativeAnonymousSubtree() &&
|
|
content->IsAnyOfXULElements(
|
|
nsGkAtoms::scrollbar, nsGkAtoms::scrollbarbutton,
|
|
nsGkAtoms::scrollcorner, nsGkAtoms::slider, nsGkAtoms::thumb)) {
|
|
content = content->GetParent();
|
|
}
|
|
MOZ_ASSERT(content, "Native anonymous element with no originating node?");
|
|
// Use the style from the primary frame of the content.
|
|
// Note: it is important to use the primary frame rather than an
|
|
// ancestor frame of the scrollbar part for the correct handling of
|
|
// viewport scrollbar. The content of the scroll frame of the viewport
|
|
// is the root element, but its style inherits from the viewport.
|
|
// Since we need to use the style of root element for the viewport
|
|
// scrollbar, we have to get the style from the primary frame.
|
|
if (nsIFrame* primaryFrame = content->GetPrimaryFrame()) {
|
|
return primaryFrame->Style();
|
|
}
|
|
// If the element doesn't have primary frame, get the computed style
|
|
// from the element directly. This can happen on viewport, because
|
|
// the scrollbar of viewport may be shown when the root element has
|
|
// > display: none; overflow: scroll;
|
|
MOZ_ASSERT(
|
|
content == aScrollbarPart->PresContext()->Document()->GetRootElement(),
|
|
"Root element is the only case for this fallback "
|
|
"path to be triggered");
|
|
RefPtr<ComputedStyle> style =
|
|
ServoStyleSet::ResolveServoStyle(*content->AsElement());
|
|
// Dropping the strong reference is fine because the style should be
|
|
// held strongly by the element.
|
|
return style.get();
|
|
}
|
|
|
|
enum class FramePosition : uint8_t {
|
|
Unknown,
|
|
InView,
|
|
OutOfView,
|
|
};
|
|
|
|
// NOTE: Returns a pair of Nothing() and `FramePosition::Unknown` if |aFrame|
|
|
// is not in out-of-process or if we haven't received enough information from
|
|
// APZ.
|
|
static std::pair<Maybe<ScreenRect>, FramePosition> GetFrameVisibleRectOnScreen(
|
|
const nsIFrame* aFrame) {
|
|
// We actually want the in-process top prescontext here.
|
|
nsPresContext* topContextInProcess =
|
|
aFrame->PresContext()->GetInProcessRootContentDocumentPresContext();
|
|
if (!topContextInProcess) {
|
|
// We are in chrome process.
|
|
return std::make_pair(Nothing(), FramePosition::Unknown);
|
|
}
|
|
|
|
if (topContextInProcess->Document()->IsTopLevelContentDocument()) {
|
|
// We are in the top of content document.
|
|
return std::make_pair(Nothing(), FramePosition::Unknown);
|
|
}
|
|
|
|
nsIDocShell* docShell = topContextInProcess->GetDocShell();
|
|
BrowserChild* browserChild = BrowserChild::GetFrom(docShell);
|
|
if (!browserChild) {
|
|
// We are not in out-of-process iframe.
|
|
return std::make_pair(Nothing(), FramePosition::Unknown);
|
|
}
|
|
|
|
if (!browserChild->GetEffectsInfo().IsVisible()) {
|
|
// There is no visible rect on this iframe at all.
|
|
return std::make_pair(Some(ScreenRect()), FramePosition::Unknown);
|
|
}
|
|
|
|
Maybe<ScreenRect> visibleRect =
|
|
browserChild->GetTopLevelViewportVisibleRectInBrowserCoords();
|
|
if (!visibleRect) {
|
|
// We are unsure if we haven't received the transformed rectangle of the
|
|
// iframe's visible area.
|
|
return std::make_pair(Nothing(), FramePosition::Unknown);
|
|
}
|
|
|
|
nsIFrame* rootFrame = topContextInProcess->PresShell()->GetRootFrame();
|
|
nsRect transformedToIFrame = nsLayoutUtils::TransformFrameRectToAncestor(
|
|
aFrame, aFrame->InkOverflowRectRelativeToSelf(), rootFrame);
|
|
|
|
LayoutDeviceRect rectInLayoutDevicePixel = LayoutDeviceRect::FromAppUnits(
|
|
transformedToIFrame, topContextInProcess->AppUnitsPerDevPixel());
|
|
|
|
ScreenRect transformedToRoot = ViewAs<ScreenPixel>(
|
|
browserChild->GetChildToParentConversionMatrix().TransformBounds(
|
|
rectInLayoutDevicePixel),
|
|
PixelCastJustification::ContentProcessIsLayerInUiProcess);
|
|
|
|
FramePosition position = FramePosition::Unknown;
|
|
// we need to check whether the transformed rect is outside the iframe
|
|
// visible rect or not because in some cases the rect size is (0x0), thus
|
|
// the intersection between the transformed rect and the iframe visible rect
|
|
// would also be (0x0), then we can't tell whether the given nsIFrame is
|
|
// inside the iframe visible rect or not by calling BaseRect::IsEmpty for the
|
|
// intersection.
|
|
if (transformedToRoot.x > visibleRect->XMost() ||
|
|
transformedToRoot.y > visibleRect->YMost() ||
|
|
visibleRect->x > transformedToRoot.XMost() ||
|
|
visibleRect->y > transformedToRoot.YMost()) {
|
|
position = FramePosition::OutOfView;
|
|
} else {
|
|
position = FramePosition::InView;
|
|
}
|
|
|
|
return std::make_pair(Some(visibleRect->Intersect(transformedToRoot)),
|
|
position);
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::FrameIsScrolledOutOfViewInCrossProcess(
|
|
const nsIFrame* aFrame) {
|
|
auto [visibleRect, framePosition] = GetFrameVisibleRectOnScreen(aFrame);
|
|
if (visibleRect.isNothing()) {
|
|
return false;
|
|
}
|
|
|
|
return visibleRect->IsEmpty() && framePosition != FramePosition::InView;
|
|
}
|
|
|
|
// static
|
|
bool nsLayoutUtils::FrameIsMostlyScrolledOutOfViewInCrossProcess(
|
|
const nsIFrame* aFrame, nscoord aMargin) {
|
|
auto [visibleRect, framePosition] = GetFrameVisibleRectOnScreen(aFrame);
|
|
(void)framePosition;
|
|
if (visibleRect.isNothing()) {
|
|
return false;
|
|
}
|
|
|
|
nsPresContext* topContextInProcess =
|
|
aFrame->PresContext()->GetInProcessRootContentDocumentPresContext();
|
|
MOZ_ASSERT(topContextInProcess);
|
|
|
|
nsIDocShell* docShell = topContextInProcess->GetDocShell();
|
|
BrowserChild* browserChild = BrowserChild::GetFrom(docShell);
|
|
MOZ_ASSERT(browserChild);
|
|
|
|
auto scale =
|
|
browserChild->GetChildToParentConversionMatrix().As2D().ScaleFactors();
|
|
const CSSCoord cssMargin = CSSPixel::FromAppUnits(aMargin);
|
|
ScreenSize margin =
|
|
CSSSize(cssMargin, cssMargin) * ViewAs<CSSToScreenScale2D>(scale);
|
|
|
|
return visibleRect->width < margin.width ||
|
|
visibleRect->height < margin.height;
|
|
}
|
|
|
|
// static
|
|
nsSize nsLayoutUtils::ExpandHeightForViewportUnits(nsPresContext* aPresContext,
|
|
const nsSize& aSize) {
|
|
nsSize sizeForViewportUnits = aPresContext->GetSizeForViewportUnits();
|
|
|
|
// |aSize| might be the size expanded to the minimum-scale size whereas the
|
|
// size for viewport units is not scaled so that we need to expand the |aSize|
|
|
// height by multiplying by the ratio of the viewport units height to the
|
|
// visible area height.
|
|
float vhExpansionRatio = (float)sizeForViewportUnits.height /
|
|
aPresContext->GetVisibleArea().height;
|
|
|
|
MOZ_ASSERT(aSize.height <= NSCoordSaturatingNonnegativeMultiply(
|
|
aSize.height, vhExpansionRatio));
|
|
return nsSize(aSize.width, NSCoordSaturatingNonnegativeMultiply(
|
|
aSize.height, vhExpansionRatio));
|
|
}
|
|
|
|
template <typename SizeType>
|
|
/* static */ SizeType ExpandHeightForDynamicToolbarImpl(
|
|
const nsPresContext* aPresContext, const SizeType& aSize) {
|
|
MOZ_ASSERT(aPresContext);
|
|
|
|
LayoutDeviceIntSize displaySize;
|
|
if (RefPtr<MobileViewportManager> MVM =
|
|
aPresContext->PresShell()->GetMobileViewportManager()) {
|
|
displaySize = MVM->DisplaySize();
|
|
} else if (!nsLayoutUtils::GetContentViewerSize(aPresContext, displaySize)) {
|
|
return aSize;
|
|
}
|
|
|
|
float toolbarHeightRatio =
|
|
mozilla::ScreenCoord(aPresContext->GetDynamicToolbarMaxHeight()) /
|
|
mozilla::ViewAs<mozilla::ScreenPixel>(
|
|
displaySize,
|
|
mozilla::PixelCastJustification::LayoutDeviceIsScreenForBounds)
|
|
.height;
|
|
|
|
SizeType expandedSize = aSize;
|
|
static_assert(std::is_same_v<nsSize, SizeType> ||
|
|
std::is_same_v<CSSSize, SizeType>);
|
|
if constexpr (std::is_same_v<nsSize, SizeType>) {
|
|
expandedSize.height =
|
|
NSCoordSaturatingAdd(aSize.height, aSize.height * toolbarHeightRatio);
|
|
} else if (std::is_same_v<CSSSize, SizeType>) {
|
|
expandedSize.height = aSize.height + aSize.height * toolbarHeightRatio;
|
|
}
|
|
return expandedSize;
|
|
}
|
|
|
|
CSSSize nsLayoutUtils::ExpandHeightForDynamicToolbar(
|
|
const nsPresContext* aPresContext, const CSSSize& aSize) {
|
|
return ExpandHeightForDynamicToolbarImpl(aPresContext, aSize);
|
|
}
|
|
nsSize nsLayoutUtils::ExpandHeightForDynamicToolbar(
|
|
const nsPresContext* aPresContext, const nsSize& aSize) {
|
|
return ExpandHeightForDynamicToolbarImpl(aPresContext, aSize);
|
|
}
|