|
|
@@ -0,0 +1,469 @@
|
|
|
+/*
|
|
|
+ * This source file is part of RmlUi, the HTML/CSS Interface Middleware
|
|
|
+ *
|
|
|
+ * For the latest information, see http://github.com/mikke89/RmlUi
|
|
|
+ *
|
|
|
+ * Copyright (c) 2008-2010 CodePoint Ltd, Shift Technology Ltd
|
|
|
+ * Copyright (c) 2019 The RmlUi Team, and contributors
|
|
|
+ *
|
|
|
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
+ * of this software and associated documentation files (the "Software"), to deal
|
|
|
+ * in the Software without restriction, including without limitation the rights
|
|
|
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
+ * copies of the Software, and to permit persons to whom the Software is
|
|
|
+ * furnished to do so, subject to the following conditions:
|
|
|
+ *
|
|
|
+ * The above copyright notice and this permission notice shall be included in
|
|
|
+ * all copies or substantial portions of the Software.
|
|
|
+ *
|
|
|
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
+ * THE SOFTWARE.
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+#include "LayoutTable.h"
|
|
|
+#include "LayoutDetails.h"
|
|
|
+#include "LayoutEngine.h"
|
|
|
+#include "../../Include/RmlUi/Core/Element.h"
|
|
|
+#include "../../Include/RmlUi/Core/Profiling.h"
|
|
|
+#include "../../Include/RmlUi/Core/Types.h"
|
|
|
+#include <cstddef>
|
|
|
+#include <algorithm>
|
|
|
+
|
|
|
+namespace Rml {
|
|
|
+
|
|
|
+
|
|
|
+LayoutTable::CloseResult LayoutTable::FormatTable(LayoutBlockBox* table_block_context_box, Element* element_table)
|
|
|
+{
|
|
|
+ const Vector2f content_top_left = table_block_context_box->GetBox().GetPosition();
|
|
|
+ const Vector2f content_containing_block = Vector2f(table_block_context_box->GetBox().GetSize().x, Math::Max(0.0f, table_block_context_box->GetBox().GetSize().y));
|
|
|
+
|
|
|
+ const Vector2f table_gap(10.f, 0.f);
|
|
|
+
|
|
|
+ Vector<float> column_border_widths = DetermineColumnWidths(element_table, content_containing_block, table_gap);
|
|
|
+
|
|
|
+ // Now that we have the size of each column, we can move on to formatting the elements.
|
|
|
+ // After we format and size an element, we record its height as well, and keep the maximum_height over all cells in the current row.
|
|
|
+ // At the end of a row, we then know the height of the row, and we can proceed by positioning the cells.
|
|
|
+
|
|
|
+ Vector2f table_content_overflow_size;
|
|
|
+
|
|
|
+ Vector2f table_cursor = content_top_left;
|
|
|
+ table_cursor.y -= table_gap.y;
|
|
|
+
|
|
|
+ struct Cell {
|
|
|
+ Element* element_cell;
|
|
|
+ int row_last; // The last row the cell spans
|
|
|
+ int column_begin, column_last;
|
|
|
+ Box box;
|
|
|
+ Vector2f table_offset;
|
|
|
+ float rows_accumulated_height;
|
|
|
+ };
|
|
|
+ Vector<Cell> cells;
|
|
|
+ cells.reserve(column_border_widths.size());
|
|
|
+
|
|
|
+ const int num_table_children = element_table->GetNumChildren();
|
|
|
+ int row = -1;
|
|
|
+ for (int i = 0; i < num_table_children; i++)
|
|
|
+ {
|
|
|
+ Element* element_row = element_table->GetChild(i);
|
|
|
+
|
|
|
+ const ComputedValues& computed_row = element_row->GetComputedValues();
|
|
|
+ if (computed_row.display != Style::Display::TableRow)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ row += 1;
|
|
|
+
|
|
|
+ Box row_box;
|
|
|
+ float row_min_height, row_max_height;
|
|
|
+ LayoutDetails::BuildBox(row_box, content_containing_block, element_row, false, 0.f);
|
|
|
+ LayoutDetails::GetMinMaxHeight(row_min_height, row_max_height, &computed_row, row_box, content_containing_block.y);
|
|
|
+
|
|
|
+ // Prepare the cursor for this row
|
|
|
+ table_cursor.x = content_top_left.x;
|
|
|
+ table_cursor.y += table_gap.y;
|
|
|
+
|
|
|
+ const Vector2f row_element_offset = table_cursor + Vector2f(row_box.GetEdge(Box::MARGIN, Box::LEFT), row_box.GetEdge(Box::MARGIN, Box::TOP));
|
|
|
+
|
|
|
+ {
|
|
|
+ const float row_top_offset = row_box.GetEdge(Box::MARGIN, Box::TOP) + row_box.GetEdge(Box::BORDER, Box::TOP) + row_box.GetEdge(Box::PADDING, Box::TOP);
|
|
|
+ table_cursor.y += row_top_offset;
|
|
|
+
|
|
|
+ for (Cell& cell : cells)
|
|
|
+ cell.rows_accumulated_height += row_top_offset;
|
|
|
+ }
|
|
|
+
|
|
|
+ const int num_cells_spanning_this_row = (int)cells.size();
|
|
|
+ const int num_row_children = element_row->GetNumChildren();
|
|
|
+
|
|
|
+ // For all child cell elements of this row, add them to the list of cells and determine their position.
|
|
|
+ for (int j = 0, column = 0; j < num_row_children; j++)
|
|
|
+ {
|
|
|
+ Element* element_cell = element_row->GetChild(j);
|
|
|
+
|
|
|
+ const ComputedValues& computed_cell = element_cell->GetComputedValues();
|
|
|
+ if (computed_cell.display != Style::Display::TableCell)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ const int row_span = Math::Max(1, element_cell->GetAttribute("rowspan", 1));
|
|
|
+ const int col_span = Math::Max(1, element_cell->GetAttribute("colspan", 1));
|
|
|
+
|
|
|
+ float spanning_column_border_width = 0;
|
|
|
+ int column_last = -1;
|
|
|
+
|
|
|
+ {
|
|
|
+ // Offset the column if we have any rowspan elements from previous rows overlapping with the current column.
|
|
|
+ const int column_offset_from = column;
|
|
|
+
|
|
|
+ for (bool continue_offset_column = true; continue_offset_column; )
|
|
|
+ {
|
|
|
+ continue_offset_column = false;
|
|
|
+ for (int k = 0; k < num_cells_spanning_this_row; k++)
|
|
|
+ {
|
|
|
+ if (column >= cells[k].column_begin && column <= cells[k].column_last)
|
|
|
+ {
|
|
|
+ column = cells[k].column_last + 1;
|
|
|
+ continue_offset_column = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ column_last = column + col_span - 1;
|
|
|
+
|
|
|
+ if (column_last >= (int)column_border_widths.size())
|
|
|
+ {
|
|
|
+ Log::Message(Log::LT_WARNING, "Too many columns in table row %d: %s\nThe number of columns is %d, as determined by the first table row.",
|
|
|
+ row + 1, element_row->GetAddress().c_str(), (int)column_border_widths.size());
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int k = column_offset_from; k < column; k++)
|
|
|
+ table_cursor.x += column_border_widths[k];
|
|
|
+
|
|
|
+ table_cursor.x += table_gap.x * float(column - column_offset_from);
|
|
|
+
|
|
|
+ for (int k = column; k <= column_last; k++)
|
|
|
+ spanning_column_border_width += column_border_widths[k];
|
|
|
+
|
|
|
+ spanning_column_border_width += table_gap.x * float(col_span - 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Add the new cell to our list.
|
|
|
+ cells.emplace_back();
|
|
|
+ Cell& cell = cells.back();
|
|
|
+
|
|
|
+ cell.row_last = row + row_span - 1;
|
|
|
+ cell.column_begin = column;
|
|
|
+ cell.column_last = column_last;
|
|
|
+ cell.element_cell = element_cell;
|
|
|
+ cell.table_offset = table_cursor;
|
|
|
+ cell.rows_accumulated_height = 0;
|
|
|
+
|
|
|
+ // Determine the cell's box for formatting later, we may get an indefinite (-1) vertical content size.
|
|
|
+ Box& box = cell.box;
|
|
|
+ LayoutDetails::BuildBox(box, content_containing_block, element_cell, false, 0.f);
|
|
|
+
|
|
|
+ // Determine the box width from the current column width.
|
|
|
+ const float content_width = Math::Max(0.0f, spanning_column_border_width - box.GetSizeAcross(Box::HORIZONTAL, Box::BORDER, Box::PADDING));
|
|
|
+ box.SetContent(Vector2f(content_width, box.GetSize().y));
|
|
|
+
|
|
|
+ table_cursor.x += spanning_column_border_width + table_gap.x;
|
|
|
+
|
|
|
+ column += col_span;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Partition the cells to determine those who end at this row.
|
|
|
+ const auto it_cells_in_row_end = std::partition(cells.begin(), cells.end(), [row](const Cell& cell) { return cell.row_last == row; });
|
|
|
+
|
|
|
+ // Determine the row height.
|
|
|
+ float row_content_height = 0;
|
|
|
+ if (row_box.GetSize().y >= 0)
|
|
|
+ {
|
|
|
+ // The row has a definite size, use that.
|
|
|
+ row_content_height = row_box.GetSize().y;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // The row does not have a definite size, we will use the maximum height of all its cells to determine the row height.
|
|
|
+ // For each cell in this row, or spanning onto this row from any previous rows, increase the row height as necessary to make the cell fit.
|
|
|
+ for (auto it = cells.begin(); it != it_cells_in_row_end; ++it)
|
|
|
+ {
|
|
|
+ Cell& cell = *it;
|
|
|
+ Element* element_cell = cell.element_cell;
|
|
|
+ Box& box = cell.box;
|
|
|
+
|
|
|
+ // If the cell's height is also indefinite, we need to format it to get its height.
|
|
|
+ if (box.GetSize().y < 0)
|
|
|
+ {
|
|
|
+ LayoutEngine::FormatElement(element_cell, content_containing_block, &box);
|
|
|
+ box.SetContent(element_cell->GetBox().GetSize());
|
|
|
+ }
|
|
|
+
|
|
|
+ row_content_height = Math::Max(row_content_height, box.GetSizeAcross(Box::VERTICAL, Box::BORDER) - cell.rows_accumulated_height);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ row_content_height = Math::Clamp(row_content_height, row_min_height, row_max_height);
|
|
|
+
|
|
|
+ for (Cell& cell : cells)
|
|
|
+ cell.rows_accumulated_height += row_content_height;
|
|
|
+
|
|
|
+ // Now we have the height of the row, position and format each cell.
|
|
|
+ auto FormatCellsInRow = [row, &cells, it_cells_in_row_end, &table_content_overflow_size, element_table, content_containing_block, content_top_left]() {
|
|
|
+
|
|
|
+ // Assumes the cells are already partitioned.
|
|
|
+ for (auto it = cells.begin(); it != it_cells_in_row_end; ++it)
|
|
|
+ {
|
|
|
+ Cell& cell = *it;
|
|
|
+ Element* element_cell = cell.element_cell;
|
|
|
+ Box& box = cell.box;
|
|
|
+ Style::VerticalAlign vertical_align = cell.element_cell->GetComputedValues().vertical_align;
|
|
|
+
|
|
|
+ if (box.GetSize().y < 0)
|
|
|
+ {
|
|
|
+ const bool is_aligned = (vertical_align.type == Style::VerticalAlign::Middle || vertical_align.type == Style::VerticalAlign::Bottom);
|
|
|
+ if (is_aligned)
|
|
|
+ {
|
|
|
+ // The size of the cell is indefinite, we need to get the height by formatting the cell.
|
|
|
+ LayoutEngine::FormatElement(element_cell, content_containing_block, &box);
|
|
|
+ box.SetContent(element_cell->GetBox().GetSize());
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ box.SetContent(Vector2f(box.GetSize().x, Math::Max(0.0f, cell.rows_accumulated_height - box.GetSizeAcross(Box::VERTICAL, Box::BORDER, Box::PADDING))));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const float available_height = cell.rows_accumulated_height - box.GetSizeAcross(Box::VERTICAL, Box::BORDER);
|
|
|
+
|
|
|
+ if (available_height > 0)
|
|
|
+ {
|
|
|
+ // Pad the cell for vertical alignment
|
|
|
+ float add_padding_top;
|
|
|
+ float add_padding_bottom;
|
|
|
+
|
|
|
+ switch (vertical_align.type)
|
|
|
+ {
|
|
|
+ case Style::VerticalAlign::Bottom:
|
|
|
+ add_padding_top = available_height;
|
|
|
+ add_padding_bottom = 0;
|
|
|
+ break;
|
|
|
+ case Style::VerticalAlign::Middle:
|
|
|
+ add_padding_top = 0.5f * available_height;
|
|
|
+ add_padding_bottom = 0.5f * available_height;
|
|
|
+ break;
|
|
|
+ case Style::VerticalAlign::Top:
|
|
|
+ default:
|
|
|
+ add_padding_top = 0.0f;
|
|
|
+ add_padding_bottom = available_height;
|
|
|
+ }
|
|
|
+
|
|
|
+ box.SetEdge(Box::PADDING, Box::TOP, box.GetEdge(Box::PADDING, Box::TOP) + add_padding_top);
|
|
|
+ box.SetEdge(Box::PADDING, Box::BOTTOM, box.GetEdge(Box::PADDING, Box::BOTTOM) + add_padding_bottom);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ // Format the cell in a new block formatting context.
|
|
|
+ Vector2f cell_visible_overflow_size;
|
|
|
+ LayoutEngine::FormatElement(element_cell, content_containing_block, &box, &cell_visible_overflow_size);
|
|
|
+
|
|
|
+ table_content_overflow_size.x = Math::Max(table_content_overflow_size.x, cell.table_offset.x - content_top_left.x + cell_visible_overflow_size.x);
|
|
|
+ table_content_overflow_size.y = Math::Max(table_content_overflow_size.y, cell.table_offset.y - content_top_left.y + cell_visible_overflow_size.y);
|
|
|
+
|
|
|
+ // Set the position of the element within the the table container
|
|
|
+ element_cell->SetOffset(cell.table_offset, element_table);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Remove the formatted cells from pending
|
|
|
+ cells.erase(cells.begin(), it_cells_in_row_end);
|
|
|
+ };
|
|
|
+
|
|
|
+ FormatCellsInRow();
|
|
|
+
|
|
|
+ // TODO: What to do with any remaining row-spanning cells after the last row?
|
|
|
+
|
|
|
+ // Position and size the row element
|
|
|
+ if (row_box.GetSize().y < 0.0f)
|
|
|
+ row_box.SetContent(Vector2f(row_box.GetSize().x, row_content_height));
|
|
|
+
|
|
|
+ element_row->SetOffset(row_element_offset, element_table);
|
|
|
+ element_row->SetBox(row_box);
|
|
|
+
|
|
|
+ const float row_bottom_offset = row_box.GetEdge(Box::MARGIN, Box::BOTTOM) + row_box.GetEdge(Box::BORDER, Box::BOTTOM) + row_box.GetEdge(Box::PADDING, Box::BOTTOM);
|
|
|
+ table_cursor.y += row_content_height + row_bottom_offset;
|
|
|
+
|
|
|
+ for (Cell& cell : cells)
|
|
|
+ cell.rows_accumulated_height += row_bottom_offset;
|
|
|
+ }
|
|
|
+
|
|
|
+ table_block_context_box->ExtendInnerContentSize(table_content_overflow_size);
|
|
|
+
|
|
|
+ CloseResult result = table_block_context_box->Close();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+LayoutTable::ColumnWidths LayoutTable::DetermineColumnWidths(Element* element_table, const Vector2f containing_block, const Vector2f table_gap)
|
|
|
+{
|
|
|
+ ColumnWidths column_widths;
|
|
|
+
|
|
|
+ // Determine the widths of the cells.
|
|
|
+ Element* element_first_row = nullptr;
|
|
|
+
|
|
|
+ for (int i = 0; i < element_table->GetNumChildren(); i++)
|
|
|
+ {
|
|
|
+ element_first_row = element_table->GetChild(i);
|
|
|
+ if (element_first_row->GetDisplay() != Style::Display::TableRow)
|
|
|
+ {
|
|
|
+ Log::Message(Log::LT_WARNING, "Only table rows ('display: table-row') are allowed as children of tables. %s", element_first_row->GetAddress().c_str());
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!element_first_row)
|
|
|
+ {
|
|
|
+ Log::Message(Log::LT_WARNING, "No rows in table. %s", element_table->GetAddress().c_str());
|
|
|
+ // TODO: Handle this more gracefully.
|
|
|
+ return ColumnWidths();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ const int num_row_children = element_first_row->GetNumChildren();
|
|
|
+
|
|
|
+ struct CellMetrics {
|
|
|
+ float fixed_content_width;
|
|
|
+ float padding_border_edges_width;
|
|
|
+ float flex_width;
|
|
|
+ float min_content_width;
|
|
|
+ float max_content_width;
|
|
|
+ };
|
|
|
+ Vector<CellMetrics> cell_metrics;
|
|
|
+ cell_metrics.reserve(num_row_children);
|
|
|
+
|
|
|
+ for (int i = 0; i < num_row_children; i++)
|
|
|
+ {
|
|
|
+ Element* element_cell = element_first_row->GetChild(i);
|
|
|
+
|
|
|
+ const ComputedValues& computed = element_cell->GetComputedValues();
|
|
|
+
|
|
|
+ if (computed.display != Style::Display::TableCell)
|
|
|
+ {
|
|
|
+ Log::Message(Log::LT_WARNING, "Only table cells ('display: table-cell') are allowed as children of table rows. %s", element_cell->GetAddress().c_str());
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ const float padding_border_edges_width =
|
|
|
+ Math::Max(0.0f, ResolveValue(computed.padding_left, containing_block.x)) +
|
|
|
+ Math::Max(0.0f, ResolveValue(computed.padding_right, containing_block.x)) +
|
|
|
+ Math::Max(0.0f, computed.border_left_width) +
|
|
|
+ Math::Max(0.0f, computed.border_right_width);
|
|
|
+
|
|
|
+ auto min_max_widths = [containing_block_width = containing_block.x](float& min_width, float& max_width, float border_padding_edges_width, const ComputedValues& computed) {
|
|
|
+ min_width = ResolveValue(computed.min_width, containing_block_width);
|
|
|
+ max_width = (computed.max_width.value < 0.f ? FLT_MAX : ResolveValue(computed.max_width, containing_block_width));
|
|
|
+
|
|
|
+ if (computed.box_sizing == Style::BoxSizing::BorderBox)
|
|
|
+ {
|
|
|
+ min_width = Math::Max(0.0f, min_width - border_padding_edges_width);
|
|
|
+ max_width = Math::Max(0.0f, max_width - border_padding_edges_width);
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ CellMetrics metric = {};
|
|
|
+ metric.padding_border_edges_width = padding_border_edges_width;
|
|
|
+ min_max_widths(metric.min_content_width, metric.max_content_width, padding_border_edges_width, computed);
|
|
|
+
|
|
|
+ if (computed.width.type == Style::Width::Auto)
|
|
|
+ {
|
|
|
+ metric.flex_width = 1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (computed.box_sizing == Style::BoxSizing::ContentBox)
|
|
|
+ metric.fixed_content_width = ResolveValue(computed.width, containing_block.x);
|
|
|
+ else
|
|
|
+ metric.fixed_content_width = Math::Max(0.f, ResolveValue(computed.width, containing_block.x - padding_border_edges_width));
|
|
|
+
|
|
|
+ metric.fixed_content_width = Math::Clamp(metric.fixed_content_width, metric.min_content_width, metric.max_content_width);
|
|
|
+ }
|
|
|
+
|
|
|
+ const int colspan = Math::Max(1, element_cell->GetAttribute("colspan", 1));
|
|
|
+ if (colspan > 1)
|
|
|
+ {
|
|
|
+ const float width_factor = 1.f / float(colspan);
|
|
|
+ metric.fixed_content_width *= width_factor;
|
|
|
+ metric.min_content_width *= width_factor;
|
|
|
+ metric.max_content_width *= width_factor;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(int j = 0; j < colspan; j++)
|
|
|
+ cell_metrics.push_back(metric);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ auto calculate_fr_to_px_ratio = [table_content_width = containing_block.x, column_gap = table_gap.x, &cell_metrics]() {
|
|
|
+ float sum_fixed_width = 0; // [px]
|
|
|
+ float sum_flex_width = 0; // [fr]
|
|
|
+
|
|
|
+ for (const CellMetrics& metric : cell_metrics)
|
|
|
+ {
|
|
|
+ sum_flex_width += metric.flex_width;
|
|
|
+ sum_fixed_width += (metric.flex_width == 0.f ? metric.fixed_content_width : 0.0f) + metric.padding_border_edges_width + column_gap;
|
|
|
+ }
|
|
|
+
|
|
|
+ sum_flex_width = Math::Max(1.f, sum_flex_width);
|
|
|
+ sum_fixed_width = Math::Max(0.f, sum_fixed_width - column_gap);
|
|
|
+
|
|
|
+ const float available_flex_width = table_content_width - sum_fixed_width;
|
|
|
+ const float fr_to_px_ratio = available_flex_width / sum_flex_width;
|
|
|
+
|
|
|
+ return fr_to_px_ratio;
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ for (bool continue_iteration = true; continue_iteration; )
|
|
|
+ {
|
|
|
+ continue_iteration = false;
|
|
|
+ const float fr_to_px_ratio = calculate_fr_to_px_ratio();
|
|
|
+
|
|
|
+ for (auto& metric : cell_metrics)
|
|
|
+ {
|
|
|
+ if (metric.flex_width > 0)
|
|
|
+ {
|
|
|
+ const float fixed_flex_width = metric.flex_width * fr_to_px_ratio;
|
|
|
+ metric.fixed_content_width = Math::Clamp(fixed_flex_width, metric.min_content_width, metric.max_content_width);
|
|
|
+
|
|
|
+ if (metric.fixed_content_width != fixed_flex_width)
|
|
|
+ {
|
|
|
+ // We met a min/max-constraint, fix the size of this column.
|
|
|
+ metric.flex_width = 0.0f;
|
|
|
+ continue_iteration = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ column_widths.resize(cell_metrics.size());
|
|
|
+
|
|
|
+ for (size_t i = 0; i < cell_metrics.size(); i++)
|
|
|
+ {
|
|
|
+ column_widths[i] = cell_metrics[i].fixed_content_width + cell_metrics[i].padding_border_edges_width;
|
|
|
+ }
|
|
|
+
|
|
|
+ // TODO: What to do with any left-over space? Distribute evenly across columns, or make table smaller etc.
|
|
|
+
|
|
|
+ return column_widths;
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace Rml
|
Michael Ragazzon