blob: 30e0ec8fcdb40a0e3f2e007da66490bf9d077c5e [file] [log] [blame]
/*
* Copyright (C) 2018 Igalia S.L. 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. AND ITS CONTRIBUTORS ``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 ITS 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 "GridLayoutFunctions.h"
#include "RenderStyleConstants.h"
#include "WritingMode.h"
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
namespace WebCore {
// These classes are used to implement the Baseline Alignment logic, as described in the CSS Box Alignment
// specification.
// https://drafts.csswg.org/css-align/#baseline-terms
//
// A baseline-sharing group is composed of boxes that participate in baseline alignment together. This is
// possible only if they:
//
// * Share an alignment context along an axis perpendicular to their baseline alignment axis.
// * Have compatible baseline alignment preferences (i.e., the baselines that want to align are on the same
// side of the alignment context).
//
// Once the BaselineGroup is instantiated, defined by a 'block-direction' (WritingMode) and a 'baseline-preference'
// (first/last baseline), it's ready to collect the items that will participate in the Baseline Alignment logic.
//
class BaselineGroup {
public:
// It stores an item (if not already present) and update the max_ascent and max_descent associated to this
// baseline-sharing group.
void update(const RenderBox&, LayoutUnit ascent, LayoutUnit descent);
LayoutUnit maxAscent() const { return m_maxAscent; }
LayoutUnit maxDescent() const { return m_maxDescent; }
int size() const { return m_items.size(); }
private:
friend class BaselineContext;
BaselineGroup(WritingMode blockFlow, ItemPosition childPreference);
// Determines whether a baseline-sharing group is compatible with an item, based on its 'block-flow' and
// 'baseline-preference'
bool isCompatible(WritingMode, ItemPosition) const;
// Determines whether the baseline-sharing group's associated block-flow is opposite (LR vs RL) to particular
// item's writing-mode.
bool isOppositeBlockFlow(WritingMode blockFlow) const;
// Determines whether the baseline-sharing group's associated block-flow is orthogonal (vertical vs horizontal)
// to particular item's writing-mode.
bool isOrthogonalBlockFlow(WritingMode blockFlow) const;
WritingMode m_blockFlow;
ItemPosition m_preference;
LayoutUnit m_maxAscent;
LayoutUnit m_maxDescent;
HashSet<const RenderBox*> m_items;
};
// https://drafts.csswg.org/css-align-3/#shared-alignment-context
// Boxes share an alignment context along a particular axis when they are:
//
// * table cells in the same row, along the table's row (inline) axis
// * table cells in the same column, along the table's column (block) axis
// * grid items in the same row, along the grid's row (inline) axis
// * grid items in the same column, along the grid's colum (block) axis
// * flex items in the same flex line, along the flex container's main axis
//
// https://drafts.csswg.org/css-align-3/#baseline-sharing-group
// A Baseline alignment-context may handle several baseline-sharing groups. In order to create an instance, we
// need to pass the required data to define the first baseline-sharing group; a Baseline Context must have at
// least one baseline-sharing group.
//
// By adding new items to a Baseline Context, the baseline-sharing groups it handles are automatically updated,
// if there is one that is compatible with such item. Otherwise, a new baseline-sharing group is created,
// compatible with the new item.
class BaselineContext {
WTF_MAKE_FAST_ALLOCATED;
public:
BaselineContext(const RenderBox& child, ItemPosition preference, LayoutUnit ascent, LayoutUnit descent);
const BaselineGroup& sharedGroup(const RenderBox& child, ItemPosition preference) const;
// Updates the baseline-sharing group compatible with the item.
// We pass the item's baseline-preference to avoid dependencies with the LayoutGrid class, which is the one
// managing the alignment behavior of the Grid Items.
void updateSharedGroup(const RenderBox& child, ItemPosition preference, LayoutUnit ascent, LayoutUnit descent);
private:
// Returns the baseline-sharing group compatible with an item.
// We pass the item's baseline-preference to avoid dependencies with the LayoutGrid class, which is the one
// managing the alignment behavior of the Grid Items.
// FIXME: Properly implement baseline-group compatibility.
// See https://github.com/w3c/csswg-drafts/issues/721
BaselineGroup& findCompatibleSharedGroup(const RenderBox& child, ItemPosition preference);
Vector<BaselineGroup> m_sharedGroups;
};
enum AllowedBaseLine {FirstLine, LastLine, BothLines};
static inline bool isBaselinePosition(ItemPosition position)
{
return position == ItemPosition::Baseline || position == ItemPosition::LastBaseline;
}
static inline bool isFirstBaselinePosition(ItemPosition position)
{
return position == ItemPosition::Baseline;
}
// This is the class that implements the Baseline Alignment logic, using internally the BaselineContext and
// BaselineGroupd classes (described above).
//
// The first phase is to collect the items that will participate in baseline alignment together. During this
// phase the required baseline-sharing groups will be created for each Baseline alignment-context shared by
// the items participating in the baseline alignment.
//
// Additionally, the baseline-sharing groups' offsets, max-ascend and max-descent will be computed and stored.
// This class also computes the baseline offset for a particular item, based on the max-ascent for its associated
// baseline-sharing group.
class GridBaselineAlignment {
public:
// Collects the items participating in baseline alignment and updates the corresponding baseline-sharing
// group of the Baseline Context the items belongs to.
// All the baseline offsets are updated accordingly based on the added item.
void updateBaselineAlignmentContext(ItemPosition, unsigned sharedContext, const RenderBox&, GridAxis);
// Returns the baseline offset of a particular item, based on the max-ascent for its associated
// baseline-sharing group
LayoutUnit baselineOffsetForChild(ItemPosition, unsigned sharedContext, const RenderBox&, GridAxis) const;
// Sets the Grid Container's writing-mode so that we can avoid the dependecy of the LayoutGrid class for
// determining whether a grid item is orthogonal or not.
void setBlockFlow(WritingMode blockFlow) { m_blockFlow = blockFlow; };
// Clearing the Baseline Alignment context and their internal classes and data structures.
void clear(GridAxis);
private:
const BaselineGroup& baselineGroupForChild(ItemPosition, unsigned sharedContext, const RenderBox&, GridAxis) const;
LayoutUnit marginOverForChild(const RenderBox&, GridAxis) const;
LayoutUnit marginUnderForChild(const RenderBox&, GridAxis) const;
LayoutUnit logicalAscentForChild(const RenderBox&, GridAxis) const;
LayoutUnit ascentForChild(const RenderBox&, GridAxis) const;
LayoutUnit descentForChild(const RenderBox&, LayoutUnit, GridAxis) const;
bool isDescentBaselineForChild(const RenderBox&, GridAxis) const;
bool isHorizontalBaselineAxis(GridAxis) const;
bool isOrthogonalChildForBaseline(const RenderBox&) const;
bool isParallelToBaselineAxisForChild(const RenderBox&, GridAxis) const;
typedef HashMap<unsigned, std::unique_ptr<BaselineContext>, DefaultHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> BaselineContextsMap;
// Grid Container's WritingMode, used to determine grid item's orthogonality.
WritingMode m_blockFlow;
BaselineContextsMap m_rowAxisAlignmentContext;
BaselineContextsMap m_colAxisAlignmentContext;
};
} // namespace WebCore