mirror of
https://github.com/roytam1/palemoon27.git
synced 2026-05-26 14:18:48 +00:00
import changes from `dev' branch of rmottola/Arctic-Fox:
- bug 1212906 - don't handle windows messages while waiting for a sync a11y ipc message r=billm (c9297e58f4)
- Bug 1183431 - Tests for hypothetical box computation (to determine static position of abspos element) where orthogonal writing modes are involved. r=dholbert (87b22c5cf5)
- Bug 1221112: When checking for ::before/::after while sorting flex items by DOM order, dig past placeholder to out-of-flow frame. r=mats (b2e252fa86)
- Bug 1169420: add crashtests. (no review) (f7484702a2)
- Bug 1183431 - Ensure hypothetical box has a writing mode with the same block direction as the absolute containing block. r=dholbert (9106e022d1)
- Partial - No bug - Various crashtest manifest cleanups. (f2d0568f2d)
- Bug 1221874 - Crashtest for overzealous writing-mode check (currently asserts). r=smontagu (ef6685f606)
- Bug 1221874 - Ignore the sideways-orientation flag when logical-coordinate classes are checking writing-mode compatibility. r=smontagu (9617a761d6)
- Bug 1193488 - patch 2 - Update the writing-mode representation printed by debugging code such as DumpFrameTree to reflect the new property values. r=dholbert (b6b3fdda58)
- Bug 1208593 - Make the WritingMode::DebugString() method available even in non-DEBUG compilation (needed by --enable-dump-painting builds, for example). r=mchang (d6b46fde86)
- Bug 1122918 - Part 1 - Add parsing for logical inline-start/end keywords to the 'float' and 'clear' properties. r=heycam (20f9dc4d11)
- Bug 1122918 - Part 2 - Provide accessors that return logical 'float' and 'clear' values resolved to their physical equivalents. r=heycam (9380f050d6)
- Bug 1108055 - Part 1: Add ComputedTimingProperties dictionary. r=smaug (ac88430cfe)
- Bug 1108055 - Part 2: Refine ComputedTiming. r=birtles (3c25124b5f)
- Bug 1108055 - Part 3: Implement GetComputedTiming method. r=birtles (d9fe931cc5)
- Bug 1108055 - Part 4: Add ComputedTiming mochitests. r=birtles (1687824926)
- Bug 1195180 part 1 - Add Animation::NeedsTicks; r=heycam (9ac3bbda87)
- Bug 1195180 part 2 - Make DocumentTimeline inherit from nsARefreshObserver; r=heycam (292f9d154d)
- Bug 1195180 part 3 - Add flag to record if DocumentTimeline is observing the refresh driver; r=heycam (3d90d3f149)
- Bug 1195180 part 4 - Unregister from refresh observer when there are no animations needing ticks; r=heycam (ad76c3ddd5)
- Bug 1195180 part 5 - Synchronize refresh driver observing with presshell creation/teardown; r=heycam (94b7d9176f)
- Bug 1195180 part 6 - Lazily remove animations from timelines; r=heycam (bb3beaa264)
- Bug 1195180 part 7 - Store animations in an array; r=heycam (199756e7d6)
- Bug 1195180 part 8 - Tick animations from their timeline; r=heycam (12942bdc45)
- Bug 1195180 part 9 - Add test for seeking finished -> paused; r=heycam (0b42afcd26)
- Bug 1195180 part 10 - Remove refresh driver observing machinery from CommonAnimationManager; r=heycam (bf233d32ac)
- Bug 1208938 part 1 - Rename AnimationCollection::mNeedsRefreshes to mStyleChanging; r=heycam (679bdf0770)
- Bug 1208938 part 2 - Remove Animation::HasEndEventToQueue; r=heycam (c75bdb64b7)
- Bug 1208938 part 3 - Update pending finishing handling; r=heycam (c9f4c1aace)
- Bug 1196379 - Fix incorrect assertion checking for sorted arrays in nsDocumentRuleResultCacheKey::Matches. r=dbaron (a12db544ef)
- Bug 978833 patch 3 - Make css::Declaration implement nsIStyleRule. r=heycam (3b79410f06)
- Bug 978833 patch 4 - Add pointer back from css::Declaration to css::Rule. r=heycam (2f86331573)
- Bug 978833 patch 5 - Rename ImportantRule to ImportantStyleData. r=heycam (e8471fc026)
- Bug 978833 patch 6 - Move ImportantStyleData from StyleRule.{h,cpp} to Declaration.{h,cpp} r=heycam (612875a128)
- Bug 978833 patch 7 - Fuse allocation of ImportantStyleData with Declaration. r=heycam (a8e9e99a35)
- Bug 978833 patch 8 - Call SetImmutable for declarations of @page and keyframe rules. r=heycam (6b04b5a81e)
- Bug 978833 patch 9 - Move keyframe !important data assertion to where it will continue to happen. r=heycam (862c6df232)
- Bug 978833 patch 10 - Raise consistent exceptions so that the exception doesn't depend on rule destruction timing. r=bzbarsky (8bd58857e9)
- Bug 978833 patch 11 - Add missing #includes in preparation for nsRuleWalker.h #include change in following patch. r=heycam (25a6357983)
- Bug 1180118 - Part 6: Return eRestyle_SomeDescendants from HasAttributeDependentStyle where appropriate. r=bzbarsky (21d88cc938)
- Bug 1202512 - Part 2: Make SelectorMatchesTree take a flags argument. r=bzbarsky (b660a417f8)
- Bug 978833 patch 12 - Use the css::Declaration instead of the css::StyleRule as the matching rule. r=heycam (dd6a7914a6)
- Bug 978833 patch 13 - Remove important rule creation from css::StyleRule. r=heycam (4766c9a635)
- Bug 978833 patch 14 - Pass mozilla::css::Rule instead of nsIStyleRule to nsIDocument/nsIDocumentObserver style rule methods. r=heycam (a632b828b9)
- Bug 978833 patch 15 - Make css::Rule no longer inherit from nsIStyleRule. r=heycam (a975922671)
- Bug 978833 patch 16 - Always call Declaration::SetImmutable when we match a rule. r=heycam (0f0c89aede)
- Bug 978833 patch 17 - Remove Rule::mWasMatched. r=heycam (d0bb9bfef1)
- Bug 978833 patch 18 - Eliminate StyleRule::RuleMatched and call Declaration::SetImmutable directly for style rules (like for @page and keyframe rules). r=heycam (70d5e45a7c)
- Bug 978833 patch 19 - Fix ResolvedStyleCache to use Declaration rather than nsCSSKeyframeRule as keys. r=heycam (223cf85e8b)
- Bug 978833 patch 20 - Rev IIDs that I should have revised in Bug 978833 patch 14. (c6421cbca8)
- Bug 1214936 - Make the ArrayBuffer constructor throw if invoked without 'new'. (r=evilpie) (ec76f43c26)
- Bug 1198826 - Rename obj parameter to buffer to improve readability, r=terrence (3b1d280a76)
- pointer style (1f9d6a7d22)
- Bug 1218111 - Fix property enumeration order of unboxed objects with expando properties. r=bhackett (a7fdc9482d)
- Bug 980945 - Throw when invoking a typed array constructor without new. r=efaust (4f80026991)
- Bug 1192572 - Add id to each opcode section in SpiderMonkey Bytecode documentation. r=Waldo (bfd9d4c165)
- Bug 1219363 - Fix sort of indexed properties to not include properties already in the Vector. r=jorendorff (77edd4d779)
- Bug 1217593 - Fix compilation of LComputeThis now this can be undefined r=shu (d227ddf666)
- Bug 1212343 - Propagate OOM from SafepointWriter r=nbp (d5a79b7d61)
- remove core files (e008661015)
- Bug 1215937 - Remove use of expression closure from js/xpconnect/. r=bholley (e928296111)
- Bug 1196975 - part1: shimwaiver. r=billm (40bc720f37)
- Bug 1196975 - part2: shimwaiver applications. r=mossop (60cf9a9342)
- Bug 1196975 - part3: GetTabForContentWindowNoShim. r=billm (05d2af3c9a)
- Bug 1196975 - part4: waiveInterposition. r=billm (31ecb441b1)
- Bug 1196975 - part5: waiveInterposition for childloader. r=mossop (fe30dddc85)
- Bug 1196975 - part6: SDK Worker should not support CPOWs. r=mossop (7e59947069)
- Bug 1129662: sdk/page-worker should use a remote page. r=krizsa (ef63bafbe4)
- Bug 1216157 - Check for OOM when generating Ion RegExp stubs. r=jonco (690229c6d7)
- Bug 1221436 patch 5 - Stop generating new style rules in DeclarationChanged (and rename it to SetDeclaration), since we no longer need a new style rule for nsIStyleRule identity rules. r=heycam (98d860d06e)
- Bug 1220516 - Devirtualize CSSStyleSheet::GetOriginalURI. r=bzbarsky (6669f8ef70)
- Fix formatting of some macros; no bug. (fe337a3e91)
- Bug 1165538 part 1 - Use delegated constructor for nsStyleFont to simplify code and remove the need of nsStyleFont::Init. r=heycam (521e59852a)
- Bug 1165538 part 2 - Add -moz-min-font-size-ratio internal property. r=heycam (a16ef2d609)
- Bug 1165538 part 3 - Apply -moz-min-font-size-ratio to rt elements and add test. r=heycam (363684724b)
- Bug 1035091 part 1: change CSS parser and loader APIs to distinguish UA, user, and author sheets instead of just UA vs everyone else. r=heycam (01decf75df)
- Bug 1221436 patch 1 - Have a pointer back from the css::Declaration for style attributes to the nsHTMLCSSStyleSheet. r=heycam (308bf9701e)
- Bug 1221436 patch 2 - For style attributes, only store a css::Declaration instead of a css::StyleRule. r=heycam (f068adb5e9)
- Bug 1167588 - Mark Rule::mParentRule as MOZ_NON_OWNING_REF. r=dbaron (bdb2bfe4a7)
- Bug 1221436 patch 3 - Remove Rule::SetHTMLCSSStyleSheet and related code, now unused. r=heycam (d4fd6fca7c)
- Bug 1221436 patch 4 - Use the same pointer to store the owning rule and the nsHTMLCSSStyleSheet on css::Declaration, since we never need both. r=heycam (1a949ec7dc)
- Bug 1221436 patch 6 - Remove mechanism for replacing style rules. r=heycam (870539dcca)
- Bug 1221436 patch 7 - Remove ReplaceStyleRule/ReplaceRuleInGroup mechanism. r=heycam (a8a58186c1)
- Bug 1186768 patch 1 - Avoid setting different font-size conditions due to MathML font size adjustments. r=heycam (5b48d02031)
- Bug 1146101 - Test. r=dbaron a=abillings (b214ab1529)
- Bug 1161366 - Correctly set referrer when loading fonts with |new FontFace()|. r=dbaron (52a59ad6a4)
- Bug 1206105 - Use CheckedInt for an+b selector matching. r=bzbarsky (739875148c)
- Bug 1163446 - Drop reference to FontFace once a FontFaceBufferSource is loaded. r=jdaggett (9fd3a219c6)
- Bug 1164813 - Make nsAnimationManager update cached in-effect status even when there is no frame; r=dbaron (6f94c96764)
- Bug 1186768 patch 2 - Crashtest. r=heycam (a566cfef9b)
- Bug 1186768 patch 3 - Compute affectedByScriptMinSize sooner to avoid asserting or doing extra work. r=heycam (30dac96a78)
- Bug 1038663 (part 1) - Make nsStyleText::mWordSpacing an nsStyleCoord. r=heycam. (42a6a2398a)
- Bug 1038663 (part 2, attempt 2) - Move GetFirstFontMetrics() up. r=heycam. (5992325377)
- Bug 1038663 (part 3, attempt 2) - Factor out space width computation. r=heycam. (92281609f0)
- Bug 1038663 (part 4, attempt 2) - Inline StyleToCoord(). r=heycam. (f40476c105)
- Bug 1038663 (part 5, attempt 2) - Change GetSpacingFlags(). r=heycam (e1fe5ecdf0)
- Bug 1038663 (part 6, attempt 2) - Allow percentage values for 'word-spacing'. r=heycam. (433fee69f6)
- Bug 1038663 (part 7, attempt 3) - Add test for percentage values for 'word-spacing'. r=heycam. (72df555579)
- Bug 1216747 - Record dependency on writing mode in nsRuleNode::ComputeStylePosition. r=heycam (8604ceff20)
- Bug 1216747 followup - Use the correct value when calling SetWritingModeDependency. (b39a82cbf7)
- Bug 1216747 - Cleanup after test fix. r=heycam (e99ec5989a)
- Bug 1170781 - Patch 1: Implement CSS 'contain: paint'. r=dholbert (3b2f65288f)
- Bug 1170781 - Patch 2: Test CSS 'contain: paint'. r=dholbert (ee83c7c0fd)
This commit is contained in:
@@ -992,9 +992,9 @@ nsHTMLReflowState::ApplyRelativePositioning(nsIFrame* aFrame,
|
||||
}
|
||||
|
||||
nsIFrame*
|
||||
nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame,
|
||||
nscoord& aCBIStartEdge,
|
||||
nscoord& aCBISize)
|
||||
nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame,
|
||||
nscoord& aCBIStartEdge,
|
||||
LogicalSize& aCBSize)
|
||||
{
|
||||
aFrame = aFrame->GetContainingBlock();
|
||||
NS_ASSERTION(aFrame != frame, "How did that happen?");
|
||||
@@ -1018,7 +1018,7 @@ nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame,
|
||||
WritingMode stateWM = state->GetWritingMode();
|
||||
aCBIStartEdge =
|
||||
state->ComputedLogicalBorderPadding().ConvertTo(wm, stateWM).IStart(wm);
|
||||
aCBISize = state->ComputedSize(wm).ISize(wm);
|
||||
aCBSize = state->ComputedSize(wm);
|
||||
} else {
|
||||
/* Didn't find a reflow state for aFrame. Just compute the information we
|
||||
want, on the assumption that aFrame already knows its size. This really
|
||||
@@ -1027,7 +1027,7 @@ nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame,
|
||||
"aFrame shouldn't be in reflow; we'll lie if it is");
|
||||
LogicalMargin borderPadding = aFrame->GetLogicalUsedBorderAndPadding(wm);
|
||||
aCBIStartEdge = borderPadding.IStart(wm);
|
||||
aCBISize = aFrame->ISize(wm) - borderPadding.IStartEnd(wm);
|
||||
aCBSize = aFrame->GetLogicalSize(wm) - borderPadding.Size(wm);
|
||||
}
|
||||
|
||||
return aFrame;
|
||||
@@ -1077,71 +1077,81 @@ GetIntrinsicSizeFor(nsIFrame* aFrame, nsSize& aIntrinsicSize, nsIAtom* aFrameTyp
|
||||
}
|
||||
|
||||
/**
|
||||
* aInsideBoxSizing returns the part of the horizontal padding, border,
|
||||
* and margin that goes inside the edge given by box-sizing;
|
||||
* aInsideBoxSizing returns the part of the padding, border, and margin
|
||||
* in the aAxis dimension that goes inside the edge given by box-sizing;
|
||||
* aOutsideBoxSizing returns the rest.
|
||||
*/
|
||||
void
|
||||
nsHTMLReflowState::CalculateInlineBorderPaddingMargin(
|
||||
nscoord aContainingBlockISize,
|
||||
nsHTMLReflowState::CalculateBorderPaddingMargin(
|
||||
LogicalAxis aAxis,
|
||||
nscoord aContainingBlockSize,
|
||||
nscoord* aInsideBoxSizing,
|
||||
nscoord* aOutsideBoxSizing)
|
||||
{
|
||||
WritingMode wm = GetWritingMode();
|
||||
mozilla::css::Side inlineStart = wm.PhysicalSide(eLogicalSideIStart);
|
||||
mozilla::css::Side inlineEnd = wm.PhysicalSide(eLogicalSideIEnd);
|
||||
mozilla::css::Side startSide =
|
||||
wm.PhysicalSide(MakeLogicalSide(aAxis, eLogicalEdgeStart));
|
||||
mozilla::css::Side endSide =
|
||||
wm.PhysicalSide(MakeLogicalSide(aAxis, eLogicalEdgeEnd));
|
||||
|
||||
const LogicalMargin& border =
|
||||
LogicalMargin(wm, mStyleBorder->GetComputedBorder());
|
||||
LogicalMargin padding(wm), margin(wm);
|
||||
nsMargin styleBorder = mStyleBorder->GetComputedBorder();
|
||||
nscoord borderStartEnd =
|
||||
styleBorder.Side(startSide) + styleBorder.Side(endSide);
|
||||
|
||||
nscoord paddingStartEnd, marginStartEnd;
|
||||
|
||||
// See if the style system can provide us the padding directly
|
||||
nsMargin stylePadding;
|
||||
if (mStylePadding->GetPadding(stylePadding)) {
|
||||
padding = LogicalMargin(wm, stylePadding);
|
||||
paddingStartEnd =
|
||||
stylePadding.Side(startSide) + stylePadding.Side(endSide);
|
||||
} else {
|
||||
// We have to compute the inline start and end values
|
||||
padding.IStart(wm) = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockISize,
|
||||
mStylePadding->mPadding.Get(inlineStart));
|
||||
padding.IEnd(wm) = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockISize,
|
||||
mStylePadding->mPadding.Get(inlineEnd));
|
||||
// We have to compute the start and end values
|
||||
nscoord start, end;
|
||||
start = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockSize,
|
||||
mStylePadding->mPadding.Get(startSide));
|
||||
end = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockSize,
|
||||
mStylePadding->mPadding.Get(endSide));
|
||||
paddingStartEnd = start + end;
|
||||
}
|
||||
|
||||
// See if the style system can provide us the margin directly
|
||||
nsMargin styleMargin;
|
||||
if (mStyleMargin->GetMargin(styleMargin)) {
|
||||
margin = LogicalMargin(wm, styleMargin);
|
||||
marginStartEnd =
|
||||
styleMargin.Side(startSide) + styleMargin.Side(endSide);
|
||||
} else {
|
||||
// We have to compute the left and right values
|
||||
if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(inlineStart)) {
|
||||
nscoord start, end;
|
||||
// We have to compute the start and end values
|
||||
if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(startSide)) {
|
||||
// XXX FIXME (or does CalculateBlockSideMargins do this?)
|
||||
margin.IStart(wm) = 0; // just ignore
|
||||
start = 0; // just ignore
|
||||
} else {
|
||||
margin.IStart(wm) = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockISize,
|
||||
mStyleMargin->mMargin.Get(inlineStart));
|
||||
start = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockSize,
|
||||
mStyleMargin->mMargin.Get(startSide));
|
||||
}
|
||||
if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(inlineEnd)) {
|
||||
if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(endSide)) {
|
||||
// XXX FIXME (or does CalculateBlockSideMargins do this?)
|
||||
margin.IEnd(wm) = 0; // just ignore
|
||||
end = 0; // just ignore
|
||||
} else {
|
||||
margin.IEnd(wm) = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockISize,
|
||||
mStyleMargin->mMargin.Get(inlineEnd));
|
||||
end = nsLayoutUtils::
|
||||
ComputeCBDependentValue(aContainingBlockSize,
|
||||
mStyleMargin->mMargin.Get(endSide));
|
||||
}
|
||||
marginStartEnd = start + end;
|
||||
}
|
||||
|
||||
nscoord outside =
|
||||
padding.IStartEnd(wm) + border.IStartEnd(wm) + margin.IStartEnd(wm);
|
||||
nscoord outside = paddingStartEnd + borderStartEnd + marginStartEnd;
|
||||
nscoord inside = 0;
|
||||
switch (mStylePosition->mBoxSizing) {
|
||||
case NS_STYLE_BOX_SIZING_BORDER:
|
||||
inside += border.IStartEnd(wm);
|
||||
inside += borderStartEnd;
|
||||
// fall through
|
||||
case NS_STYLE_BOX_SIZING_PADDING:
|
||||
inside += padding.IStartEnd(wm);
|
||||
inside += paddingStartEnd;
|
||||
}
|
||||
outside -= inside;
|
||||
*aInsideBoxSizing = inside;
|
||||
@@ -1175,8 +1185,12 @@ static bool AreAllEarlierInFlowFramesEmpty(nsIFrame* aFrame,
|
||||
|
||||
// Calculate the hypothetical box that the element would have if it were in
|
||||
// the flow. The values returned are relative to the padding edge of the
|
||||
// absolute containing block, in the actual containing block's writing mode.
|
||||
// cbrs->frame is the actual containing block
|
||||
// absolute containing block. The writing-mode of the hypothetical box will
|
||||
// have the same block direction as the absolute containing block, but may
|
||||
// differ in inline-bidi direction.
|
||||
// In the code below, |cbrs->frame| is the absolute containing block, while
|
||||
// |containingBlock| is the nearest block container of the placeholder frame,
|
||||
// which may be different from the absolute containing block.
|
||||
void
|
||||
nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
nsIFrame* aPlaceholderFrame,
|
||||
@@ -1189,16 +1203,20 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
|
||||
// Find the nearest containing block frame to the placeholder frame,
|
||||
// and its inline-start edge and width.
|
||||
nscoord blockIStartContentEdge, blockContentISize;
|
||||
nscoord blockIStartContentEdge;
|
||||
// Dummy writing mode for blockContentSize, will be changed as needed by
|
||||
// GetHypotheticalBoxContainer.
|
||||
WritingMode cbwm = cbrs->GetWritingMode();
|
||||
LogicalSize blockContentSize(cbwm);
|
||||
nsIFrame* containingBlock =
|
||||
GetHypotheticalBoxContainer(aPlaceholderFrame, blockIStartContentEdge,
|
||||
blockContentISize);
|
||||
blockContentSize);
|
||||
// Now blockContentSize is in containingBlock's writing mode.
|
||||
|
||||
// If it's a replaced element and it has a 'auto' value for
|
||||
//'inline size', see if we can get the intrinsic size. This will allow
|
||||
// us to exactly determine both the inline edges
|
||||
WritingMode wm = containingBlock->GetWritingMode();
|
||||
aHypotheticalBox.mWritingMode = wm;
|
||||
|
||||
nsStyleCoord styleISize = mStylePosition->ISize(wm);
|
||||
bool isAutoISize = styleISize.GetUnit() == eStyleUnit_Auto;
|
||||
@@ -1227,8 +1245,9 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
// been in the flow. Note that we ignore any 'auto' and 'inherit'
|
||||
// values
|
||||
nscoord insideBoxSizing, outsideBoxSizing;
|
||||
CalculateInlineBorderPaddingMargin(blockContentISize,
|
||||
&insideBoxSizing, &outsideBoxSizing);
|
||||
CalculateBorderPaddingMargin(eLogicalAxisInline,
|
||||
blockContentSize.ISize(wm),
|
||||
&insideBoxSizing, &outsideBoxSizing);
|
||||
|
||||
if (NS_FRAME_IS_REPLACED(mFrameType) && isAutoISize) {
|
||||
// It's a replaced element with an 'auto' inline size so the box
|
||||
@@ -1241,14 +1260,14 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
|
||||
} else if (isAutoISize) {
|
||||
// The box inline size is the containing block inline size
|
||||
boxISize = blockContentISize;
|
||||
boxISize = blockContentSize.ISize(wm);
|
||||
knowBoxISize = true;
|
||||
|
||||
} else {
|
||||
// We need to compute it. It's important we do this, because if it's
|
||||
// percentage based this computed value may be different from the computed
|
||||
// value calculated using the absolute containing block width
|
||||
boxISize = ComputeISizeValue(blockContentISize,
|
||||
boxISize = ComputeISizeValue(blockContentSize.ISize(wm),
|
||||
insideBoxSizing, outsideBoxSizing,
|
||||
styleISize) +
|
||||
insideBoxSizing + outsideBoxSizing;
|
||||
@@ -1260,7 +1279,6 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
// space of its containing block
|
||||
// XXXbz the placeholder is not fully reflowed yet if our containing block is
|
||||
// relatively positioned...
|
||||
WritingMode cbwm = cbrs->GetWritingMode();
|
||||
nsSize containerSize = containingBlock->GetStateBits() & NS_FRAME_IN_REFLOW
|
||||
? cbrs->ComputedSizeAsContainerIfConstrained()
|
||||
: containingBlock->GetSize();
|
||||
@@ -1365,7 +1383,8 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
// We can't compute the inline-end edge because we don't know the desired
|
||||
// inline-size. So instead use the end content edge of the block parent,
|
||||
// but remember it's not exact
|
||||
aHypotheticalBox.mIEnd = blockIStartContentEdge + blockContentISize;
|
||||
aHypotheticalBox.mIEnd =
|
||||
blockIStartContentEdge + blockContentSize.ISize(wm);
|
||||
#ifdef DEBUG
|
||||
aHypotheticalBox.mIEndIsExact = false;
|
||||
#endif
|
||||
@@ -1408,9 +1427,7 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
// scroll, and thus avoid the resulting incremental reflow bugs.
|
||||
cbOffset = containingBlock->GetOffsetTo(cbrs->frame);
|
||||
}
|
||||
nsSize cbrsSize =
|
||||
cbrs->ComputedPhysicalSize() +
|
||||
cbrs->ComputedLogicalBorderPadding().Size(cbwm).GetPhysicalSize(cbwm);
|
||||
nsSize cbrsSize = cbrs->ComputedSizeAsContainerIfConstrained();
|
||||
LogicalPoint logCBOffs(wm, cbOffset, cbrsSize - containerSize);
|
||||
aHypotheticalBox.mIStart += logCBOffs.I(wm);
|
||||
aHypotheticalBox.mIEnd += logCBOffs.I(wm);
|
||||
@@ -1425,6 +1442,74 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext* aPresContext,
|
||||
aHypotheticalBox.mIStart -= border.IStart(wm);
|
||||
aHypotheticalBox.mIEnd -= border.IStart(wm);
|
||||
aHypotheticalBox.mBStart -= border.BStart(wm);
|
||||
|
||||
// At this point, we have computed aHypotheticalBox using the writing mode
|
||||
// of the placeholder's containing block.
|
||||
|
||||
if (cbwm.GetBlockDir() != wm.GetBlockDir()) {
|
||||
// If the block direction we used in calculating aHypotheticalBox does not
|
||||
// match the absolute containing block's, we need to convert here so that
|
||||
// aHypotheticalBox is usable in relation to the absolute containing block.
|
||||
// This requires computing or measuring the abspos frame's block-size,
|
||||
// which is not otherwise required/used here (as aHypotheticalBox records
|
||||
// only the block-start coordinate).
|
||||
|
||||
// This is similar to the inline-size calculation for a replaced
|
||||
// inline-level element or a block-level element (above), except that
|
||||
// 'auto' sizing is handled differently in the block direction for non-
|
||||
// replaced elements and replaced elements lacking an intrinsic size.
|
||||
|
||||
// Determine the total amount of block direction
|
||||
// border/padding/margin that the element would have had if it had
|
||||
// been in the flow. Note that we ignore any 'auto' and 'inherit'
|
||||
// values.
|
||||
nscoord insideBoxSizing, outsideBoxSizing;
|
||||
CalculateBorderPaddingMargin(eLogicalAxisBlock,
|
||||
blockContentSize.BSize(wm),
|
||||
&insideBoxSizing, &outsideBoxSizing);
|
||||
|
||||
nscoord boxBSize;
|
||||
nsStyleCoord styleBSize = mStylePosition->BSize(wm);
|
||||
bool isAutoBSize = styleBSize.GetUnit() == eStyleUnit_Auto;
|
||||
if (isAutoBSize) {
|
||||
if (NS_FRAME_IS_REPLACED(mFrameType) && knowIntrinsicSize) {
|
||||
// It's a replaced element with an 'auto' block size so the box
|
||||
// block size is its intrinsic size plus any border/padding/margin
|
||||
boxBSize = LogicalSize(wm, intrinsicSize).BSize(wm) +
|
||||
outsideBoxSizing + insideBoxSizing;
|
||||
} else {
|
||||
// XXX Bug 1191801
|
||||
// Figure out how to get the correct boxBSize here (need to reflow the
|
||||
// positioned frame?)
|
||||
boxBSize = 0;
|
||||
}
|
||||
} else {
|
||||
// We need to compute it. It's important we do this, because if it's
|
||||
// percentage-based this computed value may be different from the
|
||||
// computed value calculated using the absolute containing block height.
|
||||
boxBSize = ComputeBSizeValue(blockContentSize.BSize(wm),
|
||||
insideBoxSizing, styleBSize) +
|
||||
insideBoxSizing + outsideBoxSizing;
|
||||
}
|
||||
|
||||
LogicalSize boxSize(wm, knowBoxISize ? boxISize : 0, boxBSize);
|
||||
|
||||
LogicalPoint origin(wm, aHypotheticalBox.mIStart,
|
||||
aHypotheticalBox.mBStart);
|
||||
origin = origin.ConvertTo(cbwm, wm, cbrsSize -
|
||||
boxSize.GetPhysicalSize(wm));
|
||||
|
||||
aHypotheticalBox.mIStart = origin.I(cbwm);
|
||||
aHypotheticalBox.mIEnd = aHypotheticalBox.mIStart +
|
||||
boxSize.ConvertTo(cbwm, wm).ISize(cbwm);
|
||||
#ifdef DEBUG
|
||||
aHypotheticalBox.mIEndIsExact = false; // it may be fake
|
||||
#endif
|
||||
aHypotheticalBox.mBStart = origin.B(cbwm);
|
||||
aHypotheticalBox.mWritingMode = cbwm;
|
||||
} else {
|
||||
aHypotheticalBox.mWritingMode = wm;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
@@ -1520,8 +1605,6 @@ nsHTMLReflowState::InitAbsoluteConstraints(nsPresContext* aPresContext,
|
||||
|
||||
if (bStartIsAuto && bEndIsAuto) {
|
||||
// Treat 'top' like 'static-position'
|
||||
NS_ASSERTION(hypotheticalBox.mWritingMode.GetBlockDir() == cbwm.GetBlockDir(),
|
||||
"block direction mismatch");
|
||||
offsets.BStart(cbwm) = hypotheticalBox.mBStart;
|
||||
bStartIsAuto = false;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user