chromium/third_party/blink/renderer/core/layout/table/table_borders.cc

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/layout/table/table_borders.h"

#include "third_party/blink/renderer/core/css/properties/longhands.h"
#include "third_party/blink/renderer/core/frame/web_feature.h"
#include "third_party/blink/renderer/core/layout/block_node.h"
#include "third_party/blink/renderer/core/layout/constraint_space.h"
#include "third_party/blink/renderer/core/layout/constraint_space_builder.h"
#include "third_party/blink/renderer/core/layout/length_utils.h"
#include "third_party/blink/renderer/core/layout/table/layout_table.h"
#include "third_party/blink/renderer/core/layout/table/layout_table_column_visitor.h"
#include "third_party/blink/renderer/core/layout/table/table_layout_algorithm_types.h"
#include "third_party/blink/renderer/core/layout/table/table_layout_utils.h"
#include "third_party/blink/renderer/core/style/computed_style.h"

namespace blink {

namespace {

// https://www.w3.org/TR/css-tables-3/#conflict-resolution-for-collapsed-borders
bool IsSourceMoreSpecificThanEdge(EBorderStyle source_style,
                                  LayoutUnit source_width,
                                  const TableBorders::Edge& edge) { … }

class ColBordersMarker { … };

class ColgroupBordersMarker { … };

}  // namespace

const TableBorders* TableBorders::ComputeTableBorders(const BlockNode& table) { … }

TableBorders::TableBorders(const BoxStrut& table_border,
                           const bool is_collapsed)
    : … { … }

Color TableBorders::BorderColor(const ComputedStyle* style,
                                EdgeSide edge_side) { … }

#if DCHECK_IS_ON()
String TableBorders::DumpEdges() { … }

void TableBorders::ShowEdges() { … }

bool TableBorders::operator==(const TableBorders& other) const { … }

#endif

BoxStrut TableBorders::GetCellBorders(wtf_size_t row,
                                      wtf_size_t column,
                                      wtf_size_t rowspan,
                                      wtf_size_t colspan) const { … }

void TableBorders::UpdateTableBorder(wtf_size_t table_row_count,
                                     wtf_size_t table_column_count) { … }

BoxStrut TableBorders::CellBorder(
    const BlockNode& cell,
    wtf_size_t row,
    wtf_size_t column,
    wtf_size_t section,
    WritingDirectionMode table_writing_direction) const { … }

// As we are determining the intrinsic size of the table at this stage,
// %-padding resolves against an indefinite size.
BoxStrut TableBorders::CellPaddingForMeasure(
    const ComputedStyle& cell_style,
    WritingDirectionMode table_writing_direction) const { … }

void TableBorders::MergeBorders(wtf_size_t cell_start_row,
                                wtf_size_t cell_start_column,
                                wtf_size_t rowspan,
                                wtf_size_t colspan,
                                const ComputedStyle& source_style,
                                EdgeSource source,
                                const wtf_size_t box_order,
                                WritingDirectionMode table_writing_direction,
                                wtf_size_t section_index) { … }

void TableBorders::MergeRowAxisBorder(wtf_size_t start_row,
                                      wtf_size_t start_column,
                                      wtf_size_t colspan,
                                      const ComputedStyle& source_style,
                                      const wtf_size_t box_order,
                                      EdgeSide physical_side) { … }

void TableBorders::MergeColumnAxisBorder(wtf_size_t start_row,
                                         wtf_size_t start_column,
                                         wtf_size_t rowspan,
                                         const ComputedStyle& source_style,
                                         const wtf_size_t box_order,
                                         EdgeSide physical_side) { … }

// Rowspanned/colspanned cells need to mark inner edges as do-not-fill to
// prevent tables parts from drawing into them.
void TableBorders::MarkInnerBordersAsDoNotFill(wtf_size_t start_row,
                                               wtf_size_t start_column,
                                               wtf_size_t rowspan,
                                               wtf_size_t colspan) { … }

// Inline edges are edges between columns.
void TableBorders::EnsureCellColumnFits(wtf_size_t cell_column) { … }

// Block edges are edges between rows.
void TableBorders::EnsureCellRowFits(wtf_size_t cell_row) { … }

}  // namespace blink