/** * adg_table_cell_size_request: * @table_cell: a valid #AdgTableCell * @row_extents: the extents of the container #AdgTableRow * * Computes the minimum space needed to properly render @table_cell * and updates the size component of the internal #CpmlExtents struct, * returning it to the caller. The returned #CpmlPair is owned by * @table_cell and should not be modified or freed. * * Returns: (transfer none): the minimum size required. * * Since: 1.0 **/ const CpmlPair * adg_table_cell_size_request(AdgTableCell *table_cell, const CpmlExtents *row_extents) { CpmlVector *size; AdgAlignment *title_alignment; AdgAlignment *value_alignment; AdgTable *table; size = &table_cell->extents.size; if (table_cell->title) { title_alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->title); adg_entity_arrange((AdgEntity *) title_alignment); } else { title_alignment = NULL; } if (table_cell->value) { value_alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->value); adg_entity_arrange((AdgEntity *) value_alignment); } else { value_alignment = NULL; } table = adg_table_cell_get_table(table_cell); size->y = row_extents->size.y; if (table_cell->width == 0) { AdgTableStyle *table_style = (AdgTableStyle *) adg_table_get_table_style(table); const CpmlExtents *extents; /* The width depends on the cell content (default = 0) */ size->x = 0; if (title_alignment) { extents = adg_entity_get_extents((AdgEntity *) title_alignment); size->x = extents->size.x; } if (value_alignment) { extents = adg_entity_get_extents((AdgEntity *) value_alignment); if (extents->size.x > size->x) size->x = extents->size.x; } size->x += adg_table_style_get_cell_spacing(table_style)->x * 2; } else { size->x = table_cell->width; } return size; }
/** * adg_table_row_arrange: * @table_row: an #AdgTableRow * @layout: the new extents to use * * Rearranges the underlying #AdgTableCell owned by @table_row using * the new extents provided in @layout. If the x or y size component * of @layout is negative, the value holded by the internal extents * struct is not overriden. * * <note><para> * table_row->extents must be up to date if @layout->size.x or * @layout->size.y is negative in order to have a valid size. * </para></note> * * Returns: (transfer none): the extents of @table_row or <constant>NULL</constant> on errors. * * Since: 1.0 **/ const CpmlExtents * adg_table_row_arrange(AdgTableRow *table_row, const CpmlExtents *layout) { CpmlExtents *extents; CpmlExtents cell_layout; const CpmlExtents *cell_extents; AdgTableStyle *table_style; const CpmlPair *spacing; gdouble xpad; AdgTableCell *cell; GSList *cell_node; g_return_val_if_fail(table_row != NULL, NULL); g_return_val_if_fail(layout != NULL, NULL); g_return_val_if_fail(layout->is_defined, NULL); /* Set the new extents */ extents = &table_row->extents; extents->org = layout->org; if (layout->size.x > 0) extents->size.x = layout->size.x; if (layout->size.y > 0) extents->size.y = layout->size.y; extents->is_defined = TRUE; table_style = (AdgTableStyle *) adg_table_get_table_style(table_row->table); spacing = adg_table_style_get_cell_spacing(table_style); xpad = spacing ? spacing->x : 0; /* Propagate the arrange to the table cells */ cell_layout.org.x = extents->org.x + xpad; cell_layout.org.y = extents->org.y; cell_layout.size.x = -1; cell_layout.size.y = extents->size.y; for (cell_node = table_row->cells; cell_node; cell_node = cell_node->next) { cell = cell_node->data; cell_extents = adg_table_cell_arrange(cell, &cell_layout); cell_layout.org.x += cell_extents->size.x + xpad; } return extents; }
/** * adg_table_row_size_request: * @table_row: a valid #AdgTableRow * * Computes the minimum space needed to properly render @table_row * and updates the size component of the internal #CpmlExtents struct, * returning it to the caller. The returned #CpmlPair is owned by * @table_row and should not be modified or freed. * * Returns: (transfer none): the minimum size required. * * Since: 1.0 **/ const CpmlPair * adg_table_row_size_request(AdgTableRow *table_row) { AdgTableStyle *table_style; const CpmlPair *spacing; gdouble xpad; CpmlExtents *extents; CpmlVector *size; AdgTableCell *cell; GSList *cell_node; const CpmlPair *cell_size; g_return_val_if_fail(table_row != NULL, NULL); table_style = (AdgTableStyle *) adg_table_get_table_style(table_row->table); spacing = adg_table_style_get_cell_spacing(table_style); xpad = spacing ? spacing->x : 0; extents = &table_row->extents; size = &extents->size; size->x = 0; if (table_row->height == 0) size->y = adg_table_style_get_row_height(table_style); else size->y = table_row->height; /* Compute the row width by summing every cell width */ for (cell_node = table_row->cells; cell_node; cell_node = cell_node->next) { cell = cell_node->data; cell_size = adg_table_cell_size_request(cell, extents); size->x += cell_size->x + xpad; } if (size->x > 0) size->x += xpad; return size; }