src/adg/adg-table-style.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010  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-style
  23  * @short_description: Customization of table rendering
  24  *
  25  * Contains parameters on how to build tables such as the lines to
  26  * use for frames and grids and the font dresses for titles or values.
  27  */
  28
  29 /**
  30  * AdgTableStyle:
  31  *
  32  * All fields are private and should not be used directly.
  33  * Use its public methods instead.
  34  **/
  35
  36
  37 #include "adg-internal.h"
  38 #include "adg-table-style.h"
  39 #include "adg-table-style-private.h"
  40 #include "adg-dress-builtins.h"
  41 #include "adg-font-style.h"
  42 #include "adg-line-style.h"
  43 #include "adg-util.h"
  44
  45
  46 enum {
  47     PROP_0,
  48     PROP_COLOR_DRESS,
  49     PROP_GRID_DRESS,
  50     PROP_FRAME_DRESS,
  51     PROP_TITLE_DRESS,
  52     PROP_VALUE_DRESS,
  53     PROP_ROW_HEIGHT,
  54     PROP_CELL_PADDING,
  55     PROP_CELL_SPACING
  56 };
  57
  58
  59 static void             get_property            (GObject        *object,
  60                                                  guint           prop_id,
  61                                                  GValue         *value,
  62                                                  GParamSpec     *pspec);
  63 static void             set_property            (GObject        *object,
  64                                                  guint           prop_id,
  65                                                  const GValue   *value,
  66                                                  GParamSpec     *pspec);
  67 static void             apply                   (AdgStyle       *style,
  68                                                  AdgEntity      *entity,
  69                                                  cairo_t        *cr);
  70 static gboolean         set_row_height          (AdgTableStyle  *table_style,
  71                                                  gdouble         height);
  72 static gboolean         set_cell_padding        (AdgTableStyle  *table_style,
  73                                                  const AdgPair  *padding);
  74 static gboolean         set_cell_spacing        (AdgTableStyle  *table_style,
  75                                                  const AdgPair  *spacing);
  76
  77
  78 G_DEFINE_TYPE(AdgTableStyle, adg_table_style, ADG_TYPE_STYLE);
  79
  80
  81 static void
  82 adg_table_style_class_init(AdgTableStyleClass *klass)
  83 {
  84     GObjectClass *gobject_class;
  85     AdgStyleClass *style_class;
  86     GParamSpec *param;
  87
  88     gobject_class = (GObjectClass *) klass;
  89     style_class = (AdgStyleClass *) klass;
  90
  91     g_type_class_add_private(klass, sizeof(AdgTableStylePrivate));
  92
  93     gobject_class->get_property = get_property;
  94     gobject_class->set_property = set_property;
  95
  96     style_class->apply = apply;
  97
  98     param = adg_param_spec_dress("color-dress",
  99                                  P_("Color Dress"),
 100                                  P_("Color dress for the whole tableension"),
 101                                  ADG_DRESS_COLOR_TABLE,
 102                                  G_PARAM_READWRITE);
 103     g_object_class_install_property(gobject_class, PROP_COLOR_DRESS, param);
 104
 105     param = adg_param_spec_dress("grid-dress",
 106                                  P_("Grid Dress"),
 107                                  P_("Line dress to use while rendering the grid of the table"),
 108                                  ADG_DRESS_LINE_TABLE,
 109                                  G_PARAM_READWRITE);
 110     g_object_class_install_property(gobject_class, PROP_GRID_DRESS, param);
 111
 112     param = adg_param_spec_dress("frame-dress",
 113                                  P_("Frame Dress"),
 114                                  P_("Line dress to use while drawing the table frame"),
 115                                  ADG_DRESS_LINE_TABLE,
 116                                  G_PARAM_READWRITE);
 117     g_object_class_install_property(gobject_class, PROP_FRAME_DRESS, param);
 118
 119     param = adg_param_spec_dress("title-dress",
 120                                  P_("Title Dress"),
 121                                  P_("Font dress to use for titles"),
 122                                  ADG_DRESS_TEXT_LIMIT,
 123                                  G_PARAM_READWRITE);
 124     g_object_class_install_property(gobject_class, PROP_TITLE_DRESS, param);
 125
 126     param = adg_param_spec_dress("value-dress",
 127                                  P_("Value Dress"),
 128                                  P_("Font dress to use for values inside the cells"),
 129                                  ADG_DRESS_TEXT_VALUE,
 130                                  G_PARAM_READWRITE);
 131     g_object_class_install_property(gobject_class, PROP_VALUE_DRESS, param);
 132
 133     param = g_param_spec_double("row-height",
 134                                 P_("Row Height"),
 135                                 P_("The fallback row height when not explicitely specified while creating a new row"),
 136                                 0, G_MAXDOUBLE, 30,
 137                                 G_PARAM_READWRITE);
 138     g_object_class_install_property(gobject_class, PROP_ROW_HEIGHT, param);
 139
 140     param = g_param_spec_boxed("cell-padding",
 141                                P_("Cell Padding"),
 142                                P_("How much space from the bounding box must left inside every cell"),
 143                                ADG_TYPE_PAIR,
 144                                G_PARAM_READWRITE);
 145     g_object_class_install_property(gobject_class, PROP_CELL_PADDING, param);
 146
 147     param = g_param_spec_boxed("cell-spacing",
 148                                P_("Cell Spacing"),
 149                                P_("How much space to left between the cells"),
 150                                ADG_TYPE_PAIR,
 151                                G_PARAM_READWRITE);
 152     g_object_class_install_property(gobject_class, PROP_CELL_SPACING, param);
 153 }
 154
 155 static void
 156 adg_table_style_init(AdgTableStyle *table_style)
 157 {
 158     AdgTableStylePrivate *data;
 159
 160     data = G_TYPE_INSTANCE_GET_PRIVATE(table_style, ADG_TYPE_TABLE_STYLE,
 161                                        AdgTableStylePrivate);
 162
 163     data->color_dress = ADG_DRESS_COLOR_TABLE,
 164     data->grid_dress = ADG_DRESS_LINE_TABLE;
 165     data->frame_dress = ADG_DRESS_LINE_TABLE;
 166     data->title_dress = ADG_DRESS_TEXT_LIMIT;
 167     data->value_dress = ADG_DRESS_TEXT_VALUE;
 168     data->row_height = 30;
 169     data->cell_padding.x = 5;
 170     data->cell_padding.y = 5;
 171     data->cell_spacing.x = 0;
 172     data->cell_spacing.y = 0;
 173
 174     table_style->data = data;
 175 }
 176
 177 static void
 178 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 179 {
 180     AdgTableStylePrivate *data = ((AdgTableStyle *) object)->data;
 181
 182     switch (prop_id) {
 183     case PROP_COLOR_DRESS:
 184         g_value_set_int(value, data->color_dress);
 185         break;
 186     case PROP_GRID_DRESS:
 187         g_value_set_int(value, data->grid_dress);
 188         break;
 189     case PROP_FRAME_DRESS:
 190         g_value_set_int(value, data->frame_dress);
 191         break;
 192     case PROP_TITLE_DRESS:
 193         g_value_set_int(value, data->title_dress);
 194         break;
 195     case PROP_VALUE_DRESS:
 196         g_value_set_int(value, data->value_dress);
 197         break;
 198     case PROP_ROW_HEIGHT:
 199         g_value_set_double(value, data->row_height);
 200         break;
 201     case PROP_CELL_PADDING:
 202         g_value_set_boxed(value, &data->cell_padding);
 203         break;
 204     case PROP_CELL_SPACING:
 205         g_value_set_boxed(value, &data->cell_spacing);
 206         break;
 207     default:
 208         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 209         break;
 210     }
 211 }
 212
 213 static void
 214 set_property(GObject *object, guint prop_id,
 215              const GValue *value, GParamSpec *pspec)
 216 {
 217     AdgTableStyle *table_style;
 218     AdgTableStylePrivate *data;
 219
 220     table_style = (AdgTableStyle *) object;
 221     data = table_style->data;
 222
 223     switch (prop_id) {
 224     case PROP_COLOR_DRESS:
 225         adg_dress_set(&data->color_dress, g_value_get_int(value));
 226         break;
 227     case PROP_GRID_DRESS:
 228         adg_dress_set(&data->grid_dress, g_value_get_int(value));
 229         break;
 230     case PROP_FRAME_DRESS:
 231         adg_dress_set(&data->frame_dress, g_value_get_int(value));
 232         break;
 233     case PROP_TITLE_DRESS:
 234         adg_dress_set(&data->title_dress, g_value_get_int(value));
 235         break;
 236     case PROP_VALUE_DRESS:
 237         adg_dress_set(&data->value_dress, g_value_get_int(value));
 238         break;
 239     case PROP_ROW_HEIGHT:
 240         set_row_height(table_style, g_value_get_double(value));
 241         break;
 242     case PROP_CELL_PADDING:
 243         set_cell_padding(table_style, g_value_get_boxed(value));
 244         break;
 245     case PROP_CELL_SPACING:
 246         set_cell_spacing(table_style, g_value_get_boxed(value));
 247         break;
 248     default:
 249         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 250         break;
 251     }
 252 }
 253
 254
 255 /**
 256  * adg_table_style_new:
 257  *
 258  * Constructs a new empty table style initialized with default params.
 259  *
 260  * Returns: a new table style
 261  **/
 262 AdgTableStyle *
 263 adg_table_style_new(void)
 264 {
 265     return g_object_new(ADG_TYPE_TABLE_STYLE, NULL);
 266 }
 267
 268 /**
 269  * adg_table_style_set_color_dress:
 270  * @table_style: an #AdgTableStyle object
 271  * @dress: the new color dress
 272  *
 273  * Sets a new color dress on @table_style.
 274  **/
 275 void
 276 adg_table_style_set_color_dress(AdgTableStyle *table_style, AdgDress dress)
 277 {
 278     AdgTableStylePrivate *data;
 279
 280     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 281
 282     data = table_style->data;
 283
 284     if (adg_dress_set(&data->color_dress, dress))
 285         g_object_notify((GObject *) table_style, "color-dress");
 286 }
 287
 288 /**
 289  * adg_table_style_get_color_dress:
 290  * @table_style: an #AdgTableStyle object
 291  *
 292  * Gets the @table_style color dress to be used. This dress should be
 293  * intended as a fallback color as it could be overriden by more
 294  * specific dresses, such as a color explicitely specified on the
 295  * #AdgTableStyle:value-dress.
 296  *
 297  * Returns: the color dress
 298  **/
 299 AdgDress
 300 adg_table_style_get_color_dress(AdgTableStyle *table_style)
 301 {
 302     AdgTableStylePrivate *data;
 303
 304     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), ADG_DRESS_UNDEFINED);
 305
 306     data = table_style->data;
 307
 308     return data->color_dress;
 309 }
 310
 311 /**
 312  * adg_table_style_set_frame_dress:
 313  * @table_style: an #AdgTableStyle object
 314  * @dress: the new line dress
 315  *
 316  * Sets a new line dress on @table_style for rendering the frames.
 317  **/
 318 void
 319 adg_table_style_set_frame_dress(AdgTableStyle *table_style, AdgDress dress)
 320 {
 321     AdgTableStylePrivate *data;
 322
 323     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 324
 325     data = table_style->data;
 326
 327     if (adg_dress_set(&data->frame_dress, dress))
 328         g_object_notify((GObject *) table_style, "frame-dress");
 329 }
 330
 331 /**
 332  * adg_table_style_get_frame_dress:
 333  * @table_style: an #AdgTableStyle object
 334  *
 335  * Gets the line dress to be used for rendering the frames with
 336  * @table_style.
 337  *
 338  * Returns: the line dress
 339  **/
 340 AdgDress
 341 adg_table_style_get_frame_dress(AdgTableStyle *table_style)
 342 {
 343     AdgTableStylePrivate *data;
 344
 345     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), ADG_DRESS_UNDEFINED);
 346
 347     data = table_style->data;
 348
 349     return data->frame_dress;
 350 }
 351
 352 /**
 353  * adg_table_style_set_grid_dress:
 354  * @table_style: an #AdgTableStyle object
 355  * @dress: the new line dress
 356  *
 357  * Sets a new line dress on @table_style for rendering the grids.
 358  **/
 359 void
 360 adg_table_style_set_grid_dress(AdgTableStyle *table_style, AdgDress dress)
 361 {
 362     AdgTableStylePrivate *data;
 363
 364     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 365
 366     data = table_style->data;
 367
 368     if (adg_dress_set(&data->grid_dress, dress))
 369         g_object_notify((GObject *) table_style, "grid-dress");
 370 }
 371
 372 /**
 373  * adg_table_style_get_grid_dress:
 374  * @table_style: an #AdgTableStyle object
 375  *
 376  * Gets the line dress to be used for rendering the grids with
 377  * @table_style.
 378  *
 379  * Returns: the line dress
 380  **/
 381 AdgDress
 382 adg_table_style_get_grid_dress(AdgTableStyle *table_style)
 383 {
 384     AdgTableStylePrivate *data;
 385
 386     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), ADG_DRESS_UNDEFINED);
 387
 388     data = table_style->data;
 389
 390     return data->grid_dress;
 391 }
 392
 393 /**
 394  * adg_table_style_set_title_dress:
 395  * @table_style: an #AdgTableStyle object
 396  * @dress: the new font dress
 397  *
 398  * Sets a new font dress on @table_style for rendering cell titles.
 399  **/
 400 void
 401 adg_table_style_set_title_dress(AdgTableStyle *table_style, AdgDress dress)
 402 {
 403     AdgTableStylePrivate *data;
 404
 405     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 406
 407     data = table_style->data;
 408
 409     if (adg_dress_set(&data->title_dress, dress))
 410         g_object_notify((GObject *) table_style, "title-dress");
 411 }
 412
 413 /**
 414  * adg_table_style_get_title_dress:
 415  * @table_style: an #AdgTableStyle object
 416  *
 417  * Gets the font dress to be used for rendering cell titles
 418  * with @table_style.
 419  *
 420  * Returns: the font dress
 421  **/
 422 AdgDress
 423 adg_table_style_get_title_dress(AdgTableStyle *table_style)
 424 {
 425     AdgTableStylePrivate *data;
 426
 427     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), ADG_DRESS_UNDEFINED);
 428
 429     data = table_style->data;
 430
 431     return data->title_dress;
 432 }
 433
 434 /**
 435  * adg_table_style_set_value_dress:
 436  * @table_style: an #AdgTableStyle object
 437  * @dress: the new font dress
 438  *
 439  * Sets a new font dress on @table_style for rendering cell values.
 440  **/
 441 void
 442 adg_table_style_set_value_dress(AdgTableStyle *table_style, AdgDress dress)
 443 {
 444     AdgTableStylePrivate *data;
 445
 446     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 447
 448     data = table_style->data;
 449
 450     if (adg_dress_set(&data->value_dress, dress))
 451         g_object_notify((GObject *) table_style, "value-dress");
 452 }
 453
 454 /**
 455  * adg_table_style_get_value_dress:
 456  * @table_style: an #AdgTableStyle object
 457  *
 458  * Gets the font dress to be used for rendering cell values
 459  * with @table_style.
 460  *
 461  * Returns: the font dress
 462  **/
 463 AdgDress
 464 adg_table_style_get_value_dress(AdgTableStyle *table_style)
 465 {
 466     AdgTableStylePrivate *data;
 467
 468     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), ADG_DRESS_UNDEFINED);
 469
 470     data = table_style->data;
 471
 472     return data->value_dress;
 473 }
 474
 475 /**
 476  * adg_table_style_set_row_height:
 477  * @table_style: an #AdgTableStyle object
 478  * @heigth: the new row heigth fallback
 479  *
 480  * Sets a new #AdgTableStyle:row-height fallback. @height must
 481  * be a valid row height greather than %0 or a warning will be
 482  * raised and this function will fail.
 483  **/
 484 void
 485 adg_table_style_set_row_height(AdgTableStyle *table_style, gdouble height)
 486 {
 487     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 488
 489     if (set_row_height(table_style, height))
 490         g_object_notify((GObject *) table_style, "row-height");
 491 }
 492
 493 /**
 494  * adg_table_style_get_row_height:
 495  * @table_style: an #AdgTableStyle object
 496  *
 497  * Gets the row height fallback value.
 498  *
 499  * Returns: the fallback row height or %0 on errors
 500  **/
 501 gdouble
 502 adg_table_style_get_row_height(AdgTableStyle *table_style)
 503 {
 504     AdgTableStylePrivate *data;
 505
 506     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), 0);
 507
 508     data = table_style->data;
 509
 510     return data->row_height;
 511 }
 512
 513 /**
 514  * adg_table_style_set_cell_padding:
 515  * @table_style: an #AdgTableStyle object
 516  * @padding: the new padding values
 517  *
 518  * Sets new #AdgTableStyle:cell-padding values.
 519  **/
 520 void
 521 adg_table_style_set_cell_padding(AdgTableStyle *table_style,
 522                                  const AdgPair *padding)
 523 {
 524     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 525
 526     if (set_cell_padding(table_style, padding))
 527         g_object_notify((GObject *) table_style, "cell-padding");
 528 }
 529
 530 /**
 531  * adg_table_style_get_cell_padding:
 532  * @table_style: an #AdgTableStyle object
 533  *
 534  * Gets the padding values in x and y to be left clear inside the cells.
 535  * The returned pointer refers to an internal allocated struct and
 536  * must not be modified or freed.
 537  *
 538  * The cell padding is a symmetric value, that is the padding on the
 539  * left will always be equal to the padding on the right and the top
 540  * will always be equal to the bottom.
 541  *
 542  * Returns: the cell padding values or %NULL on errors
 543  **/
 544 const AdgPair *
 545 adg_table_style_get_cell_padding(AdgTableStyle *table_style)
 546 {
 547     AdgTableStylePrivate *data;
 548
 549     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), NULL);
 550
 551     data = table_style->data;
 552
 553     return &data->cell_padding;
 554 }
 555
 556 /**
 557  * adg_table_style_set_cell_spacing:
 558  * @table_style: an #AdgTableStyle object
 559  * @spacing: the new spacing values
 560  *
 561  * Sets new #AdgTableStyle:cell-spacing values.
 562  **/
 563 void
 564 adg_table_style_set_cell_spacing(AdgTableStyle *table_style,
 565                                  const AdgPair *spacing)
 566 {
 567     g_return_if_fail(ADG_IS_TABLE_STYLE(table_style));
 568
 569     if (set_cell_spacing(table_style, spacing))
 570         g_object_notify((GObject *) table_style, "cell-spacing");
 571 }
 572
 573 /**
 574  * adg_table_style_get_cell_spacing:
 575  * @table_style: an #AdgTableStyle object
 576  *
 577  * Gets the spacing values in x and y to be left between the cell
 578  * boundary boxes. The returned pointer refers to an internal
 579  * allocated struct and must not be modified or freed.
 580  *
 581  * The cell spacing is a symmetric value, that is the spacing on the
 582  * left will always be equal to the spacing on the right and the top
 583  * will always be equal to the bottom.
 584  *
 585  * Returns: the cell spacing values or %NULL on errors
 586  **/
 587 const AdgPair *
 588 adg_table_style_get_cell_spacing(AdgTableStyle *table_style)
 589 {
 590     AdgTableStylePrivate *data;
 591
 592     g_return_val_if_fail(ADG_IS_TABLE_STYLE(table_style), NULL);
 593
 594     data = table_style->data;
 595
 596     return &data->cell_spacing;
 597 }
 598
 599
 600 static void
 601 apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
 602 {
 603     AdgTableStylePrivate *data = ((AdgTableStyle *) style)->data;
 604
 605     adg_entity_apply_dress(entity, data->color_dress, cr);
 606 }
 607
 608 static gboolean
 609 set_row_height(AdgTableStyle *table_style, gdouble height)
 610 {
 611     AdgTableStylePrivate *data = table_style->data;
 612
 613     /* A better approach would be to use the GParamSpec of this property */
 614     g_return_val_if_fail(height >= 0, FALSE);
 615
 616     if (data->row_height == height)
 617         return FALSE;
 618
 619     data->row_height = height;
 620     return TRUE;
 621 }
 622
 623 static gboolean
 624 set_cell_padding(AdgTableStyle *table_style, const AdgPair *padding)
 625 {
 626     AdgTableStylePrivate *data;
 627
 628     g_return_val_if_fail(padding != NULL, FALSE);
 629
 630     data = table_style->data;
 631
 632     if (adg_pair_equal(&data->cell_padding, padding))
 633         return FALSE;
 634
 635     data->cell_padding = *padding;
 636
 637     return TRUE;
 638 }
 639
 640 static gboolean
 641 set_cell_spacing(AdgTableStyle *table_style, const AdgPair *spacing)
 642 {
 643     AdgTableStylePrivate *data;
 644
 645     g_return_val_if_fail(spacing != NULL, FALSE);
 646
 647     data = table_style->data;
 648
 649     if (adg_pair_equal(&data->cell_spacing, spacing))
 650         return FALSE;
 651
 652     data->cell_spacing = *spacing;
 653
 654     return TRUE;
 655 }