adg/adg-table-style.c

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