Source code

Revision control

Other Tools

/* -*- 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/. */
/* Per-block-formatting-context manager of font size inflation for pan and zoom
* UI. */
#include "nsFontInflationData.h"
#include "FrameProperties.h"
#include "nsTextControlFrame.h"
#include "nsListControlFrame.h"
#include "nsComboboxControlFrame.h"
#include "mozilla/dom/Text.h" // for inline nsINode::AsText() definition
#include "mozilla/PresShell.h"
#include "mozilla/ReflowInput.h"
#include "nsTextFrameUtils.h"
using namespace mozilla;
using namespace mozilla::layout;
NS_DECLARE_FRAME_PROPERTY_DELETABLE(FontInflationDataProperty,
nsFontInflationData)
/* static */ nsFontInflationData* nsFontInflationData::FindFontInflationDataFor(
const nsIFrame* aFrame) {
// We have one set of font inflation data per block formatting context.
const nsIFrame* bfc = FlowRootFor(aFrame);
NS_ASSERTION(bfc->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT),
"should have found a flow root");
MOZ_ASSERT(aFrame->GetWritingMode().IsVertical() ==
bfc->GetWritingMode().IsVertical(),
"current writing mode should match that of our flow root");
return bfc->GetProperty(FontInflationDataProperty());
}
/* static */
bool nsFontInflationData::UpdateFontInflationDataISizeFor(
const ReflowInput& aReflowInput) {
nsIFrame* bfc = aReflowInput.mFrame;
NS_ASSERTION(bfc->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT),
"should have been given a flow root");
nsFontInflationData* data = bfc->GetProperty(FontInflationDataProperty());
bool oldInflationEnabled;
nscoord oldUsableISize;
if (data) {
oldUsableISize = data->mUsableISize;
oldInflationEnabled = data->mInflationEnabled;
} else {
data = new nsFontInflationData(bfc);
bfc->SetProperty(FontInflationDataProperty(), data);
oldUsableISize = -1;
oldInflationEnabled = true; /* not relevant */
}
data->UpdateISize(aReflowInput);
if (oldInflationEnabled != data->mInflationEnabled) return true;
return oldInflationEnabled && oldUsableISize != data->mUsableISize;
}
/* static */
void nsFontInflationData::MarkFontInflationDataTextDirty(nsIFrame* aBFCFrame) {
NS_ASSERTION(aBFCFrame->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT),
"should have been given a flow root");
nsFontInflationData* data =
aBFCFrame->GetProperty(FontInflationDataProperty());
if (data) {
data->MarkTextDirty();
}
}
nsFontInflationData::nsFontInflationData(nsIFrame* aBFCFrame)
: mBFCFrame(aBFCFrame),
mUsableISize(0),
mTextAmount(0),
mTextThreshold(0),
mInflationEnabled(false),
mTextDirty(true) {}
/**
* Find the closest common ancestor between aFrame1 and aFrame2, except
* treating the parent of a frame as the first-in-flow of its parent (so
* the result doesn't change when breaking changes).
*
* aKnownCommonAncestor is a known common ancestor of both.
*/
static nsIFrame* NearestCommonAncestorFirstInFlow(
nsIFrame* aFrame1, nsIFrame* aFrame2, nsIFrame* aKnownCommonAncestor) {
aFrame1 = aFrame1->FirstInFlow();
aFrame2 = aFrame2->FirstInFlow();
aKnownCommonAncestor = aKnownCommonAncestor->FirstInFlow();
AutoTArray<nsIFrame*, 32> ancestors1, ancestors2;
for (nsIFrame* f = aFrame1; f != aKnownCommonAncestor;
(f = f->GetParent()) && (f = f->FirstInFlow())) {
ancestors1.AppendElement(f);
}
for (nsIFrame* f = aFrame2; f != aKnownCommonAncestor;
(f = f->GetParent()) && (f = f->FirstInFlow())) {
ancestors2.AppendElement(f);
}
nsIFrame* result = aKnownCommonAncestor;
uint32_t i1 = ancestors1.Length(), i2 = ancestors2.Length();
while (i1-- != 0 && i2-- != 0) {
if (ancestors1[i1] != ancestors2[i2]) {
break;
}
result = ancestors1[i1];
}
return result;
}
static nscoord ComputeDescendantISize(const ReflowInput& aAncestorReflowInput,
nsIFrame* aDescendantFrame) {
nsIFrame* ancestorFrame = aAncestorReflowInput.mFrame->FirstInFlow();
if (aDescendantFrame == ancestorFrame) {
return aAncestorReflowInput.ComputedISize();
}
AutoTArray<nsIFrame*, 16> frames;
for (nsIFrame* f = aDescendantFrame; f != ancestorFrame;
f = f->GetParent()->FirstInFlow()) {
frames.AppendElement(f);
}
// This ignores the inline-size contributions made by scrollbars, though in
// reality we don't have any scrollbars on the sorts of devices on
// which we use font inflation, so it's not a problem. But it may
// occasionally cause problems when writing tests on desktop.
uint32_t len = frames.Length();
ReflowInput* reflowInputs =
static_cast<ReflowInput*>(moz_xmalloc(sizeof(ReflowInput) * len));
nsPresContext* presContext = aDescendantFrame->PresContext();
for (uint32_t i = 0; i < len; ++i) {
const ReflowInput& parentReflowInput =
(i == 0) ? aAncestorReflowInput : reflowInputs[i - 1];
nsIFrame* frame = frames[len - i - 1];
WritingMode wm = frame->GetWritingMode();
LogicalSize availSize = parentReflowInput.ComputedSize(wm);
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
MOZ_ASSERT(frame->GetParent()->FirstInFlow() ==
parentReflowInput.mFrame->FirstInFlow(),
"bad logic in this function");
new (reflowInputs + i)
ReflowInput(presContext, parentReflowInput, frame, availSize);
}
MOZ_ASSERT(reflowInputs[len - 1].mFrame == aDescendantFrame,
"bad logic in this function");
nscoord result = reflowInputs[len - 1].ComputedISize();
for (uint32_t i = len; i-- != 0;) {
reflowInputs[i].~ReflowInput();
}
free(reflowInputs);
return result;
}
void nsFontInflationData::UpdateISize(const ReflowInput& aReflowInput) {
nsIFrame* bfc = aReflowInput.mFrame;
NS_ASSERTION(bfc->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT),
"must be block formatting context");
nsIFrame* firstInflatableDescendant =
FindEdgeInflatableFrameIn(bfc, eFromStart);
if (!firstInflatableDescendant) {
mTextAmount = 0;
mTextThreshold = 0; // doesn't matter
mTextDirty = false;
mInflationEnabled = false;
return;
}
nsIFrame* lastInflatableDescendant = FindEdgeInflatableFrameIn(bfc, eFromEnd);
MOZ_ASSERT(!firstInflatableDescendant == !lastInflatableDescendant,
"null-ness should match; NearestCommonAncestorFirstInFlow"
" will crash when passed null");
// Particularly when we're computing for the root BFC, the inline-size of
// nca might differ significantly for the inline-size of bfc.
nsIFrame* nca = NearestCommonAncestorFirstInFlow(
firstInflatableDescendant, lastInflatableDescendant, bfc);
while (!nca->IsContainerForFontSizeInflation()) {
nca = nca->GetParent()->FirstInFlow();
}
nscoord newNCAISize = ComputeDescendantISize(aReflowInput, nca);
// See comment above "font.size.inflation.lineThreshold" in
// modules/libpref/src/init/StaticPrefList.yaml .
PresShell* presShell = bfc->PresShell();
uint32_t lineThreshold = presShell->FontSizeInflationLineThreshold();
nscoord newTextThreshold = (newNCAISize * lineThreshold) / 100;
if (mTextThreshold <= mTextAmount && mTextAmount < newTextThreshold) {
// Because we truncate our scan when we hit sufficient text, we now
// need to rescan.
mTextDirty = true;
}
// Font inflation increases the font size for a given flow root so that the
// text is legible when we've zoomed such that the respective nearest common
// ancestor's (NCA) full inline-size (ISize) fills the screen. We assume how-
// ever that we don't want to zoom out further than the root iframe's ISize
// (i.e. the viewport for a top-level document, or the containing iframe
// otherwise), since in some cases zooming out further might not even be
// possible or make sense.
// Hence the ISize assumed to be usable for displaying text is limited to the
// visible area.
nsPresContext* presContext = bfc->PresContext();
MOZ_ASSERT(
bfc->GetWritingMode().IsVertical() == nca->GetWritingMode().IsVertical(),
"writing mode of NCA should match that of its flow root");
nscoord iFrameISize = bfc->GetWritingMode().IsVertical()
? presContext->GetVisibleArea().height
: presContext->GetVisibleArea().width;
mUsableISize = std::min(iFrameISize, newNCAISize);
mTextThreshold = newTextThreshold;
mInflationEnabled = mTextAmount >= mTextThreshold;
}
/* static */ nsIFrame* nsFontInflationData::FindEdgeInflatableFrameIn(
nsIFrame* aFrame, SearchDirection aDirection) {
// NOTE: This function has a similar structure to ScanTextIn!
// FIXME: Should probably only scan the text that's actually going to
// be inflated!
nsIFormControlFrame* fcf = do_QueryFrame(aFrame);
if (fcf) {
return aFrame;
}
// FIXME: aDirection!
AutoTArray<FrameChildList, 4> lists;
aFrame->GetChildLists(&lists);
for (uint32_t i = 0, len = lists.Length(); i < len; ++i) {
const nsFrameList& list =
lists[(aDirection == eFromStart) ? i : len - i - 1].mList;
for (nsIFrame* kid = (aDirection == eFromStart) ? list.FirstChild()
: list.LastChild();
kid; kid = (aDirection == eFromStart) ? kid->GetNextSibling()
: kid->GetPrevSibling()) {
if (kid->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT)) {
// Goes in a different set of inflation data.
continue;
}
if (kid->IsTextFrame()) {
nsIContent* content = kid->GetContent();
if (content && kid == content->GetPrimaryFrame()) {
uint32_t len = nsTextFrameUtils::
ComputeApproximateLengthWithWhitespaceCompression(
content->AsText(), kid->StyleText());
if (len != 0) {
return kid;
}
}
} else {
nsIFrame* kidResult = FindEdgeInflatableFrameIn(kid, aDirection);
if (kidResult) {
return kidResult;
}
}
}
}
return nullptr;
}
void nsFontInflationData::ScanText() {
mTextDirty = false;
mTextAmount = 0;
ScanTextIn(mBFCFrame);
mInflationEnabled = mTextAmount >= mTextThreshold;
}
static uint32_t DoCharCountOfLargestOption(nsIFrame* aContainer) {
uint32_t result = 0;
for (nsIFrame* option : aContainer->PrincipalChildList()) {
uint32_t optionResult;
if (option->GetContent()->IsHTMLElement(nsGkAtoms::optgroup)) {
optionResult = DoCharCountOfLargestOption(option);
} else {
// REVIEW: Check the frame structure for this!
optionResult = 0;
for (nsIFrame* optionChild : option->PrincipalChildList()) {
if (optionChild->IsTextFrame()) {
optionResult += nsTextFrameUtils::
ComputeApproximateLengthWithWhitespaceCompression(
optionChild->GetContent()->AsText(),
optionChild->StyleText());
}
}
}
if (optionResult > result) {
result = optionResult;
}
}
return result;
}
static uint32_t CharCountOfLargestOption(nsIFrame* aListControlFrame) {
return DoCharCountOfLargestOption(
static_cast<nsListControlFrame*>(aListControlFrame)
->GetOptionsContainer());
}
void nsFontInflationData::ScanTextIn(nsIFrame* aFrame) {
// NOTE: This function has a similar structure to FindEdgeInflatableFrameIn!
// FIXME: Should probably only scan the text that's actually going to
// be inflated!
for (const auto& childList : aFrame->ChildLists()) {
for (nsIFrame* kid : childList.mList) {
if (kid->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT)) {
// Goes in a different set of inflation data.
continue;
}
LayoutFrameType fType = kid->Type();
if (fType == LayoutFrameType::Text) {
nsIContent* content = kid->GetContent();
if (content && kid == content->GetPrimaryFrame()) {
uint32_t len = nsTextFrameUtils::
ComputeApproximateLengthWithWhitespaceCompression(
content->AsText(), kid->StyleText());
if (len != 0) {
nscoord fontSize = kid->StyleFont()->mFont.size.ToAppUnits();
if (fontSize > 0) {
mTextAmount += fontSize * len;
}
}
}
} else if (fType == LayoutFrameType::TextInput) {
// We don't want changes to the amount of text in a text input
// to change what we count towards inflation.
nscoord fontSize = kid->StyleFont()->mFont.size.ToAppUnits();
int32_t charCount = static_cast<nsTextControlFrame*>(kid)->GetCols();
mTextAmount += charCount * fontSize;
} else if (fType == LayoutFrameType::ComboboxControl) {
// See textInputFrame above (with s/amount of text/selected option/).
// Don't just recurse down to the list control inside, since we
// need to exclude the display frame.
nscoord fontSize = kid->StyleFont()->mFont.size.ToAppUnits();
int32_t charCount = CharCountOfLargestOption(
static_cast<nsComboboxControlFrame*>(kid)->GetDropDown());
mTextAmount += charCount * fontSize;
} else if (fType == LayoutFrameType::ListControl) {
// See textInputFrame above (with s/amount of text/selected option/).
nscoord fontSize = kid->StyleFont()->mFont.size.ToAppUnits();
int32_t charCount = CharCountOfLargestOption(kid);
mTextAmount += charCount * fontSize;
} else {
// recursive step
ScanTextIn(kid);
}
if (mTextAmount >= mTextThreshold) {
return;
}
}
}
}