src/adg/adg-title-block.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  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-title-block
  23  * @short_description: A title block entity
  24  *
  25  * Title blocks are commonly used in technical drawings to include
  26  * additional information not strictly related to physical dimensions,
  27  * such as title, material of the represented part, special treatments,
  28  * date and scale etc.
  29  *
  30  * Actually this entity is only a place-holder: it will be implemented
  31  * properly in a 0.6.x release, after having AdgToyTable in place.
  32  *
  33  * Since: 1.0
  34  **/
  35
  36 /**
  37  * AdgTitleBlock:
  38  *
  39  * All fields are privates and should not be used directly.
  40  * Use its public methods instead.
  41  *
  42  * Since: 1.0
  43  **/
  44
  45
  46 #include "adg-internal.h"
  47
  48 #include "adg-table.h"
  49 #include "adg-table-row.h"
  50 #include "adg-table-cell.h"
  51
  52 #include "adg-title-block.h"
  53 #include "adg-title-block-private.h"
  54
  55
  56 #define _ADG_OLD_OBJECT_CLASS  ((GObjectClass *) adg_title_block_parent_class)
  57
  58
  59 G_DEFINE_TYPE(AdgTitleBlock, adg_title_block, ADG_TYPE_TABLE);
  60
  61 enum {
  62     PROP_0,
  63     PROP_TITLE,
  64     PROP_DRAWING,
  65     PROP_SIZE,
  66     PROP_SCALE,
  67     PROP_AUTHOR,
  68     PROP_DATE,
  69     PROP_LOGO,
  70     PROP_PROJECTION
  71 };
  72
  73
  74 static void             _adg_finalize           (GObject        *object);
  75 static void             _adg_get_property       (GObject        *object,
  76                                                  guint           prop_id,
  77                                                  GValue         *value,
  78                                                  GParamSpec     *pspec);
  79 static void             _adg_set_property       (GObject        *object,
  80                                                  guint           prop_id,
  81                                                  const GValue   *value,
  82                                                  GParamSpec     *pspec);
  83
  84
  85 static void
  86 adg_title_block_class_init(AdgTitleBlockClass *klass)
  87 {
  88     GObjectClass *gobject_class;
  89     GParamSpec *param;
  90
  91     gobject_class = (GObjectClass *) klass;
  92
  93     g_type_class_add_private(klass, sizeof(AdgTitleBlockPrivate));
  94
  95     gobject_class->finalize = _adg_finalize;
  96     gobject_class->set_property = _adg_set_property;
  97     gobject_class->get_property = _adg_get_property;
  98
  99     param = g_param_spec_string("title",
 100                                 P_("Title"),
 101                                 P_("A descriptive title of the drawing"),
 102                                 NULL,
 103                                 G_PARAM_READWRITE);
 104     g_object_class_install_property(gobject_class, PROP_TITLE, param);
 105
 106     param = g_param_spec_string("drawing",
 107                                 P_("Drawing Name"),
 108                                 P_("The name of the drawing: the ADG canvas does not make any assumtpion on this text string"),
 109                                 NULL,
 110                                 G_PARAM_READWRITE);
 111     g_object_class_install_property(gobject_class, PROP_DRAWING, param);
 112
 113     param = g_param_spec_string("size",
 114                                 P_("Media Size"),
 115                                 P_("The media size to be used to print the drawing, usually something like \"A3\" or \"Letter\""),
 116                                 NULL,
 117                                 G_PARAM_READWRITE);
 118     g_object_class_install_property(gobject_class, PROP_SIZE, param);
 119
 120     param = g_param_spec_string("scale",
 121                                 P_("Scale"),
 122                                 P_("The scale of the drawing, if it makes sense"),
 123                                 NULL,
 124                                 G_PARAM_READWRITE);
 125     g_object_class_install_property(gobject_class, PROP_SCALE, param);
 126
 127     param = g_param_spec_string("author",
 128                                 P_("Author"),
 129                                 P_("Name and last name of the author of the drawing"),
 130                                 NULL,
 131                                 G_PARAM_READWRITE);
 132     g_object_class_install_property(gobject_class, PROP_AUTHOR, param);
 133
 134     param = g_param_spec_string("date",
 135                                 P_("Date"),
 136                                 P_("The date this drawing has been generated: setting it to an empty string will fallback to today in the preferred representation for the current locale"),
 137                                 NULL,
 138                                 G_PARAM_READWRITE);
 139     g_object_class_install_property(gobject_class, PROP_DATE, param);
 140
 141     param = g_param_spec_object("logo",
 142                                 P_("Logo"),
 143                                 P_("An entity to be displayed in the title block as the logo of the owner: the containing cell has a 1:1 ratio"),
 144                                 ADG_TYPE_ENTITY,
 145                                 G_PARAM_READWRITE);
 146     g_object_class_install_property(gobject_class, PROP_LOGO, param);
 147
 148     param = g_param_spec_object("projection",
 149                                 P_("Projection Scheme"),
 150                                 P_("The entity usually reserved to identify the projection scheme adopted by this drawing"),
 151                                 ADG_TYPE_ENTITY,
 152                                 G_PARAM_READWRITE);
 153     g_object_class_install_property(gobject_class, PROP_PROJECTION, param);
 154 }
 155
 156 static void
 157 adg_title_block_init(AdgTitleBlock *title_block)
 158 {
 159     AdgTable *table = (AdgTable *) title_block;
 160     AdgTableRow *row;
 161     AdgTitleBlockPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(title_block,
 162                                                              ADG_TYPE_TITLE_BLOCK,
 163                                                              AdgTitleBlockPrivate);
 164
 165     data->author = NULL;
 166     data->title = NULL;
 167     data->drawing = NULL;
 168     data->size = NULL;
 169     data->scale = NULL;
 170     data->author = NULL;
 171     data->date = NULL;
 172     data->projection = NULL;
 173
 174     title_block->data = data;
 175
 176     /* Create the title block template*/
 177
 178     /* First row */
 179     row = adg_table_row_new(table);
 180     adg_table_cell_new_with_width(row, 62);
 181     adg_table_cell_new_full(row, 200, "title", _("TITLE"), TRUE);
 182
 183     /* Second row */
 184     row = adg_table_row_new(table);
 185     adg_table_cell_new_full(row, 62, "logo", NULL, FALSE);
 186     adg_table_cell_new_full(row, 40, "size", _("SIZE"), TRUE);
 187     adg_table_cell_new_full(row, 60, "scale", _("SCALE"), TRUE);
 188     adg_table_cell_new_full(row, 100, "drawing", _("DRAWING"), TRUE);
 189
 190     /* Third row */
 191     row = adg_table_row_new(table);
 192     adg_table_cell_new_full(row, 62, "projection", NULL, TRUE);
 193     adg_table_cell_new_full(row, 100, "author", _("AUTHOR"), TRUE);
 194     adg_table_cell_new_full(row, 100, "date", _("DATE"), TRUE);
 195 }
 196
 197 static void
 198 _adg_finalize(GObject *object)
 199 {
 200     AdgTitleBlockPrivate *data = ((AdgTitleBlock *) object)->data;
 201
 202     g_free(data->title);
 203     g_free(data->drawing);
 204     g_free(data->size);
 205     g_free(data->scale);
 206     g_free(data->author);
 207     g_free(data->date);
 208
 209     if (_ADG_OLD_OBJECT_CLASS->finalize)
 210         _ADG_OLD_OBJECT_CLASS->finalize(object);
 211 }
 212
 213 static void
 214 _adg_get_property(GObject *object, guint prop_id,
 215                   GValue *value, GParamSpec *pspec)
 216 {
 217     AdgTitleBlockPrivate *data = ((AdgTitleBlock *) object)->data;
 218
 219     switch (prop_id) {
 220     case PROP_TITLE:
 221         g_value_set_string(value, data->title);
 222         break;
 223     case PROP_DRAWING:
 224         g_value_set_string(value, data->drawing);
 225         break;
 226     case PROP_SIZE:
 227         g_value_set_string(value, data->size);
 228         break;
 229     case PROP_SCALE:
 230         g_value_set_string(value, data->scale);
 231         break;
 232     case PROP_AUTHOR:
 233         g_value_set_string(value, data->author);
 234         break;
 235     case PROP_DATE:
 236         g_value_set_string(value, data->date);
 237         break;
 238     case PROP_LOGO:
 239         g_value_set_object(value, data->logo);
 240         break;
 241     case PROP_PROJECTION:
 242         g_value_set_object(value, data->projection);
 243         break;
 244     default:
 245         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 246         break;
 247     }
 248 }
 249
 250 static void
 251 _adg_set_property(GObject *object, guint prop_id,
 252                   const GValue *value, GParamSpec *pspec)
 253 {
 254     AdgTitleBlock *title_block;
 255     AdgTitleBlockPrivate *data;
 256     AdgTable *table;
 257     AdgTableCell *cell;
 258
 259     title_block = (AdgTitleBlock *) object;
 260     data = title_block->data;
 261     table = (AdgTable *) object;
 262
 263     switch (prop_id) {
 264     case PROP_TITLE:
 265         g_free(data->title);
 266         data->title = g_value_dup_string(value);
 267         cell = adg_table_get_cell(table, "title");
 268         adg_table_cell_set_text_value(cell, data->title);
 269         break;
 270     case PROP_DRAWING:
 271         g_free(data->drawing);
 272         data->drawing = g_value_dup_string(value);
 273         cell = adg_table_get_cell(table, "drawing");
 274         adg_table_cell_set_text_value(cell, data->drawing);
 275         break;
 276     case PROP_SIZE:
 277         g_free(data->size);
 278         data->size = g_value_dup_string(value);
 279         cell = adg_table_get_cell(table, "size");
 280         adg_table_cell_set_text_value(cell, data->size);
 281         break;
 282     case PROP_SCALE:
 283         g_free(data->scale);
 284         data->scale = g_value_dup_string(value);
 285         cell = adg_table_get_cell(table, "scale");
 286         adg_table_cell_set_text_value(cell, data->scale);
 287         break;
 288     case PROP_AUTHOR:
 289         g_free(data->author);
 290         data->author = g_value_dup_string(value);
 291         cell = adg_table_get_cell(table, "author");
 292         adg_table_cell_set_text_value(cell, data->author);
 293         break;
 294     case PROP_DATE:
 295         g_free(data->date);
 296         if (g_value_get_string(value) == NULL) {
 297             /* NULL means the date must be automatically updated */
 298             GDate *gdate;
 299             char buffer[100] = { 0 };
 300
 301             gdate = g_date_new();
 302             g_date_set_time_t(gdate, time (NULL));
 303             g_date_strftime(buffer, sizeof(buffer), "%x", gdate);
 304             g_date_free(gdate);
 305
 306             data->date = g_strdup(buffer);
 307         } else {
 308             data->date = g_value_dup_string(value);
 309         }
 310         cell = adg_table_get_cell(table, "date");
 311         adg_table_cell_set_text_value(cell, data->date);
 312         break;
 313     case PROP_LOGO:
 314         data->logo = g_value_get_object(value);
 315         cell = adg_table_get_cell(table, "logo");
 316         adg_table_cell_set_value(cell, data->logo);
 317         adg_table_cell_set_value_pos_explicit(cell, 0.5, 1, 0.5, 0.5);
 318         break;
 319     case PROP_PROJECTION:
 320         data->projection = g_value_get_object(value);
 321         cell = adg_table_get_cell(table, "projection");
 322         adg_table_cell_set_value(cell, data->projection);
 323         adg_table_cell_set_value_pos_explicit(cell, 0.5, 0.5, 0.5, 0.5);
 324         break;
 325     default:
 326         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 327         break;
 328     }
 329 }
 330
 331
 332 /**
 333  * adg_title_block_new:
 334  *
 335  * Creates a new empty title block entity.
 336  *
 337  * Returns: (transfer full): the newly created title block entity.
 338  *
 339  * Since: 1.0
 340  **/
 341 AdgTitleBlock *
 342 adg_title_block_new(void)
 343 {
 344     return g_object_new(ADG_TYPE_TITLE_BLOCK, NULL);
 345 }
 346
 347 /**
 348  * adg_title_block_set_title:
 349  * @title_block: an #AdgTitleBlock entity
 350  * @title: the new title
 351  *
 352  * Sets a new title on the title block.
 353  *
 354  * Since: 1.0
 355  **/
 356 void
 357 adg_title_block_set_title(AdgTitleBlock *title_block, const gchar *title)
 358 {
 359     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 360     g_object_set(title_block, "title", title, NULL);
 361 }
 362
 363 /**
 364  * adg_title_block_get_title:
 365  * @title_block: an #AdgTitleBlock entity
 366  *
 367  * Gets the descriptive title associated to this title block.
 368  * The returned string is owned by @title_block and should not
 369  * be modifed or freed.
 370  *
 371  * Returns: (transfer none): the title or %NULL on no title or errors.
 372  *
 373  * Since: 1.0
 374  **/
 375 const gchar *
 376 adg_title_block_get_title(AdgTitleBlock *title_block)
 377 {
 378     AdgTitleBlockPrivate *data;
 379
 380     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 381
 382     data = title_block->data;
 383
 384     return data->title;
 385 }
 386
 387 /**
 388  * adg_title_block_set_drawing:
 389  * @title_block: an #AdgTitleBlock entity
 390  * @drawing: the new drawing name
 391  *
 392  * Sets a new drawing name on the title block.
 393  *
 394  * Since: 1.0
 395  **/
 396 void
 397 adg_title_block_set_drawing(AdgTitleBlock *title_block, const gchar *drawing)
 398 {
 399     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 400     g_object_set(title_block, "drawing", drawing, NULL);
 401 }
 402
 403 /**
 404  * adg_title_block_get_drawing:
 405  * @title_block: an #AdgTitleBlock entity
 406  *
 407  * Gets the drawing name, commonly used to specify the file name.
 408  * The returned string is owned by @title_block and should not
 409  * be modifed or freed.
 410  *
 411  * Returns: (transfer none): the drawing name or %NULL on no name or errors.
 412  *
 413  * Since: 1.0
 414  **/
 415 const gchar *
 416 adg_title_block_get_drawing(AdgTitleBlock *title_block)
 417 {
 418     AdgTitleBlockPrivate *data;
 419
 420     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 421
 422     data = title_block->data;
 423
 424     return data->drawing;
 425 }
 426
 427 /**
 428  * adg_title_block_set_size:
 429  * @title_block: an #AdgTitleBlock entity
 430  * @size: the new size
 431  *
 432  * Sets a new size on the title block.
 433  *
 434  * Since: 1.0
 435  **/
 436 void
 437 adg_title_block_set_size(AdgTitleBlock *title_block, const gchar *size)
 438 {
 439     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 440     g_object_set(title_block, "size", size, NULL);
 441 }
 442
 443 /**
 444  * adg_title_block_get_size:
 445  * @title_block: an #AdgTitleBlock entity
 446  *
 447  * Gets the media size (a descriptive name) where this drawing will
 448  * be printed. Usually contains something like "A4" or "Letter".
 449  * The returned string is owned by @title_block and should not
 450  * be modifed or freed.
 451  *
 452  * Returns: (transfer none): the size or %NULL on no size or errors.
 453  *
 454  * Since: 1.0
 455  **/
 456 const gchar *
 457 adg_title_block_get_size(AdgTitleBlock *title_block)
 458 {
 459     AdgTitleBlockPrivate *data;
 460
 461     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 462
 463     data = title_block->data;
 464
 465     return data->size;
 466 }
 467
 468 /**
 469  * adg_title_block_set_scale:
 470  * @title_block: an #AdgTitleBlock entity
 471  * @scale: the new scale
 472  *
 473  * Sets a new scale on the title block.
 474  *
 475  * Since: 1.0
 476  **/
 477 void
 478 adg_title_block_set_scale(AdgTitleBlock *title_block, const gchar *scale)
 479 {
 480     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 481     g_object_set(title_block, "scale", scale, NULL);
 482 }
 483
 484 /**
 485  * adg_title_block_get_scale:
 486  * @title_block: an #AdgTitleBlock entity
 487  *
 488  * Gets the scale descriptive name of the drawing.
 489  *
 490  * Returns: (transfer none): the scale text or %NULL on no scale or errors.
 491  *
 492  * Since: 1.0
 493  **/
 494 const gchar *
 495 adg_title_block_get_scale(AdgTitleBlock *title_block)
 496 {
 497     AdgTitleBlockPrivate *data;
 498
 499     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 500
 501     data = title_block->data;
 502
 503     return data->scale;
 504 }
 505
 506 /**
 507  * adg_title_block_set_author:
 508  * @title_block: an #AdgTitleBlock entity
 509  * @author: the new author
 510  *
 511  * Sets a new author on the title block.
 512  *
 513  * Since: 1.0
 514  **/
 515 void
 516 adg_title_block_set_author(AdgTitleBlock *title_block, const gchar *author)
 517 {
 518     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 519     g_object_set(title_block, "author", author, NULL);
 520 }
 521
 522 /**
 523  * adg_title_block_get_author:
 524  * @title_block: an #AdgTitleBlock entity
 525  *
 526  * Gets the author's name of the drawing.
 527  *
 528  * Returns: (transfer none): the author or %NULL on no author or errors.
 529  *
 530  * Since: 1.0
 531  **/
 532 const gchar *
 533 adg_title_block_get_author(AdgTitleBlock *title_block)
 534 {
 535     AdgTitleBlockPrivate *data;
 536
 537     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 538
 539     data = title_block->data;
 540
 541     return data->author;
 542 }
 543
 544 /**
 545  * adg_title_block_set_date:
 546  * @title_block: an #AdgTitleBlock entity
 547  * @date: the new date
 548  *
 549  * Sets a new date on the title block. By default the date is
 550  * set to %NULL and it will be implicitely rendered using the
 551  * preferred representation for the current local of the actual
 552  * date. This is roughly equivalent to:
 553  *
 554  * |[
 555  * strftime(buffer, sizeof(buffer), "%x", now);
 556  * adg_title_block_set_date(title_block, buffer);
 557  * ]|
 558  *
 559  * To not render any value, use an empty string as @date.
 560  *
 561  * Since: 1.0
 562  **/
 563 void
 564 adg_title_block_set_date(AdgTitleBlock *title_block, const gchar *date)
 565 {
 566     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 567     g_object_set(title_block, "date", date, NULL);
 568 }
 569
 570 /**
 571  * adg_title_block_get_date:
 572  * @title_block: an #AdgTitleBlock entity
 573  *
 574  * Gets the date of the rendering set on @title_block.
 575  *
 576  * Returns: (transfer none): the date or %NULL on no date or errors.
 577  *
 578  * Since: 1.0
 579  **/
 580 const gchar *
 581 adg_title_block_get_date(AdgTitleBlock *title_block)
 582 {
 583     AdgTitleBlockPrivate *data;
 584
 585     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 586
 587     data = title_block->data;
 588
 589     return data->date;
 590 }
 591
 592 /**
 593  * adg_title_block_set_logo:
 594  * @title_block: an #AdgTitleBlock entity
 595  * @logo: the new logo
 596  *
 597  * Sets a new logo on the title block. This function will add
 598  * a reference to @logo, removing the eventual reference held
 599  * to the old logo, hence possibly destroying the old endity.
 600  *
 601  * The space reserved for the logo is 56x56, so try to keep the
 602  * new logo near this size or scale it accordingly.
 603  *
 604  * Since: 1.0
 605  **/
 606 void
 607 adg_title_block_set_logo(AdgTitleBlock *title_block, AdgEntity *logo)
 608 {
 609     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 610     g_object_set(title_block, "logo", logo, NULL);
 611 }
 612
 613 /**
 614  * adg_title_block_logo:
 615  * @title_block: an #AdgTitleBlock entity
 616  *
 617  * Gets the logo bound to this title block.
 618  * The returned object is owned by @title_block and should not
 619  * be unreferenced although can be freely modified.
 620  *
 621  * Returns: (transfer none): the logo or %NULL on no logo or errors.
 622  *
 623  * Since: 1.0
 624  **/
 625 AdgEntity *
 626 adg_title_block_logo(AdgTitleBlock *title_block)
 627 {
 628     AdgTitleBlockPrivate *data;
 629
 630     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 631
 632     data = title_block->data;
 633
 634     return data->logo;
 635 }
 636
 637 /**
 638  * adg_title_block_set_projection:
 639  * @title_block: an #AdgTitleBlock entity
 640  * @projection: the new projection
 641  *
 642  * Sets a new projection symbol on the title block. This function
 643  * will add a reference to @projection, removing the eventual
 644  * reference held to the old symbol, hence possibly destroying
 645  * the old endity.
 646  *
 647  * The space reserved for the projection is 56x56, so try to keep the
 648  * new projection near this size or scale it accordingly.
 649  *
 650  * Since: 1.0
 651  **/
 652 void
 653 adg_title_block_set_projection(AdgTitleBlock *title_block,
 654                                AdgEntity *projection)
 655 {
 656     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 657     g_object_set(title_block, "projection", projection, NULL);
 658 }
 659
 660 /**
 661  * adg_title_block_projection:
 662  * @title_block: an #AdgTitleBlock entity
 663  *
 664  * Gets the projection bound to this title block.
 665  * The returned object is owned by @title_block and should not
 666  * be unreferenced although can be freely modified.
 667  *
 668  * Returns: (transfer none): the projection or
 669  *                           %NULL on no projection or errors.
 670  *
 671  * Since: 1.0
 672  **/
 673 AdgEntity *
 674 adg_title_block_projection(AdgTitleBlock *title_block)
 675 {
 676     AdgTitleBlockPrivate *data;
 677
 678     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 679
 680     data = title_block->data;
 681
 682     return data->projection;
 683 }