1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
|
/*
* Copyright (C) 2012 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "RenderFragmentedFlow.h"
#include <wtf/HashMap.h>
namespace WebCore {
class RenderMultiColumnSet;
class RenderMultiColumnSpannerPlaceholder;
class RenderMultiColumnFlow final : public RenderFragmentedFlow {
WTF_MAKE_TZONE_OR_ISO_ALLOCATED(RenderMultiColumnFlow);
WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(RenderMultiColumnFlow);
public:
RenderMultiColumnFlow(Document&, RenderStyle&&);
virtual ~RenderMultiColumnFlow();
RenderBlockFlow* multiColumnBlockFlow() const { return downcast<RenderBlockFlow>(parent()); }
RenderMultiColumnSet* firstMultiColumnSet() const;
RenderMultiColumnSet* lastMultiColumnSet() const;
RenderBox* firstColumnSetOrSpanner() const;
bool hasColumnSpanner() const { return !m_spannerMap.isEmpty(); }
static RenderBox* nextColumnSetOrSpannerSiblingOf(const RenderBox*);
static RenderBox* previousColumnSetOrSpannerSiblingOf(const RenderBox*);
RenderMultiColumnSpannerPlaceholder* findColumnSpannerPlaceholder(const RenderBox* spanner) const;
void layout() override;
unsigned columnCount() const { return m_columnCount; }
LayoutUnit columnWidth() const { return m_columnWidth; }
LayoutUnit columnHeightAvailable() const { return m_columnHeightAvailable; }
void setColumnHeightAvailable(LayoutUnit available) { m_columnHeightAvailable = available; }
bool inBalancingPass() const { return m_inBalancingPass; }
void setInBalancingPass(bool balancing) { m_inBalancingPass = balancing; }
bool needsHeightsRecalculation() const { return m_needsHeightsRecalculation; }
void setNeedsHeightsRecalculation(bool recalculate) { m_needsHeightsRecalculation = recalculate; }
bool shouldRelayoutForPagination() const { return !m_inBalancingPass && m_needsHeightsRecalculation; }
void setColumnCountAndWidth(unsigned count, LayoutUnit width)
{
m_columnCount = count;
m_columnWidth = width;
}
bool progressionIsInline() const { return m_progressionIsInline; }
void setProgressionIsInline(bool progressionIsInline) { m_progressionIsInline = progressionIsInline; }
bool progressionIsReversed() const { return m_progressionIsReversed; }
void setProgressionIsReversed(bool reversed) { m_progressionIsReversed = reversed; }
RenderFragmentContainer* mapFromFlowToFragment(TransformState&) const final;
// This method takes a logical offset and returns a physical translation that can be applied to map
// a physical point (corresponding to the logical offset) into the fragment's physical coordinate space.
LayoutSize physicalTranslationOffsetFromFlowToFragment(const RenderFragmentContainer*, const LayoutUnit) const;
// The point is physical, and the result is a physical location within the fragment.
RenderFragmentContainer* physicalTranslationFromFlowToFragment(LayoutPoint&) const;
// This method is the inverse of the previous method and goes from fragment to flow.
LayoutSize physicalTranslationFromFragmentToFlow(const RenderMultiColumnSet*, const LayoutPoint&) const;
bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
void mapAbsoluteToLocalPoint(OptionSet<MapCoordinatesMode>, TransformState&) const override;
LayoutSize offsetFromContainer(RenderElement&, const LayoutPoint&, bool* offsetDependsOnPoint = nullptr) const override;
// FIXME: Eventually as column and fragment flow threads start nesting, this will end up changing.
bool shouldCheckColumnBreaks() const override;
using SpannerMap = UncheckedKeyHashMap<SingleThreadWeakRef<const RenderBox>, SingleThreadWeakPtr<RenderMultiColumnSpannerPlaceholder>>;
SpannerMap& spannerMap() { return m_spannerMap; }
private:
ASCIILiteral renderName() const override;
void addFragmentToThread(RenderFragmentContainer*) override;
void willBeRemovedFromTree() override;
void fragmentedFlowDescendantBoxLaidOut(RenderBox*) override;
LogicalExtentComputedValues computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const override;
LayoutUnit initialLogicalWidth() const override;
void setPageBreak(const RenderBlock*, LayoutUnit offset, LayoutUnit spaceShortage) override;
void updateMinimumPageHeight(const RenderBlock*, LayoutUnit offset, LayoutUnit minHeight) override;
void updateSpaceShortageForSizeContainment(const RenderBlock*, LayoutUnit offset, LayoutUnit shortage) override;
RenderFragmentContainer* fragmentAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastFragment = false) const override;
void setFragmentRangeForBox(const RenderBox&, RenderFragmentContainer*, RenderFragmentContainer*) override;
bool addForcedFragmentBreak(const RenderBlock*, LayoutUnit, RenderBox* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment = 0) override;
bool isPageLogicalHeightKnown() const override;
private:
SpannerMap m_spannerMap;
// The last set we worked on. It's not to be used as the "current set". The concept of a
// "current set" is difficult, since layout may jump back and forth in the tree, due to wrong
// top location estimates (due to e.g. margin collapsing), and possibly for other reasons.
mutable SingleThreadWeakPtr<RenderMultiColumnSet> m_lastSetWorkedOn { nullptr };
unsigned m_columnCount { 1 }; // The default column count/width that are based off our containing block width. These values represent only the default,
LayoutUnit m_columnWidth { 0 }; // A multi-column block that is split across variable width pages or fragments will have different column counts and widths in each. These values will be cached (eventually) for multi-column blocks.
LayoutUnit m_columnHeightAvailable; // Total height available to columns, or 0 if auto.
bool m_inLayout { false }; // Set while we're laying out the flow thread, during which colum set heights are unknown.
bool m_inBalancingPass { false }; // Guard to avoid re-entering column balancing.
bool m_needsHeightsRecalculation { false };
bool m_progressionIsInline { false };
bool m_progressionIsReversed { false };
};
} // namespace WebCore
SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderMultiColumnFlow, isRenderMultiColumnFlow())
|