OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2012 Apple Inc. All rights reserved. | 2 * Copyright (C) 2012 Apple Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * 1. Redistributions of source code must retain the above copyright | 7 * 1. Redistributions of source code must retain the above copyright |
8 * notice, this list of conditions and the following disclaimer. | 8 * notice, this list of conditions and the following disclaimer. |
9 * 2. Redistributions in binary form must reproduce the above copyright | 9 * 2. Redistributions in binary form must reproduce the above copyright |
10 * notice, this list of conditions and the following disclaimer in the | 10 * notice, this list of conditions and the following disclaimer in the |
11 * documentation and/or other materials provided with the distribution. | 11 * documentation and/or other materials provided with the distribution. |
12 * | 12 * |
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY | 13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR | 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
20 * PROFITS; OR BUSINESS IN..0TERRUPTION) HOWEVER CAUSED AND ON ANY THEORY | 20 * PROFITS; OR BUSINESS IN..0TERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
24 */ | 24 */ |
25 | 25 |
26 #include "config.h" | 26 #include "config.h" |
27 #include "core/rendering/RenderMultiColumnFlowThread.h" | 27 #include "core/rendering/RenderMultiColumnFlowThread.h" |
28 | 28 |
29 #include "core/rendering/RenderMultiColumnSet.h" | 29 #include "core/rendering/RenderMultiColumnSet.h" |
30 #include "core/rendering/RenderMultiColumnSpannerSet.h" | 30 #include "core/rendering/RenderMultiColumnSpannerPlaceholder.h" |
31 | 31 |
32 namespace blink { | 32 namespace blink { |
33 | 33 |
34 RenderMultiColumnFlowThread::RenderMultiColumnFlowThread() | 34 RenderMultiColumnFlowThread::RenderMultiColumnFlowThread() |
35 : m_columnCount(1) | 35 : m_columnCount(1) |
36 , m_columnHeightAvailable(0) | 36 , m_columnHeightAvailable(0) |
37 , m_inBalancingPass(false) | 37 , m_inBalancingPass(false) |
38 , m_needsColumnHeightsRecalculation(false) | 38 , m_needsColumnHeightsRecalculation(false) |
39 , m_progressionIsInline(true) | 39 , m_progressionIsInline(true) |
| 40 , m_isBeingEvacuated(false) |
40 { | 41 { |
41 setFlowThreadState(InsideInFlowThread); | 42 setFlowThreadState(InsideInFlowThread); |
42 } | 43 } |
43 | 44 |
44 RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread() | 45 RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread() |
45 { | 46 { |
46 } | 47 } |
47 | 48 |
48 RenderMultiColumnFlowThread* RenderMultiColumnFlowThread::createAnonymous(Docume
nt& document, RenderStyle* parentStyle) | 49 RenderMultiColumnFlowThread* RenderMultiColumnFlowThread::createAnonymous(Docume
nt& document, RenderStyle* parentStyle) |
49 { | 50 { |
(...skipping 14 matching lines...) Expand all Loading... |
64 | 65 |
65 RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const | 66 RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const |
66 { | 67 { |
67 for (RenderObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; s
ibling = sibling->previousSibling()) { | 68 for (RenderObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; s
ibling = sibling->previousSibling()) { |
68 if (sibling->isRenderMultiColumnSet()) | 69 if (sibling->isRenderMultiColumnSet()) |
69 return toRenderMultiColumnSet(sibling); | 70 return toRenderMultiColumnSet(sibling); |
70 } | 71 } |
71 return 0; | 72 return 0; |
72 } | 73 } |
73 | 74 |
74 RenderMultiColumnSpannerSet* RenderMultiColumnFlowThread::containingColumnSpanne
rSet(const RenderObject* descendant) const | 75 RenderMultiColumnSpannerPlaceholder* RenderMultiColumnFlowThread::containingColu
mnSpannerPlaceholder(const RenderObject* descendant) const |
75 { | 76 { |
76 ASSERT(descendant->isDescendantOf(this)); | 77 ASSERT(descendant->isDescendantOf(this)); |
77 | 78 |
78 // Before we spend time on searching the ancestry, see if there's a quick wa
y to determine | 79 // Before we spend time on searching the ancestry, see if there's a quick wa
y to determine |
79 // whether there might be any spanners at all. | 80 // whether there might be any spanners at all. |
80 RenderMultiColumnSet* firstSet = firstMultiColumnSet(); | 81 RenderBox* firstBox = firstMultiColumnBox(); |
81 if (!firstSet || (firstSet == lastMultiColumnSet() && !firstSet->isRenderMul
tiColumnSpannerSet())) | 82 if (!firstBox || (firstBox == lastMultiColumnBox() && firstBox->isRenderMult
iColumnSet())) |
82 return 0; | 83 return 0; |
83 | 84 |
84 // We have spanners. See if the renderer in question is one or inside of one
then. | 85 // We have spanners. See if the renderer in question is one or inside of one
then. |
85 for (const RenderObject* ancestor = descendant; ancestor && ancestor != this
; ancestor = ancestor->parent()) { | 86 for (const RenderObject* ancestor = descendant; ancestor && ancestor != this
; ancestor = ancestor->parent()) { |
86 if (RenderMultiColumnSpannerSet* spanner = m_spannerMap.get(ancestor)) | 87 if (RenderMultiColumnSpannerPlaceholder* placeholder = ancestor->spanner
Placeholder()) |
87 return spanner; | 88 return placeholder; |
88 } | 89 } |
89 return 0; | 90 return 0; |
90 } | 91 } |
91 | 92 |
92 void RenderMultiColumnFlowThread::populate() | 93 void RenderMultiColumnFlowThread::populate() |
93 { | 94 { |
94 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); | 95 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); |
95 ASSERT(!nextSibling()); | 96 ASSERT(!nextSibling()); |
96 // Reparent children preceding the flow thread into the flow thread. It's mu
lticol content | 97 // Reparent children preceding the flow thread into the flow thread. It's mu
lticol content |
97 // now. At this point there's obviously nothing after the flow thread, but r
enderers (column | 98 // now. At this point there's obviously nothing after the flow thread, but r
enderers (column |
98 // sets and spanners) will be inserted there as we insert elements into the
flow thread. | 99 // sets and spanners) will be inserted there as we insert elements into the
flow thread. |
99 multicolContainer->moveChildrenTo(this, multicolContainer->firstChild(), thi
s, true); | 100 multicolContainer->moveChildrenTo(this, multicolContainer->firstChild(), thi
s, true); |
100 } | 101 } |
101 | 102 |
102 void RenderMultiColumnFlowThread::evacuateAndDestroy() | 103 void RenderMultiColumnFlowThread::evacuateAndDestroy() |
103 { | 104 { |
104 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); | 105 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); |
| 106 m_isBeingEvacuated = true; |
105 | 107 |
106 // Remove all sets. | 108 // Remove all sets and spanners. |
107 while (RenderMultiColumnSet* columnSet = firstMultiColumnSet()) | 109 while (RenderBox* columnBox = firstMultiColumnBox()) { |
108 columnSet->destroy(); | 110 ASSERT(columnBox->isAnonymous()); |
| 111 columnBox->destroy(); |
| 112 } |
109 | 113 |
110 ASSERT(!previousSibling()); | 114 ASSERT(!previousSibling()); |
111 ASSERT(!nextSibling()); | 115 ASSERT(!nextSibling()); |
112 | 116 |
113 // Finally we can promote all flow thread's children. Before we move them to
the flow thread's | 117 // Finally we can promote all flow thread's children. Before we move them to
the flow thread's |
114 // container, we need to unregister the flow thread, so that they aren't jus
t re-added again to | 118 // container, we need to unregister the flow thread, so that they aren't jus
t re-added again to |
115 // the flow thread that we're trying to empty. | 119 // the flow thread that we're trying to empty. |
116 multicolContainer->resetMultiColumnFlowThread(); | 120 multicolContainer->resetMultiColumnFlowThread(); |
117 moveAllChildrenTo(multicolContainer, true); | 121 moveAllChildrenTo(multicolContainer, true); |
118 | 122 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 // Just before the multicol container (our parent RenderBlockFlow) finis
hes laying out, it | 159 // Just before the multicol container (our parent RenderBlockFlow) finis
hes laying out, it |
156 // will call recalculateColumnHeights() on us unconditionally, but we on
ly want that method | 160 // will call recalculateColumnHeights() on us unconditionally, but we on
ly want that method |
157 // to do any work if we actually laid out the flow thread. Otherwise, th
e balancing | 161 // to do any work if we actually laid out the flow thread. Otherwise, th
e balancing |
158 // machinery would kick in needlessly, and trigger additional layout pas
ses. Furthermore, we | 162 // machinery would kick in needlessly, and trigger additional layout pas
ses. Furthermore, we |
159 // actually depend on a proper flowthread layout pass in order to do bal
ancing, since it's | 163 // actually depend on a proper flowthread layout pass in order to do bal
ancing, since it's |
160 // flowthread layout that sets up content runs. | 164 // flowthread layout that sets up content runs. |
161 m_needsColumnHeightsRecalculation = false; | 165 m_needsColumnHeightsRecalculation = false; |
162 return; | 166 return; |
163 } | 167 } |
164 | 168 |
165 for (RenderMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; col
umnSet = columnSet->nextSiblingMultiColumnSet()) { | 169 for (RenderBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = co
lumnBox->nextSiblingBox()) { |
| 170 if (!columnBox->isRenderMultiColumnSet()) { |
| 171 ASSERT(columnBox->isRenderMultiColumnSpannerPlaceholder()); // no ot
her type is expected. |
| 172 continue; |
| 173 } |
| 174 RenderMultiColumnSet* columnSet = toRenderMultiColumnSet(columnBox); |
166 if (!m_inBalancingPass) { | 175 if (!m_inBalancingPass) { |
167 // This is the initial layout pass. We need to reset the column heig
ht, because contents | 176 // This is the initial layout pass. We need to reset the column heig
ht, because contents |
168 // typically have changed. | 177 // typically have changed. |
169 columnSet->resetColumnHeight(); | 178 columnSet->resetColumnHeight(); |
170 } | 179 } |
171 } | 180 } |
172 | 181 |
173 invalidateRegions(); | 182 invalidateRegions(); |
174 m_needsColumnHeightsRecalculation = heightIsAuto(); | 183 m_needsColumnHeightsRecalculation = heightIsAuto(); |
175 layout(); | 184 layout(); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
231 | 240 |
232 void RenderMultiColumnFlowThread::createAndInsertMultiColumnSet() | 241 void RenderMultiColumnFlowThread::createAndInsertMultiColumnSet() |
233 { | 242 { |
234 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); | 243 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); |
235 RenderMultiColumnSet* newSet = RenderMultiColumnSet::createAnonymous(this, m
ulticolContainer->style()); | 244 RenderMultiColumnSet* newSet = RenderMultiColumnSet::createAnonymous(this, m
ulticolContainer->style()); |
236 multicolContainer->RenderBlock::addChild(newSet); | 245 multicolContainer->RenderBlock::addChild(newSet); |
237 invalidateRegions(); | 246 invalidateRegions(); |
238 | 247 |
239 // We cannot handle immediate column set siblings (and there's no need for i
t, either). | 248 // We cannot handle immediate column set siblings (and there's no need for i
t, either). |
240 // There has to be at least one spanner separating them. | 249 // There has to be at least one spanner separating them. |
241 ASSERT(!newSet->previousSiblingMultiColumnSet() || newSet->previousSiblingMu
ltiColumnSet()->isRenderMultiColumnSpannerSet()); | 250 ASSERT(!newSet->previousSiblingMultiColumnBox() || !newSet->previousSiblingM
ultiColumnBox()->isRenderMultiColumnSet()); |
242 ASSERT(!newSet->nextSiblingMultiColumnSet() || newSet->nextSiblingMultiColum
nSet()->isRenderMultiColumnSpannerSet()); | 251 ASSERT(!newSet->nextSiblingMultiColumnBox() || !newSet->nextSiblingMultiColu
mnBox()->isRenderMultiColumnSet()); |
243 } | 252 } |
244 | 253 |
245 void RenderMultiColumnFlowThread::createAndInsertSpannerSet(RenderBox* spanner) | 254 void RenderMultiColumnFlowThread::createAndInsertSpannerPlaceholder(RenderBox* s
panner) |
246 { | 255 { |
247 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); | 256 RenderBlockFlow* multicolContainer = multiColumnBlockFlow(); |
248 RenderMultiColumnSpannerSet* newSpannerSet = RenderMultiColumnSpannerSet::cr
eateAnonymous(this, multicolContainer->style(), spanner); | 257 RenderMultiColumnSpannerPlaceholder* newPlaceholder = RenderMultiColumnSpann
erPlaceholder::createAnonymous(multicolContainer->style(), spanner); |
249 multicolContainer->RenderBlock::addChild(newSpannerSet); | 258 multicolContainer->RenderBlock::addChild(newPlaceholder); |
250 m_spannerMap.add(spanner, newSpannerSet); | 259 spanner->setSpannerPlaceholder(*newPlaceholder); |
251 invalidateRegions(); | |
252 } | 260 } |
253 | 261 |
254 bool RenderMultiColumnFlowThread::descendantIsValidColumnSpanner(RenderObject* d
escendant) const | 262 bool RenderMultiColumnFlowThread::descendantIsValidColumnSpanner(RenderObject* d
escendant) const |
255 { | 263 { |
256 // We assume that we're inside the flow thread. This function is not to be c
alled otherwise. | 264 // We assume that we're inside the flow thread. This function is not to be c
alled otherwise. |
257 ASSERT(descendant->isDescendantOf(this)); | 265 ASSERT(descendant->isDescendantOf(this)); |
258 | 266 |
| 267 // We're evaluating if the descendant should be turned into a proper spanner
. It shouldn't |
| 268 // already be one. |
| 269 ASSERT(!descendant->spannerPlaceholder()); |
| 270 |
259 // The spec says that column-span only applies to in-flow block-level elemen
ts. | 271 // The spec says that column-span only applies to in-flow block-level elemen
ts. |
260 if (descendant->style()->columnSpan() != ColumnSpanAll || !descendant->isBox
() || descendant->isInline() || descendant->isFloatingOrOutOfFlowPositioned()) | 272 if (descendant->style()->columnSpan() != ColumnSpanAll || !descendant->isBox
() || descendant->isInline() || descendant->isFloatingOrOutOfFlowPositioned()) |
261 return false; | 273 return false; |
262 | 274 |
263 if (!descendant->containingBlock()->isRenderBlockFlow()) { | 275 if (!descendant->containingBlock()->isRenderBlockFlow()) { |
264 // Needs to be in a block-flow container, and not e.g. a table. | 276 // Needs to be in a block-flow container, and not e.g. a table. |
265 return false; | 277 return false; |
266 } | 278 } |
267 | 279 |
268 // This looks like a spanner, but if we're inside something unbreakable, it'
s not to be treated as one. | 280 // This looks like a spanner, but if we're inside something unbreakable, it'
s not to be treated as one. |
269 for (RenderBlock* ancestor = descendant->containingBlock(); ancestor && ance
stor->flowThreadContainingBlock() == this; ancestor = ancestor->containingBlock(
)) { | 281 for (RenderBlock* ancestor = descendant->containingBlock(); ancestor; ancest
or = ancestor->containingBlock()) { |
270 if (ancestor->isRenderFlowThread()) { | 282 if (ancestor->isRenderFlowThread()) { |
271 ASSERT(ancestor == this); | 283 ASSERT(ancestor == this); |
272 return true; | 284 return true; |
273 } | 285 } |
274 if (m_spannerMap.get(ancestor)) { | 286 if (ancestor->spannerPlaceholder()) { |
275 // FIXME: do we want to support nested spanners in a different way?
The outer spanner | 287 // FIXME: do we want to support nested spanners in a different way?
The outer spanner |
276 // has already broken out from the columns to become sized by the mu
lticol container, | 288 // has already broken out from the columns to become sized by the mu
lticol container, |
277 // which may be good enough for the inner spanner. But margins, bord
ers, padding and | 289 // which may be good enough for the inner spanner. But margins, bord
ers, padding and |
278 // explicit widths on the outer spanner, or on any children between
the outer and inner | 290 // explicit widths on the outer spanner, or on any children between
the outer and inner |
279 // spanner, will affect the width of the inner spanner this way, whi
ch might be | 291 // spanner, will affect the width of the inner spanner this way, whi
ch might be |
280 // undesirable. The spec has nothing to say on the matter. | 292 // undesirable. The spec has nothing to say on the matter. |
281 return false; // Ignore nested spanners. | 293 return false; // Ignore nested spanners. |
282 } | 294 } |
283 if (ancestor->isUnsplittableForPagination()) | 295 if (ancestor->isUnsplittableForPagination()) |
284 return false; | 296 return false; |
(...skipping 14 matching lines...) Expand all Loading... |
299 ASSERT(it != m_multiColumnSetList.end()); | 311 ASSERT(it != m_multiColumnSetList.end()); |
300 m_multiColumnSetList.insertBefore(it, columnSet); | 312 m_multiColumnSetList.insertBefore(it, columnSet); |
301 } else { | 313 } else { |
302 m_multiColumnSetList.add(columnSet); | 314 m_multiColumnSetList.add(columnSet); |
303 } | 315 } |
304 columnSet->setIsValid(true); | 316 columnSet->setIsValid(true); |
305 } | 317 } |
306 | 318 |
307 void RenderMultiColumnFlowThread::willBeRemovedFromTree() | 319 void RenderMultiColumnFlowThread::willBeRemovedFromTree() |
308 { | 320 { |
309 m_spannerMap.clear(); | |
310 // Detach all column sets from the flow thread. Cannot destroy them at this
point, since they | 321 // Detach all column sets from the flow thread. Cannot destroy them at this
point, since they |
311 // are siblings of this object, and there may be pointers to this object's s
ibling somewhere | 322 // are siblings of this object, and there may be pointers to this object's s
ibling somewhere |
312 // further up on the call stack. | 323 // further up on the call stack. |
313 for (RenderMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; col
umnSet = columnSet->nextSiblingMultiColumnSet()) | 324 for (RenderMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; col
umnSet = columnSet->nextSiblingMultiColumnSet()) |
314 columnSet->detachRegion(); | 325 columnSet->detachRegion(); |
315 multiColumnBlockFlow()->resetMultiColumnFlowThread(); | 326 multiColumnBlockFlow()->resetMultiColumnFlowThread(); |
316 RenderFlowThread::willBeRemovedFromTree(); | 327 RenderFlowThread::willBeRemovedFromTree(); |
317 } | 328 } |
318 | 329 |
319 void RenderMultiColumnFlowThread::flowThreadDescendantWasInserted(RenderObject*
descendant) | 330 void RenderMultiColumnFlowThread::flowThreadDescendantWasInserted(RenderObject*
descendant) |
320 { | 331 { |
| 332 ASSERT(!m_isBeingEvacuated); |
321 // Go through the subtree that was just inserted and create column sets (nee
ded by regular | 333 // Go through the subtree that was just inserted and create column sets (nee
ded by regular |
322 // column content) and spanner sets (one needed by each spanner). | 334 // column content) and spanner placeholders (one needed by each spanner). |
323 for (RenderObject* renderer = descendant; renderer; renderer = renderer->nex
tInPreOrder(descendant)) { | 335 for (RenderObject* renderer = descendant; renderer; renderer = renderer->nex
tInPreOrder(descendant)) { |
324 if (containingColumnSpannerSet(renderer)) | 336 if (containingColumnSpannerPlaceholder(renderer)) |
325 continue; // Inside a column spanner set. Nothing to do, then. | 337 continue; // Inside a column spanner. Nothing to do, then. |
326 if (descendantIsValidColumnSpanner(renderer)) { | 338 if (descendantIsValidColumnSpanner(renderer)) { |
327 // This renderer is a spanner, so it needs to establish a spanner se
t. | 339 // This renderer is a spanner, so it needs to establish a spanner pl
aceholder. |
328 createAndInsertSpannerSet(toRenderBox(renderer)); | 340 createAndInsertSpannerPlaceholder(toRenderBox(renderer)); |
329 continue; | 341 continue; |
330 } | 342 } |
331 // This renderer is regular column content (i.e. not a spanner). Create
a set if necessary. | 343 // This renderer is regular column content (i.e. not a spanner). Create
a set if necessary. |
332 RenderMultiColumnSet* lastSet = lastMultiColumnSet(); | 344 RenderBox* lastColumnBox = lastMultiColumnBox(); |
333 if (!lastSet || lastSet->isRenderMultiColumnSpannerSet()) | 345 if (!lastColumnBox || !lastColumnBox->isRenderMultiColumnSet()) |
334 createAndInsertMultiColumnSet(); | 346 createAndInsertMultiColumnSet(); |
335 } | 347 } |
336 } | 348 } |
337 | 349 |
| 350 void RenderMultiColumnFlowThread::flowThreadDescendantWillBeRemoved(RenderObject
* descendant) |
| 351 { |
| 352 if (m_isBeingEvacuated) |
| 353 return; |
| 354 RenderObject* next; |
| 355 // Remove spanner placeholders that are no longer needed, and merge column s
ets around them. |
| 356 for (RenderObject* renderer = descendant; renderer; renderer = next) { |
| 357 RenderMultiColumnSpannerPlaceholder* placeholder = renderer->spannerPlac
eholder(); |
| 358 if (!placeholder) { |
| 359 next = renderer->nextInPreOrder(descendant); |
| 360 continue; |
| 361 } |
| 362 next = renderer->nextInPreOrderAfterChildren(descendant); // It's a span
ner. Its children are of no interest to us. |
| 363 if (RenderBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox())
{ |
| 364 RenderBox* previousColumnBox = placeholder->previousSiblingMultiColu
mnBox(); |
| 365 if (nextColumnBox && nextColumnBox->isRenderMultiColumnSet() |
| 366 && previousColumnBox && previousColumnBox->isRenderMultiColumnSe
t()) { |
| 367 // Need to merge two column sets. |
| 368 nextColumnBox->destroy(); |
| 369 previousColumnBox->setNeedsLayout(); |
| 370 invalidateRegions(); |
| 371 } |
| 372 } |
| 373 placeholder->destroy(); |
| 374 } |
| 375 } |
| 376 |
338 void RenderMultiColumnFlowThread::computeLogicalHeight(LayoutUnit logicalHeight,
LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const | 377 void RenderMultiColumnFlowThread::computeLogicalHeight(LayoutUnit logicalHeight,
LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const |
339 { | 378 { |
340 // We simply remain at our intrinsic height. | 379 // We simply remain at our intrinsic height. |
341 computedValues.m_extent = logicalHeight; | 380 computedValues.m_extent = logicalHeight; |
342 computedValues.m_position = logicalTop; | 381 computedValues.m_position = logicalTop; |
343 } | 382 } |
344 | 383 |
345 void RenderMultiColumnFlowThread::updateLogicalWidth() | 384 void RenderMultiColumnFlowThread::updateLogicalWidth() |
346 { | 385 { |
347 LayoutUnit columnWidth; | 386 LayoutUnit columnWidth; |
348 calculateColumnCountAndWidth(columnWidth, m_columnCount); | 387 calculateColumnCountAndWidth(columnWidth, m_columnCount); |
349 setLogicalWidth(columnWidth); | 388 setLogicalWidth(columnWidth); |
350 } | 389 } |
351 | 390 |
352 void RenderMultiColumnFlowThread::layout() | 391 void RenderMultiColumnFlowThread::layout() |
353 { | 392 { |
354 RenderFlowThread::layout(); | 393 RenderFlowThread::layout(); |
355 if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) | 394 if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) { |
356 lastSet->expandToEncompassFlowThreadContentsIfNeeded(); | 395 if (!lastSet->nextSiblingMultiColumnBox()) |
| 396 lastSet->expandToEncompassFlowThreadContentsIfNeeded(); |
| 397 } |
357 } | 398 } |
358 | 399 |
359 void RenderMultiColumnFlowThread::setPageBreak(LayoutUnit offset, LayoutUnit spa
ceShortage) | 400 void RenderMultiColumnFlowThread::setPageBreak(LayoutUnit offset, LayoutUnit spa
ceShortage) |
360 { | 401 { |
361 // Only positive values are interesting (and allowed) here. Zero space short
age may be reported | 402 // Only positive values are interesting (and allowed) here. Zero space short
age may be reported |
362 // when we're at the top of a column and the element has zero height. Ignore
this, and also | 403 // when we're at the top of a column and the element has zero height. Ignore
this, and also |
363 // ignore any negative values, which may occur when we set an early break in
order to honor | 404 // ignore any negative values, which may occur when we set an early break in
order to honor |
364 // widows in the next column. | 405 // widows in the next column. |
365 if (spaceShortage <= 0) | 406 if (spaceShortage <= 0) |
366 return; | 407 return; |
(...skipping 26 matching lines...) Expand all Loading... |
393 } | 434 } |
394 | 435 |
395 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const | 436 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const |
396 { | 437 { |
397 if (RenderMultiColumnSet* columnSet = lastMultiColumnSet()) | 438 if (RenderMultiColumnSet* columnSet = lastMultiColumnSet()) |
398 return columnSet->pageLogicalHeight(); | 439 return columnSet->pageLogicalHeight(); |
399 return false; | 440 return false; |
400 } | 441 } |
401 | 442 |
402 } | 443 } |
OLD | NEW |