src/adg/adg-title-block.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-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 <constant>NULL</constant> 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 <constant>NULL</constant> 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 <constant>"A4"</constant>
 449  * or <constant>"Letter"</constant>.
 450  * The returned string is owned by @title_block and should not
 451  * be modifed or freed.
 452  *
 453  * Returns: (transfer none): the size or <constant>NULL</constant> on no size or errors.
 454  *
 455  * Since: 1.0
 456  **/
 457 const gchar *
 458 adg_title_block_get_size(AdgTitleBlock *title_block)
 459 {
 460     AdgTitleBlockPrivate *data;
 461
 462     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 463
 464     data = title_block->data;
 465
 466     return data->size;
 467 }
 468
 469 /**
 470  * adg_title_block_set_scale:
 471  * @title_block: an #AdgTitleBlock entity
 472  * @scale: the new scale
 473  *
 474  * Sets a new scale on the title block.
 475  *
 476  * Since: 1.0
 477  **/
 478 void
 479 adg_title_block_set_scale(AdgTitleBlock *title_block, const gchar *scale)
 480 {
 481     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 482     g_object_set(title_block, "scale", scale, NULL);
 483 }
 484
 485 /**
 486  * adg_title_block_get_scale:
 487  * @title_block: an #AdgTitleBlock entity
 488  *
 489  * Gets the scale descriptive name of the drawing.
 490  *
 491  * Returns: (transfer none): the scale text or <constant>NULL</constant> on no scale or errors.
 492  *
 493  * Since: 1.0
 494  **/
 495 const gchar *
 496 adg_title_block_get_scale(AdgTitleBlock *title_block)
 497 {
 498     AdgTitleBlockPrivate *data;
 499
 500     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 501
 502     data = title_block->data;
 503
 504     return data->scale;
 505 }
 506
 507 /**
 508  * adg_title_block_set_author:
 509  * @title_block: an #AdgTitleBlock entity
 510  * @author: the new author
 511  *
 512  * Sets a new author on the title block.
 513  *
 514  * Since: 1.0
 515  **/
 516 void
 517 adg_title_block_set_author(AdgTitleBlock *title_block, const gchar *author)
 518 {
 519     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 520     g_object_set(title_block, "author", author, NULL);
 521 }
 522
 523 /**
 524  * adg_title_block_get_author:
 525  * @title_block: an #AdgTitleBlock entity
 526  *
 527  * Gets the author's name of the drawing.
 528  *
 529  * Returns: (transfer none): the author or <constant>NULL</constant> on no author or errors.
 530  *
 531  * Since: 1.0
 532  **/
 533 const gchar *
 534 adg_title_block_get_author(AdgTitleBlock *title_block)
 535 {
 536     AdgTitleBlockPrivate *data;
 537
 538     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 539
 540     data = title_block->data;
 541
 542     return data->author;
 543 }
 544
 545 /**
 546  * adg_title_block_set_date:
 547  * @title_block: an #AdgTitleBlock entity
 548  * @date: the new date
 549  *
 550  * Sets a new date on the title block. By default the date is
 551  * set to <constant>NULL</constant> and it will be implicitely
 552  * rendered using the*preferred representation for the current
 553  * local of the actual date. This is roughly equivalent to:
 554  *
 555  * <informalexample><programlisting language="C">
 556  * strftime(buffer, sizeof(buffer), "%x", now);
 557  * adg_title_block_set_date(title_block, buffer);
 558  * </programlisting></informalexample>
 559  *
 560  * To not render any value, use an empty string as @date.
 561  *
 562  * Since: 1.0
 563  **/
 564 void
 565 adg_title_block_set_date(AdgTitleBlock *title_block, const gchar *date)
 566 {
 567     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 568     g_object_set(title_block, "date", date, NULL);
 569 }
 570
 571 /**
 572  * adg_title_block_get_date:
 573  * @title_block: an #AdgTitleBlock entity
 574  *
 575  * Gets the date of the rendering set on @title_block.
 576  *
 577  * Returns: (transfer none): the date or <constant>NULL</constant> on no date or errors.
 578  *
 579  * Since: 1.0
 580  **/
 581 const gchar *
 582 adg_title_block_get_date(AdgTitleBlock *title_block)
 583 {
 584     AdgTitleBlockPrivate *data;
 585
 586     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 587
 588     data = title_block->data;
 589
 590     return data->date;
 591 }
 592
 593 /**
 594  * adg_title_block_set_logo:
 595  * @title_block: an #AdgTitleBlock entity
 596  * @logo: the new logo
 597  *
 598  * Sets a new logo on the title block. This function will add
 599  * a reference to @logo, removing the eventual reference held
 600  * to the old logo, hence possibly destroying the old endity.
 601  *
 602  * The space reserved for the logo is 56x56, so try to keep the
 603  * new logo near this size or scale it accordingly.
 604  *
 605  * Since: 1.0
 606  **/
 607 void
 608 adg_title_block_set_logo(AdgTitleBlock *title_block, AdgEntity *logo)
 609 {
 610     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 611     g_object_set(title_block, "logo", logo, NULL);
 612 }
 613
 614 /**
 615  * adg_title_block_logo:
 616  * @title_block: an #AdgTitleBlock entity
 617  *
 618  * Gets the logo bound to this title block.
 619  * The returned object is owned by @title_block and should not
 620  * be unreferenced although can be freely modified.
 621  *
 622  * Returns: (transfer none): the logo or <constant>NULL</constant> on no logo or errors.
 623  *
 624  * Since: 1.0
 625  **/
 626 AdgEntity *
 627 adg_title_block_logo(AdgTitleBlock *title_block)
 628 {
 629     AdgTitleBlockPrivate *data;
 630
 631     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 632
 633     data = title_block->data;
 634
 635     return data->logo;
 636 }
 637
 638 /**
 639  * adg_title_block_set_projection:
 640  * @title_block: an #AdgTitleBlock entity
 641  * @projection: the new projection
 642  *
 643  * Sets a new projection symbol on the title block. This function
 644  * will add a reference to @projection, removing the eventual
 645  * reference held to the old symbol, hence possibly destroying
 646  * the old endity.
 647  *
 648  * The space reserved for the projection is 56x56, so try to keep the
 649  * new projection near this size or scale it accordingly.
 650  *
 651  * Since: 1.0
 652  **/
 653 void
 654 adg_title_block_set_projection(AdgTitleBlock *title_block,
 655                                AdgEntity *projection)
 656 {
 657     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 658     g_object_set(title_block, "projection", projection, NULL);
 659 }
 660
 661 /**
 662  * adg_title_block_projection:
 663  * @title_block: an #AdgTitleBlock entity
 664  *
 665  * Gets the projection bound to this title block.
 666  * The returned object is owned by @title_block and should not
 667  * be unreferenced although can be freely modified.
 668  *
 669  * Returns: (transfer none): the projection or <constant>NULL</constant> 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 }