src/adg/adg-table-cell.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2015  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-table-cell
  23  * @Section_Id:AdgTableCell
  24  * @title: AdgTableCell
  25  * @short_description: A single cell of a table
  26  *
  27  * The #AdgTableCell is a boxed type, the basic component of an
  28  * #AdgTable entity. It must be added to an #AdgTableRow that,
  29  * in cascade, will be added to an #AdgTable entity.
  30  *
  31  * Any cell can be filled with a title and a value: the font to be
  32  * used will be picked up from the #AdgTableStyle got by resolving
  33  * the #AdgTable:table-dress property.
  34  *
  35  * The default title is placed at the upper left corner of the cell
  36  * while the value is centered up to the bottom edge of the cell.
  37  * Anyway the text positioning can be customized by using the
  38  * adg_table_cell_set_value_pos() method.
  39  *
  40  * Some convenient functions to easily create title and value entities
  41  * with plain text are provided: adg_table_cell_new_full(),
  42  * adg_table_cell_set_text_title() and adg_table_cell_set_text_value().
  43  * When using these methods keep in mind the underlying #AdgToyText
  44  * entities will be displaced accordingly to the
  45  * #AdgTableStyle:cell-padding value, not used when setting the
  46  * entities throught other APIs.
  47  *
  48  * Since: 1.0
  49  **/
  50
  51 /**
  52  * AdgTableCell:
  53  *
  54  * An opaque structure referring to the cell of an #AdgTableRow.
  55  * Any row can have an unlimited number of cells.
  56  *
  57  * Since: 1.0
  58  **/
  59
  60
  61 #include "adg-internal.h"
  62 #include "adg-text-internal.h"
  63
  64 #include "adg-container.h"
  65 #include "adg-alignment.h"
  66 #include "adg-textual.h"
  67 #include "adg-style.h"
  68 #include "adg-table-style.h"
  69
  70 #include "adg-table.h"
  71 #include "adg-table-row.h"
  72 #include "adg-table-cell.h"
  73
  74
  75 struct _AdgTableCell {
  76     AdgTableRow   *row;
  77     gdouble        width;
  78     gboolean       has_frame;
  79     AdgEntity     *title;
  80     AdgEntity     *value;
  81     CpmlPair       value_factor;
  82     CpmlExtents    extents;
  83 };
  84
  85
  86 static AdgTableCell *   _adg_cell_new           (void);
  87 static void             _adg_cell_invalidate    (AdgTableCell   *table_cell);
  88 static gboolean         _adg_cell_set_title     (AdgTableCell   *table_cell,
  89                                                  AdgEntity      *title);
  90 static gboolean         _adg_cell_set_value     (AdgTableCell   *table_cell,
  91                                                  AdgEntity      *value);
  92 static void             _adg_cell_set_value_pos (AdgTableCell   *table_cell,
  93                                                  const CpmlPair *from_factor,
  94                                                  const CpmlPair *to_factor);
  95
  96
  97 GType
  98 adg_table_cell_get_type(void)
  99 {
 100     static GType cell_type = 0;
 101
 102     if (G_UNLIKELY(cell_type == 0))
 103         cell_type = g_boxed_type_register_static("AdgTableCell",
 104                                                  (GBoxedCopyFunc) adg_table_cell_dup,
 105                                                  (GBoxedFreeFunc) adg_table_cell_free);
 106
 107     return cell_type;
 108 }
 109
 110
 111 /**
 112  * adg_table_cell_dup:
 113  * @src: an #AdgTableCell structure
 114  *
 115  * Duplicates @src. The returned duplicate should be freed
 116  * with adg_table_cell_free() when no longer needed.
 117  *
 118  * Returns: (transfer full): a duplicate of @src.
 119  *
 120  * Since: 1.0
 121  **/
 122 AdgTableCell *
 123 adg_table_cell_dup(const AdgTableCell *src)
 124 {
 125     g_return_val_if_fail(src != NULL, NULL);
 126     return g_memdup(src, sizeof(AdgTableCell));
 127 }
 128
 129 /**
 130  * adg_table_cell_new:
 131  * @table_row: a valid #AdgTableRow
 132  *
 133  * Creates a new empty cell without a frame and appends it at the
 134  * end of the cells yet present in @table_row. You can add content
 135  * to the cell by using adg_table_cell_set_title() and
 136  * adg_table_cell_set_value() or enable the frame with
 137  * adg_table_cell_switch_frame().
 138  *
 139  * Returns: (transfer full): the newly created cell or <constant>NULL</constant> on errors.
 140  *
 141  * Since: 1.0
 142  **/
 143 AdgTableCell *
 144 adg_table_cell_new(AdgTableRow *table_row)
 145 {
 146     AdgTableCell *table_cell;
 147
 148     g_return_val_if_fail(table_row != NULL, NULL);
 149
 150     table_cell = _adg_cell_new();
 151     table_cell->row = table_row;
 152
 153     adg_table_row_insert(table_row, table_cell, NULL);
 154     _adg_cell_invalidate(table_cell);
 155
 156     return table_cell;
 157 }
 158
 159 /**
 160  * adg_table_cell_new_before:
 161  * @before_cell: a valid #AdgTableCell
 162  *
 163  * Creates a new cell and inserts it rigthly before the @table_cell cell.
 164  *
 165  * Returns: (transfer full): the newly created cell or <constant>NULL</constant> on errors.
 166  *
 167  * Since: 1.0
 168  **/
 169 AdgTableCell *
 170 adg_table_cell_new_before(AdgTableCell *before_cell)
 171 {
 172     AdgTableRow *table_row;
 173     AdgTableCell *table_cell;
 174
 175     g_return_val_if_fail(before_cell != NULL, NULL);
 176
 177     table_row = before_cell->row;
 178     g_return_val_if_fail(table_row != NULL, NULL);
 179
 180     table_cell = _adg_cell_new();
 181     table_cell->row = table_row;
 182
 183     adg_table_row_insert(table_row, table_cell, NULL);
 184     _adg_cell_invalidate(table_cell);
 185
 186     return table_cell;
 187 }
 188
 189 /**
 190  * adg_table_cell_new_with_width:
 191  * @table_row: a valid #AdgTableRow
 192  * @width: the cell width
 193  *
 194  * A convenient wrapper to adg_table_cell_new() that allows to
 195  * specify the @width of @table_row all at once.
 196  *
 197  * Returns: (transfer full): the newly created cell or <constant>NULL</constant> on errors.
 198  *
 199  * Since: 1.0
 200  **/
 201 AdgTableCell *
 202 adg_table_cell_new_with_width(AdgTableRow *table_row, gdouble width)
 203 {
 204     AdgTableCell *table_cell = adg_table_cell_new(table_row);
 205
 206     if (table_cell != NULL)
 207         adg_table_cell_set_width(table_cell, width);
 208
 209     return table_cell;
 210 }
 211
 212 /**
 213  * adg_table_cell_new_full:
 214  * @table_row: a valid #AdgTableRow
 215  * @width: the cell width
 216  * @name: (allow-none): the name to bound to this cell
 217  * @title: (allow-none): the title text
 218  * @has_frame: whether to draw or not the frame
 219  *
 220  * A convenient function to add a cell and specifies some common
 221  * used properties at once.
 222  *
 223  * If @name is <constant>NULL</constant>, the created cell will
 224  * not be a named cell. Check adg_table_set_cell() for further
 225  * details on what a named cell is supposed to be.
 226  *
 227  * @title can be <constant>NULL</constant>, in which case no
 228  * title entity will be created.
 229  *
 230  * Returns: (transfer full): the newly created cell or <constant>NULL</constant> on errors.
 231  *
 232  * Since: 1.0
 233  **/
 234 AdgTableCell *
 235 adg_table_cell_new_full(AdgTableRow *table_row, gdouble width,
 236                         const gchar *name, const gchar *title,
 237                         gboolean has_frame)
 238 {
 239     AdgTableCell *table_cell = adg_table_cell_new(table_row);
 240
 241     if (table_cell == NULL)
 242         return NULL;
 243
 244     adg_table_cell_set_width(table_cell, width);
 245     adg_table_cell_switch_frame(table_cell, has_frame);
 246
 247     if (title) {
 248         adg_table_cell_set_text_title(table_cell, title);
 249     }
 250     if (name) {
 251         AdgTable *table = adg_table_row_get_table(table_row);
 252         adg_table_set_cell(table, name, table_cell);
 253     }
 254
 255     return table_cell;
 256 }
 257
 258 /**
 259  * adg_table_cell_dispose:
 260  * @table_cell: a valid #AdgTableCell struct
 261  *
 262  * Disposes @table_cell.
 263  *
 264  * Since: 1.0
 265  **/
 266 void
 267 adg_table_cell_dispose(AdgTableCell *table_cell)
 268 {
 269     _adg_cell_set_title(table_cell, NULL);
 270     _adg_cell_set_value(table_cell, NULL);
 271 }
 272
 273 /**
 274  * adg_table_cell_free:
 275  * @table_cell: an #AdgTableCell structure
 276  *
 277  * Releases all the memory allocated by @table_cell, itself included.
 278  *
 279  * Since: 1.0
 280  **/
 281 void
 282 adg_table_cell_free(AdgTableCell *table_cell)
 283 {
 284     AdgTableRow *table_row = table_cell->row;
 285
 286     if (table_cell->row != NULL) {
 287         AdgTable *table = adg_table_row_get_table(table_row);
 288         adg_table_row_remove(table_row, table_cell);
 289         if (table)
 290             adg_table_set_cell(table, NULL, table_cell);
 291     }
 292
 293     adg_table_cell_dispose(table_cell);
 294     g_free(table_cell);
 295 }
 296
 297 /**
 298  * adg_table_cell_get_row:
 299  * @table_cell: a valid #AdgTableCell
 300  *
 301  * Gets the row container of @table_cell. The returned #AdgTableRow
 302  * is owned by @table_cell and must not be modified or freed.
 303  *
 304  * Returns: (transfer none): the container row.
 305  *
 306  * Since: 1.0
 307  **/
 308 AdgTableRow *
 309 adg_table_cell_get_row(AdgTableCell *table_cell)
 310 {
 311     g_return_val_if_fail(table_cell != NULL, NULL);
 312     return table_cell->row;
 313 }
 314
 315 /**
 316  * adg_table_cell_get_table:
 317  * @table_cell: a valid #AdgTableCell
 318  *
 319  * A convenient function that gets the table that contains
 320  * @table_cell. The returned #AdgTable is owned by @table_cell
 321  * and must not be modified or freed.
 322  *
 323  * Returns: (transfer none): the container table.
 324  *
 325  * Since: 1.0
 326  **/
 327 AdgTable *
 328 adg_table_cell_get_table(AdgTableCell *table_cell)
 329 {
 330     AdgTableRow *table_row = adg_table_cell_get_row(table_cell);
 331     if (table_row == NULL)
 332         return NULL;
 333
 334     return adg_table_row_get_table(table_row);
 335 }
 336
 337 /**
 338  * adg_table_cell_set_title:
 339  * @table_cell: a valid #AdgTableCell
 340  * @title: the new title entity
 341  *
 342  * Sets @title as the new title entity of @table_cell. The top left
 343  * corner of the bounding box of @title will be cohincident to
 344  * the top left corner of the cell extents, taking into accounts
 345  * eventual padding spaces specified by the table style.
 346  *
 347  * The old internal entity is unrefenrenced while the @title (if
 348  * not <constant>NULL</constant>) is refenenced with
 349  * g_object_ref_sink().
 350  *
 351  * @title can be <constant>NULL</constant>, in which case the old
 352  * entity is removed.
 353  *
 354  * Since: 1.0
 355  **/
 356 void
 357 adg_table_cell_set_title(AdgTableCell *table_cell, AdgEntity *title)
 358 {
 359     g_return_if_fail(table_cell != NULL);
 360     g_return_if_fail(title == NULL || ADG_IS_ENTITY(title));
 361
 362     if (_adg_cell_set_title(table_cell, title))
 363         _adg_cell_invalidate(table_cell);
 364 }
 365
 366 /**
 367  * adg_table_cell_set_text_title:
 368  * @table_cell: a valid #AdgTableCell
 369  * @title: a text string
 370  *
 371  * Convenient function to set a the title of a cell using an #AdgToyText
 372  * entity with the font dress picked from #AdgTable:table-dress with
 373  * a call to adg_table_style_get_title_dress().
 374  *
 375  * Since: 1.0
 376  **/
 377 void
 378 adg_table_cell_set_text_title(AdgTableCell *table_cell, const gchar *title)
 379 {
 380     AdgTable *table;
 381     AdgEntity *entity;
 382     AdgTableStyle *table_style;
 383     const CpmlPair *padding;
 384     AdgDress table_dress, font_dress;
 385     cairo_matrix_t map;
 386
 387     g_return_if_fail(table_cell != NULL);
 388
 389     if (title == NULL)
 390         adg_table_cell_set_title(table_cell, NULL);
 391
 392     if (table_cell->title) {
 393         gchar *old_title;
 394         gboolean unchanged;
 395
 396         if (ADG_IS_TEXTUAL(table_cell->title))
 397             old_title = adg_textual_dup_text((AdgTextual *) table_cell->title);
 398         else
 399             old_title = NULL;
 400
 401         unchanged = g_strcmp0(title, old_title) == 0;
 402         g_free(old_title);
 403
 404         if (unchanged)
 405             return;
 406     }
 407
 408     table = adg_table_cell_get_table(table_cell);
 409     table_dress = adg_table_get_table_dress(table);
 410     table_style = (AdgTableStyle *) adg_entity_style((AdgEntity *) table,
 411                                                      table_dress);
 412     padding = adg_table_style_get_cell_padding(table_style);
 413     font_dress = adg_table_style_get_title_dress(table_style);
 414     entity = g_object_new(ADG_TYPE_BEST_TEXT, "text", title,
 415                           "font-dress", font_dress, NULL);
 416
 417     cairo_matrix_init_translate(&map, padding->x, padding->y);
 418     adg_entity_set_global_map(entity, &map);
 419
 420     adg_table_cell_set_title(table_cell, entity);
 421 }
 422
 423 /**
 424  * adg_table_cell_title:
 425  * @table_cell: a valid #AdgTableCell
 426  *
 427  * Gets the current title of @table_cell. The returned string is owned
 428  * by @table_cell and must not be modified or freed.
 429  *
 430  * Returns: (transfer none): the title entity or <constant>NULL</constant> for undefined title.
 431  *
 432  * Since: 1.0
 433  **/
 434 AdgEntity *
 435 adg_table_cell_title(AdgTableCell *table_cell)
 436 {
 437     g_return_val_if_fail(table_cell != NULL, NULL);
 438
 439     return table_cell->title;
 440 }
 441
 442 /**
 443  * adg_table_cell_set_value:
 444  * @table_cell: a valid #AdgTableCell
 445  * @value: the new value entity
 446  *
 447  * Sets @value as the new value entity of @table_cell. The bottom middle
 448  * point of the bounding box of @value will be cohincident to the
 449  * bottom middle point of the cell extents, taking into accounts
 450  * eventual padding spaces specified by the table style.
 451  *
 452  * The old internal entity is unrefenrenced while the @value (if
 453  * not <constant>NULL</constant>) is referenced with
 454  * g_object_ref_sink().
 455  *
 456  * @value can be <constant>NULL</constant>, in which case the old entity is removed.
 457  *
 458  * Since: 1.0
 459  **/
 460 void
 461 adg_table_cell_set_value(AdgTableCell *table_cell, AdgEntity *value)
 462 {
 463     g_return_if_fail(table_cell != NULL);
 464     g_return_if_fail(value == NULL || ADG_IS_ENTITY(value));
 465
 466     if (_adg_cell_set_value(table_cell, value))
 467         _adg_cell_invalidate(table_cell);
 468 }
 469
 470 /**
 471  * adg_table_cell_set_text_value:
 472  * @table_cell: a valid #AdgTableCell
 473  * @value: a text string
 474  *
 475  * Convenient function to set a the value of a cell using an #AdgToyText
 476  * entity with a value font dress picked from #AdgTable:table-dress with
 477  * a call to adg_table_style_get_value_dress().
 478  *
 479  * Since: 1.0
 480  **/
 481 void
 482 adg_table_cell_set_text_value(AdgTableCell *table_cell, const gchar *value)
 483 {
 484     AdgTable *table;
 485     AdgEntity *entity;
 486     AdgTableStyle *table_style;
 487     const CpmlPair *padding;
 488     AdgDress table_dress, font_dress;
 489     cairo_matrix_t map;
 490
 491     g_return_if_fail(table_cell != NULL);
 492
 493     if (value == NULL)
 494         adg_table_cell_set_value(table_cell, NULL);
 495
 496     if (table_cell->value) {
 497         gchar *old_value;
 498         gboolean unchanged;
 499
 500         if (ADG_IS_TEXTUAL(table_cell->value))
 501             old_value = adg_textual_dup_text((AdgTextual *) table_cell->value);
 502         else
 503             old_value = NULL;
 504
 505         unchanged = g_strcmp0(value, old_value) == 0;
 506         g_free(old_value);
 507         if (unchanged)
 508             return;
 509     }
 510
 511     table = adg_table_cell_get_table(table_cell);
 512     table_dress = adg_table_get_table_dress(table);
 513     table_style = (AdgTableStyle *) adg_entity_style((AdgEntity *) table,
 514                                                      table_dress);
 515     padding = adg_table_style_get_cell_padding(table_style);
 516     font_dress = adg_table_style_get_value_dress(table_style);
 517     entity = g_object_new(ADG_TYPE_BEST_TEXT, "text", value,
 518                           "font-dress", font_dress, NULL);
 519
 520     cairo_matrix_init_translate(&map, 0, -padding->y);
 521     adg_entity_set_global_map(entity, &map);
 522
 523     adg_table_cell_set_value(table_cell, entity);
 524 }
 525
 526 /**
 527  * adg_table_cell_value:
 528  * @table_cell: a valid #AdgTableCell
 529  *
 530  * Gets the current value of @table_cell. The returned string is owned
 531  * by @table_cell and must not be modified or freed.
 532  *
 533  * Returns: (transfer none): the value entity or <constant>NULL</constant> for undefined value.
 534  *
 535  * Since: 1.0
 536  **/
 537 AdgEntity *
 538 adg_table_cell_value(AdgTableCell *table_cell)
 539 {
 540     g_return_val_if_fail(table_cell != NULL, NULL);
 541
 542     return table_cell->value;
 543 }
 544
 545 /**
 546  * adg_table_cell_set_value_pos:
 547  * @table_cell: a valid #AdgTableCell
 548  * @from_factor: the alignment factor on the value entity
 549  * @to_factor: the alignment factor on the cell
 550  *
 551  * Sets a new custom position for the value entity of @table_cell. The
 552  * @from_factor specifies the source point (as a fraction of the
 553  * value extents) while the @to_factor is the destination point
 554  * (specified as a fraction of the cell extents) the source point
 555  * must be moved to.
 556  *
 557  * Since: 1.0
 558  **/
 559 void
 560 adg_table_cell_set_value_pos(AdgTableCell *table_cell,
 561                              const CpmlPair *from_factor,
 562                              const CpmlPair *to_factor)
 563 {
 564     g_return_if_fail(table_cell != NULL);
 565     _adg_cell_set_value_pos(table_cell, from_factor, to_factor);
 566 }
 567
 568 /**
 569  * adg_table_cell_set_value_pos_explicit:
 570  * @table_cell: a valid #AdgTableCell
 571  * @from_x: the x alignment factor on the entity
 572  * @from_y: the y alignment factor on the entity
 573  * @to_x: the x alignment factor on the cell
 574  * @to_y: the y alignment factor on the cell
 575  *
 576  * A convenient wrapper around adg_table_cell_set_value_pos()
 577  * that uses explicit factors instead of #CpmlPair.
 578  *
 579  * Since: 1.0
 580  **/
 581 void
 582 adg_table_cell_set_value_pos_explicit(AdgTableCell *table_cell,
 583                                       gdouble from_x, gdouble from_y,
 584                                       gdouble to_x, gdouble to_y)
 585 {
 586     CpmlPair from, to;
 587
 588     from.x = from_x;
 589     from.y = from_y;
 590     to.x = to_x;
 591     to.y = to_y;
 592
 593     adg_table_cell_set_value_pos(table_cell, &from, &to);
 594 }
 595
 596 /**
 597  * adg_table_cell_set_width:
 598  * @table_cell: a valid #AdgTableCell
 599  * @width: the new width
 600  *
 601  * Sets a new width on @table_cell. The extents on the whole table
 602  * will be invalidated, so will be recomputed in the next
 603  * arrange() phase.
 604  *
 605  * A positive @width value specifies the width of this cell in global
 606  * space: if the width of its content (that is, either the title or the
 607  * value entity) will be greater than @width, it will be rendered
 608  * outside the cell boundary box, luckely overwriting the adiacent
 609  * cells.
 610  *
 611  * Using 0 as @width means the width of the cell will be automatically
 612  * adjusted to the maximum width of its content.
 613  *
 614  * Negative width values are not allowed: this condition will raise
 615  * a warning without any further processing.
 616  *
 617  * Since: 1.0
 618  **/
 619 void
 620 adg_table_cell_set_width(AdgTableCell *table_cell, gdouble width)
 621 {
 622     g_return_if_fail(table_cell != NULL);
 623     g_return_if_fail(width >= 0);
 624
 625     if (table_cell->width != width) {
 626         table_cell->width = width;
 627         _adg_cell_invalidate(table_cell);
 628     }
 629 }
 630
 631 /**
 632  * adg_table_cell_get_width:
 633  * @table_cell: a valid #AdgTableCell
 634  *
 635  * Gets the width of @table_cell.
 636  *
 637  * Returns: the requested width or 0 on errors.
 638  *
 639  * Since: 1.0
 640  **/
 641 gdouble
 642 adg_table_cell_get_width(AdgTableCell *table_cell)
 643 {
 644     g_return_val_if_fail(table_cell != NULL, 0.);
 645
 646     return table_cell->width;
 647 }
 648
 649 /**
 650  * adg_table_cell_switch_frame:
 651  * @table_cell: a valid #AdgTableCell
 652  * @has_frame: whether to draw or not the frame
 653  *
 654  * Sets the frame flag of @table_cell: if @has_frame is
 655  * <constant>TRUE</constant>, a frame around @table_cell
 656  * will be rendered using the #AdgTableStyle:frame-dress
 657  * dress of the table style.
 658  *
 659  * Since: 1.0
 660  **/
 661 void
 662 adg_table_cell_switch_frame(AdgTableCell *table_cell, gboolean has_frame)
 663 {
 664     g_return_if_fail(table_cell != NULL);
 665
 666     if (table_cell->has_frame != has_frame) {
 667         AdgTable *table = adg_table_cell_get_table(table_cell);
 668         table_cell->has_frame = has_frame;
 669         adg_table_invalidate_grid(table);
 670     }
 671 }
 672
 673 /**
 674  * adg_table_cell_has_frame:
 675  * @table_cell: a valid #AdgTableCell
 676  *
 677  * Gets the frame flag of @table_cell.
 678  *
 679  * Returns: the frame flag.
 680  *
 681  * Since: 1.0
 682  **/
 683 gboolean
 684 adg_table_cell_has_frame(AdgTableCell *table_cell)
 685 {
 686     g_return_val_if_fail(table_cell != NULL, FALSE);
 687
 688     return table_cell->has_frame;
 689 }
 690
 691 /**
 692  * adg_table_cell_get_extents:
 693  * @table_cell: a valid #AdgTableCell
 694  *
 695  * Gets the extents of @table_cell. This function is useful only after the
 696  * arrange() phase as in the other situation the extents will likely
 697  * be not up to date.
 698  *
 699  * Returns: the extents of @table_cell or <constant>NULL</constant> on errors.
 700  *
 701  * Since: 1.0
 702  **/
 703 const CpmlExtents *
 704 adg_table_cell_get_extents(AdgTableCell *table_cell)
 705 {
 706     g_return_val_if_fail(table_cell != NULL, NULL);
 707
 708     return &table_cell->extents;
 709 }
 710
 711 /**
 712  * adg_table_cell_size_request:
 713  * @table_cell: a valid #AdgTableCell
 714  * @row_extents: the extents of the container #AdgTableRow
 715  *
 716  * Computes the minimum space needed to properly render @table_cell
 717  * and updates the size component of the internal #CpmlExtents struct,
 718  * returning it to the caller. The returned #CpmlPair is owned by
 719  * @table_cell and should not be modified or freed.
 720  *
 721  * Returns: (transfer none): the minimum size required.
 722  *
 723  * Since: 1.0
 724  **/
 725 const CpmlPair *
 726 adg_table_cell_size_request(AdgTableCell *table_cell,
 727                             const CpmlExtents *row_extents)
 728 {
 729     CpmlVector *size;
 730     AdgAlignment *title_alignment;
 731     AdgAlignment *value_alignment;
 732     AdgTable *table;
 733
 734     size = &table_cell->extents.size;
 735
 736     if (table_cell->title) {
 737         title_alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->title);
 738         adg_entity_arrange((AdgEntity *) title_alignment);
 739     } else {
 740         title_alignment = NULL;
 741     }
 742
 743     if (table_cell->value) {
 744         value_alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->value);
 745         adg_entity_arrange((AdgEntity *) value_alignment);
 746     } else {
 747         value_alignment = NULL;
 748     }
 749
 750     table = adg_table_cell_get_table(table_cell);
 751     size->y = row_extents->size.y;
 752
 753     if (table_cell->width == 0) {
 754         AdgTableStyle *table_style = (AdgTableStyle *) adg_table_get_table_style(table);
 755         const CpmlExtents *extents;
 756
 757         /* The width depends on the cell content (default = 0) */
 758         size->x = 0;
 759
 760         if (title_alignment) {
 761             extents = adg_entity_get_extents((AdgEntity *) title_alignment);
 762             size->x = extents->size.x;
 763         }
 764
 765         if (value_alignment) {
 766             extents = adg_entity_get_extents((AdgEntity *) value_alignment);
 767             if (extents->size.x > size->x)
 768                 size->x = extents->size.x;
 769         }
 770
 771         size->x += adg_table_style_get_cell_spacing(table_style)->x * 2;
 772     } else {
 773         size->x = table_cell->width;
 774     }
 775
 776     return size;
 777 }
 778
 779 /**
 780  * adg_table_cell_arrange:
 781  * @table_cell: an #AdgTableCell
 782  * @layout: the new extents to use
 783  *
 784  * Rearranges the underlying #AdgTableCell owned by @table_cell using
 785  * the new extents provided in @layout. If the x or y size component
 786  * of @layout is negative, the value holded by the internal extents
 787  * struct is not overriden.
 788  *
 789  * <note><para>
 790  * table_cell->extents must be up to date if @layout->size.x or
 791  * @layout->size.y is negative in order to have a valid size.
 792  * </para></note>
 793  *
 794  * Returns: the extents of @table_cell or <constant>NULL</constant> on errors.
 795  *
 796  * Since: 1.0
 797  **/
 798 const CpmlExtents *
 799 adg_table_cell_arrange(AdgTableCell *table_cell, const CpmlExtents *layout)
 800 {
 801     CpmlExtents *extents;
 802     AdgAlignment *alignment;
 803     cairo_matrix_t map;
 804
 805     /* Set the new extents */
 806     extents = &table_cell->extents;
 807     extents->org = layout->org;
 808     if (layout->size.x > 0)
 809         extents->size.x = layout->size.x;
 810     if (layout->size.y > 0)
 811         extents->size.y = layout->size.y;
 812     extents->is_defined = TRUE;
 813
 814     if (table_cell->title) {
 815         alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->title);
 816
 817         cairo_matrix_init_translate(&map, extents->org.x, extents->org.y);
 818         adg_entity_set_global_map((AdgEntity *) alignment, &map);
 819     }
 820
 821     if (table_cell->value) {
 822         CpmlPair to;
 823
 824         alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->value);
 825         to.x = extents->size.x * table_cell->value_factor.x + extents->org.x;
 826         to.y = extents->size.y * table_cell->value_factor.y + extents->org.y;
 827
 828         cairo_matrix_init_translate(&map, to.x, to.y);
 829         adg_entity_set_global_map((AdgEntity *) alignment, &map);
 830     }
 831
 832     return extents;
 833 }
 834
 835
 836 static AdgTableCell *
 837 _adg_cell_new(void)
 838 {
 839     AdgTableCell *table_cell;
 840
 841     table_cell = g_new(AdgTableCell, 1);
 842     table_cell->row = NULL;
 843     table_cell->width = 0.;
 844     table_cell->has_frame = FALSE;
 845     table_cell->title = NULL;
 846     table_cell->value = NULL;
 847     table_cell->extents.is_defined = FALSE;
 848     table_cell->value_factor.x = 0.5;
 849     table_cell->value_factor.y = 1;
 850
 851     return table_cell;
 852 }
 853
 854 static void
 855 _adg_cell_invalidate(AdgTableCell *table_cell)
 856 {
 857     AdgTable *table = adg_table_cell_get_table(table_cell);
 858
 859     if (table)
 860         adg_entity_invalidate((AdgEntity *) table);
 861 }
 862
 863 static gboolean
 864 _adg_cell_set_title(AdgTableCell *table_cell, AdgEntity *title)
 865 {
 866     AdgEntity *alignment;
 867
 868     if (table_cell->title == title)
 869         return FALSE;
 870
 871     if (table_cell->title) {
 872         alignment = adg_entity_get_parent(table_cell->title);
 873         g_object_unref(alignment);
 874     }
 875
 876     table_cell->title = title;
 877
 878     if (title) {
 879         AdgEntity *table = (AdgEntity *) adg_table_cell_get_table(table_cell);
 880         alignment = (AdgEntity *) adg_alignment_new_explicit(0, -1);
 881         g_object_ref_sink(alignment);
 882         adg_entity_set_parent(alignment, table);
 883         adg_container_add((AdgContainer *) alignment, title);
 884     }
 885
 886     return TRUE;
 887 }
 888
 889 static gboolean
 890 _adg_cell_set_value(AdgTableCell *table_cell, AdgEntity *value)
 891 {
 892     AdgEntity *alignment;
 893
 894     if (table_cell->value == value)
 895         return FALSE;
 896
 897     if (value) {
 898         AdgEntity *table = (AdgEntity *) adg_table_cell_get_table(table_cell);
 899         alignment = (AdgEntity *) adg_alignment_new_explicit(0.5, 0);
 900         g_object_ref_sink(alignment);
 901         adg_entity_set_parent(alignment, table);
 902         adg_container_add((AdgContainer *) alignment, value);
 903     }
 904
 905     if (table_cell->value) {
 906         alignment = adg_entity_get_parent(table_cell->value);
 907         adg_container_remove((AdgContainer *) alignment, table_cell->value);
 908         g_object_unref(alignment);
 909     }
 910
 911     table_cell->value = value;
 912     return TRUE;
 913 }
 914
 915 static void
 916 _adg_cell_set_value_pos(AdgTableCell *table_cell,
 917                         const CpmlPair *from_factor, const CpmlPair *to_factor)
 918 {
 919     AdgAlignment *alignment;
 920
 921     if (table_cell->value == NULL)
 922         return;
 923
 924     alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->value);
 925
 926     if (from_factor)
 927         adg_alignment_set_factor(alignment, from_factor);
 928
 929     if (to_factor)
 930         table_cell->value_factor = *to_factor;
 931 }