src/adg/adg-title-block.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2019  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     /* By default the title block should be floating */
 177     adg_entity_switch_floating((AdgEntity *) title_block, TRUE);
 178
 179     /* Create the title block template*/
 180
 181     /* First row */
 182     row = adg_table_row_new(table);
 183     adg_table_cell_new_with_width(row, 62);
 184     adg_table_cell_new_full(row, 200, "title", _("TITLE"), TRUE);
 185
 186     /* Second row */
 187     row = adg_table_row_new(table);
 188     adg_table_cell_new_full(row, 62, "logo", NULL, FALSE);
 189     adg_table_cell_new_full(row, 40, "size", _("SIZE"), TRUE);
 190     adg_table_cell_new_full(row, 60, "scale", _("SCALE"), TRUE);
 191     adg_table_cell_new_full(row, 100, "drawing", _("DRAWING"), TRUE);
 192
 193     /* Third row */
 194     row = adg_table_row_new(table);
 195     adg_table_cell_new_full(row, 62, "projection", NULL, TRUE);
 196     adg_table_cell_new_full(row, 100, "author", _("AUTHOR"), TRUE);
 197     adg_table_cell_new_full(row, 100, "date", _("DATE"), TRUE);
 198 }
 199
 200 static void
 201 _adg_finalize(GObject *object)
 202 {
 203     AdgTitleBlockPrivate *data = ((AdgTitleBlock *) object)->data;
 204
 205     g_free(data->title);
 206     g_free(data->drawing);
 207     g_free(data->size);
 208     g_free(data->scale);
 209     g_free(data->author);
 210     g_free(data->date);
 211
 212     if (_ADG_OLD_OBJECT_CLASS->finalize)
 213         _ADG_OLD_OBJECT_CLASS->finalize(object);
 214 }
 215
 216 static void
 217 _adg_get_property(GObject *object, guint prop_id,
 218                   GValue *value, GParamSpec *pspec)
 219 {
 220     AdgTitleBlockPrivate *data = ((AdgTitleBlock *) object)->data;
 221
 222     switch (prop_id) {
 223     case PROP_TITLE:
 224         g_value_set_string(value, data->title);
 225         break;
 226     case PROP_DRAWING:
 227         g_value_set_string(value, data->drawing);
 228         break;
 229     case PROP_SIZE:
 230         g_value_set_string(value, data->size);
 231         break;
 232     case PROP_SCALE:
 233         g_value_set_string(value, data->scale);
 234         break;
 235     case PROP_AUTHOR:
 236         g_value_set_string(value, data->author);
 237         break;
 238     case PROP_DATE:
 239         g_value_set_string(value, data->date);
 240         break;
 241     case PROP_LOGO:
 242         g_value_set_object(value, data->logo);
 243         break;
 244     case PROP_PROJECTION:
 245         g_value_set_object(value, data->projection);
 246         break;
 247     default:
 248         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 249         break;
 250     }
 251 }
 252
 253 static void
 254 _adg_set_property(GObject *object, guint prop_id,
 255                   const GValue *value, GParamSpec *pspec)
 256 {
 257     AdgTitleBlock *title_block;
 258     AdgTitleBlockPrivate *data;
 259     AdgTable *table;
 260     AdgTableCell *cell;
 261
 262     title_block = (AdgTitleBlock *) object;
 263     data = title_block->data;
 264     table = (AdgTable *) object;
 265
 266     switch (prop_id) {
 267     case PROP_TITLE:
 268         g_free(data->title);
 269         data->title = g_value_dup_string(value);
 270         cell = adg_table_get_cell(table, "title");
 271         adg_table_cell_set_text_value(cell, data->title);
 272         break;
 273     case PROP_DRAWING:
 274         g_free(data->drawing);
 275         data->drawing = g_value_dup_string(value);
 276         cell = adg_table_get_cell(table, "drawing");
 277         adg_table_cell_set_text_value(cell, data->drawing);
 278         break;
 279     case PROP_SIZE:
 280         g_free(data->size);
 281         data->size = g_value_dup_string(value);
 282         cell = adg_table_get_cell(table, "size");
 283         adg_table_cell_set_text_value(cell, data->size);
 284         break;
 285     case PROP_SCALE:
 286         g_free(data->scale);
 287         data->scale = g_value_dup_string(value);
 288         cell = adg_table_get_cell(table, "scale");
 289         adg_table_cell_set_text_value(cell, data->scale);
 290         break;
 291     case PROP_AUTHOR:
 292         g_free(data->author);
 293         data->author = g_value_dup_string(value);
 294         cell = adg_table_get_cell(table, "author");
 295         adg_table_cell_set_text_value(cell, data->author);
 296         break;
 297     case PROP_DATE:
 298         g_free(data->date);
 299         if (g_value_get_string(value) == NULL) {
 300             /* NULL means the date must be automatically updated */
 301             GDate *gdate;
 302             char buffer[100] = { 0 };
 303
 304             gdate = g_date_new();
 305             g_date_set_time_t(gdate, time (NULL));
 306             g_date_strftime(buffer, sizeof(buffer), "%x", gdate);
 307             g_date_free(gdate);
 308
 309             data->date = g_strdup(buffer);
 310         } else {
 311             data->date = g_value_dup_string(value);
 312         }
 313         cell = adg_table_get_cell(table, "date");
 314         adg_table_cell_set_text_value(cell, data->date);
 315         break;
 316     case PROP_LOGO:
 317         data->logo = g_value_get_object(value);
 318         cell = adg_table_get_cell(table, "logo");
 319         adg_table_cell_set_value(cell, data->logo);
 320         adg_table_cell_set_value_pos_explicit(cell, 0.5, 1, 0.5, 0.5);
 321         break;
 322     case PROP_PROJECTION:
 323         data->projection = g_value_get_object(value);
 324         cell = adg_table_get_cell(table, "projection");
 325         adg_table_cell_set_value(cell, data->projection);
 326         adg_table_cell_set_value_pos_explicit(cell, 0.5, 0.5, 0.5, 0.5);
 327         break;
 328     default:
 329         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 330         break;
 331     }
 332 }
 333
 334
 335 /**
 336  * adg_title_block_new:
 337  *
 338  * Creates a new empty title block entity.
 339  *
 340  * Returns: (transfer full): the newly created title block entity.
 341  *
 342  * Since: 1.0
 343  **/
 344 AdgTitleBlock *
 345 adg_title_block_new(void)
 346 {
 347     return g_object_new(ADG_TYPE_TITLE_BLOCK, NULL);
 348 }
 349
 350 /**
 351  * adg_title_block_set_title:
 352  * @title_block: an #AdgTitleBlock entity
 353  * @title: the new title
 354  *
 355  * Sets a new title on the title block.
 356  *
 357  * Since: 1.0
 358  **/
 359 void
 360 adg_title_block_set_title(AdgTitleBlock *title_block, const gchar *title)
 361 {
 362     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 363     g_object_set(title_block, "title", title, NULL);
 364 }
 365
 366 /**
 367  * adg_title_block_get_title:
 368  * @title_block: an #AdgTitleBlock entity
 369  *
 370  * Gets the descriptive title associated to this title block.
 371  * The returned string is owned by @title_block and should not
 372  * be modifed or freed.
 373  *
 374  * Returns: (transfer none): the title or <constant>NULL</constant> on no title or errors.
 375  *
 376  * Since: 1.0
 377  **/
 378 const gchar *
 379 adg_title_block_get_title(AdgTitleBlock *title_block)
 380 {
 381     AdgTitleBlockPrivate *data;
 382
 383     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 384
 385     data = title_block->data;
 386
 387     return data->title;
 388 }
 389
 390 /**
 391  * adg_title_block_set_drawing:
 392  * @title_block: an #AdgTitleBlock entity
 393  * @drawing: the new drawing name
 394  *
 395  * Sets a new drawing name on the title block.
 396  *
 397  * Since: 1.0
 398  **/
 399 void
 400 adg_title_block_set_drawing(AdgTitleBlock *title_block, const gchar *drawing)
 401 {
 402     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 403     g_object_set(title_block, "drawing", drawing, NULL);
 404 }
 405
 406 /**
 407  * adg_title_block_get_drawing:
 408  * @title_block: an #AdgTitleBlock entity
 409  *
 410  * Gets the drawing name, commonly used to specify the file name.
 411  * The returned string is owned by @title_block and should not
 412  * be modifed or freed.
 413  *
 414  * Returns: (transfer none): the drawing name or <constant>NULL</constant> on no name or errors.
 415  *
 416  * Since: 1.0
 417  **/
 418 const gchar *
 419 adg_title_block_get_drawing(AdgTitleBlock *title_block)
 420 {
 421     AdgTitleBlockPrivate *data;
 422
 423     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 424
 425     data = title_block->data;
 426
 427     return data->drawing;
 428 }
 429
 430 /**
 431  * adg_title_block_set_size:
 432  * @title_block: an #AdgTitleBlock entity
 433  * @size: the new size
 434  *
 435  * Sets a new size on the title block.
 436  *
 437  * Since: 1.0
 438  **/
 439 void
 440 adg_title_block_set_size(AdgTitleBlock *title_block, const gchar *size)
 441 {
 442     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 443     g_object_set(title_block, "size", size, NULL);
 444 }
 445
 446 /**
 447  * adg_title_block_get_size:
 448  * @title_block: an #AdgTitleBlock entity
 449  *
 450  * Gets the media size (a descriptive name) where this drawing will
 451  * be printed. Usually contains something like <constant>"A4"</constant>
 452  * or <constant>"Letter"</constant>.
 453  * The returned string is owned by @title_block and should not
 454  * be modifed or freed.
 455  *
 456  * Returns: (transfer none): the size or <constant>NULL</constant> on no size or errors.
 457  *
 458  * Since: 1.0
 459  **/
 460 const gchar *
 461 adg_title_block_get_size(AdgTitleBlock *title_block)
 462 {
 463     AdgTitleBlockPrivate *data;
 464
 465     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 466
 467     data = title_block->data;
 468
 469     return data->size;
 470 }
 471
 472 /**
 473  * adg_title_block_set_scale:
 474  * @title_block: an #AdgTitleBlock entity
 475  * @scale: the new scale
 476  *
 477  * Sets a new scale on the title block.
 478  *
 479  * Since: 1.0
 480  **/
 481 void
 482 adg_title_block_set_scale(AdgTitleBlock *title_block, const gchar *scale)
 483 {
 484     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 485     g_object_set(title_block, "scale", scale, NULL);
 486 }
 487
 488 /**
 489  * adg_title_block_get_scale:
 490  * @title_block: an #AdgTitleBlock entity
 491  *
 492  * Gets the scale descriptive name of the drawing.
 493  *
 494  * Returns: (transfer none): the scale text or <constant>NULL</constant> on no scale or errors.
 495  *
 496  * Since: 1.0
 497  **/
 498 const gchar *
 499 adg_title_block_get_scale(AdgTitleBlock *title_block)
 500 {
 501     AdgTitleBlockPrivate *data;
 502
 503     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 504
 505     data = title_block->data;
 506
 507     return data->scale;
 508 }
 509
 510 /**
 511  * adg_title_block_set_author:
 512  * @title_block: an #AdgTitleBlock entity
 513  * @author: the new author
 514  *
 515  * Sets a new author on the title block.
 516  *
 517  * Since: 1.0
 518  **/
 519 void
 520 adg_title_block_set_author(AdgTitleBlock *title_block, const gchar *author)
 521 {
 522     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 523     g_object_set(title_block, "author", author, NULL);
 524 }
 525
 526 /**
 527  * adg_title_block_get_author:
 528  * @title_block: an #AdgTitleBlock entity
 529  *
 530  * Gets the author's name of the drawing.
 531  *
 532  * Returns: (transfer none): the author or <constant>NULL</constant> on no author or errors.
 533  *
 534  * Since: 1.0
 535  **/
 536 const gchar *
 537 adg_title_block_get_author(AdgTitleBlock *title_block)
 538 {
 539     AdgTitleBlockPrivate *data;
 540
 541     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 542
 543     data = title_block->data;
 544
 545     return data->author;
 546 }
 547
 548 /**
 549  * adg_title_block_set_date:
 550  * @title_block: an #AdgTitleBlock entity
 551  * @date: the new date
 552  *
 553  * Sets a new date on the title block. By default the date is
 554  * set to <constant>NULL</constant> and it will be implicitely
 555  * rendered using the*preferred representation for the current
 556  * local of the actual date. This is roughly equivalent to:
 557  *
 558  * <informalexample><programlisting language="C">
 559  * strftime(buffer, sizeof(buffer), "%x", now);
 560  * adg_title_block_set_date(title_block, buffer);
 561  * </programlisting></informalexample>
 562  *
 563  * To not render any value, use an empty string as @date.
 564  *
 565  * Since: 1.0
 566  **/
 567 void
 568 adg_title_block_set_date(AdgTitleBlock *title_block, const gchar *date)
 569 {
 570     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 571     g_object_set(title_block, "date", date, NULL);
 572 }
 573
 574 /**
 575  * adg_title_block_get_date:
 576  * @title_block: an #AdgTitleBlock entity
 577  *
 578  * Gets the date of the rendering set on @title_block.
 579  *
 580  * Returns: (transfer none): the date or <constant>NULL</constant> on no date or errors.
 581  *
 582  * Since: 1.0
 583  **/
 584 const gchar *
 585 adg_title_block_get_date(AdgTitleBlock *title_block)
 586 {
 587     AdgTitleBlockPrivate *data;
 588
 589     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 590
 591     data = title_block->data;
 592
 593     return data->date;
 594 }
 595
 596 /**
 597  * adg_title_block_set_logo:
 598  * @title_block: an #AdgTitleBlock entity
 599  * @logo: the new logo
 600  *
 601  * Sets a new logo on the title block. This function will add
 602  * a reference to @logo, removing the eventual reference held
 603  * to the old logo, hence possibly destroying the old endity.
 604  *
 605  * The space reserved for the logo is 56x56, so try to keep the
 606  * new logo near this size or scale it accordingly.
 607  *
 608  * Since: 1.0
 609  **/
 610 void
 611 adg_title_block_set_logo(AdgTitleBlock *title_block, AdgEntity *logo)
 612 {
 613     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 614     g_object_set(title_block, "logo", logo, NULL);
 615 }
 616
 617 /**
 618  * adg_title_block_logo:
 619  * @title_block: an #AdgTitleBlock entity
 620  *
 621  * Gets the logo bound to this title block.
 622  * The returned object is owned by @title_block and should not
 623  * be unreferenced although can be freely modified.
 624  *
 625  * Returns: (transfer none): the logo or <constant>NULL</constant> on no logo or errors.
 626  *
 627  * Since: 1.0
 628  **/
 629 AdgEntity *
 630 adg_title_block_logo(AdgTitleBlock *title_block)
 631 {
 632     AdgTitleBlockPrivate *data;
 633
 634     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 635
 636     data = title_block->data;
 637
 638     return data->logo;
 639 }
 640
 641 /**
 642  * adg_title_block_set_projection:
 643  * @title_block: an #AdgTitleBlock entity
 644  * @projection: the new projection
 645  *
 646  * Sets a new projection symbol on the title block. This function
 647  * will add a reference to @projection, removing the eventual
 648  * reference held to the old symbol, hence possibly destroying
 649  * the old endity.
 650  *
 651  * The space reserved for the projection is 56x56, so try to keep the
 652  * new projection near this size or scale it accordingly.
 653  *
 654  * Since: 1.0
 655  **/
 656 void
 657 adg_title_block_set_projection(AdgTitleBlock *title_block,
 658                                AdgEntity *projection)
 659 {
 660     g_return_if_fail(ADG_IS_TITLE_BLOCK(title_block));
 661     g_object_set(title_block, "projection", projection, NULL);
 662 }
 663
 664 /**
 665  * adg_title_block_projection:
 666  * @title_block: an #AdgTitleBlock entity
 667  *
 668  * Gets the projection bound to this title block.
 669  * The returned object is owned by @title_block and should not
 670  * be unreferenced although can be freely modified.
 671  *
 672  * Returns: (transfer none): the projection or <constant>NULL</constant> on no projection or errors.
 673  *
 674  * Since: 1.0
 675  **/
 676 AdgEntity *
 677 adg_title_block_projection(AdgTitleBlock *title_block)
 678 {
 679     AdgTitleBlockPrivate *data;
 680
 681     g_return_val_if_fail(ADG_IS_TITLE_BLOCK(title_block), NULL);
 682
 683     data = title_block->data;
 684
 685     return data->projection;
 686 }