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