src/adg/adg-title-block.c

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