src/adg/adg-dress.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-dress
  23  * @Section_Id:Dresses
  24  * @title: AdgDress
  25  * @short_description: The ADG way to associate styles to entities
  26  *
  27  * The dress is a virtualization of an #AdgStyle instance. #AdgEntity
  28  * objects do not directly refer to #AdgStyle but use #AdgDress values
  29  * instead. This allows some advanced operations, such as overriding
  30  * a dress only in a specific entity branch of the hierarchy or
  31  * customize multiple entities at once.
  32  *
  33  * Since: 1.0
  34  **/
  35
  36 /**
  37  * AdgDress:
  38  * @ADG_DRESS_UNDEFINED:             undefined dress, used for notifying invalid
  39  *                                   dresses.
  40  * @ADG_DRESS_COLOR:                 default built-in color. This is a
  41  *                                   pass-through dress, that is it does not
  42  *                                   change the cairo context when it is
  43  *                                   applied. This dress will be resolved to an
  44  *                                   #AdgColorStyle instance.
  45  * @ADG_DRESS_COLOR_BACKGROUND:      default built-in color to be used as the
  46  *                                   #AdgCanvas background. This dress will be
  47  *                                   resolved to an #AdgColorStyle instance.
  48  * @ADG_DRESS_COLOR_STROKE:          default built-in color for #AdgStroke
  49  *                                   entities. This dress will be resolved to
  50  *                                   an #AdgColorStyle instance.
  51  * @ADG_DRESS_COLOR_DIMENSION:       built-in color used by default in
  52  *                                   #AdgDimStyle. This dress will be resolved
  53  *                                   to an #AdgColorStyle instance.
  54  * @ADG_DRESS_COLOR_ANNOTATION:      built-in color used for rendering
  55  *                                   helper entities such as #AdgToyText,
  56  *                                   #AdgTable and #AdgTitleBlock. This dress
  57  *                                   will be resolved to an #AdgColorStyle
  58  *                                   instance.
  59  * @ADG_DRESS_COLOR_FILL:            built-in color used by default by
  60  *                                   #AdgFillStyle based styles. This dress
  61  *                                   will be resolved to an #AdgColorStyle
  62  *                                   instance.
  63  * @ADG_DRESS_COLOR_AXIS:            default built-in color for stroking
  64  *                                   #ADG_DRESS_LINE_AXIS lines. This dress
  65  *                                   will be resolved to an #AdgColorStyle
  66  *                                   instance.
  67  * @ADG_DRESS_COLOR_HIDDEN:          default built-in color for stroking
  68  *                                   #ADG_DRESS_LINE_HIDDEN lines. This dress
  69  *                                   will be resolved to an #AdgColorStyle
  70  *                                   instance.
  71  * @ADG_DRESS_LINE:                  default built-in line. This is a
  72  *                                   pass-through dress, that is it does not
  73  *                                   change the cairo context when it is
  74  *                                   applied. This dress will be resolved to
  75  *                                   an #AdgLineStyle instance.
  76  * @ADG_DRESS_LINE_STROKE:           built-in line type to be used by default
  77  *                                   for rendering #AdgStroke entities.
  78  *                                   This dress will be resolved to an
  79  *                                   #AdgLineStyle instance.
  80  * @ADG_DRESS_LINE_DIMENSION:        built-in line type used by default for
  81  *                                   rendering base and extension lines of
  82  *                                   dimensions. This dress will be resolved
  83  *                                   to an #AdgLineStyle instance.
  84  * @ADG_DRESS_LINE_FILL:             built-in line type used by #AdgFillStyle.
  85  *                                   This dress will be resolved to an
  86  *                                   #AdgLineStyle instance.
  87  * @ADG_DRESS_LINE_GRID:             built-in line type used for rendering
  88  *                                   the grid of #AdgTable entities, that is
  89  *                                   the frame of the cells. This dress will
  90  *                                   be resolved to an #AdgLineStyle instance.
  91  * @ADG_DRESS_LINE_FRAME:            built-in line type used for rendering the
  92  *                                   frame of #AdgTable entities, that is the
  93  *                                   frame around the whole table. This dress
  94  *                                   will be resolved to an #AdgLineStyle
  95  *                                   instance.
  96  * @ADG_DRESS_LINE_AXIS:             built-in line type used for rendering axis
  97  *                                   and centerlines. This dress will be
  98  *                                   resolved to an #AdgLineStyle instance.
  99  * @ADG_DRESS_LINE_HIDDEN:           built-in line type used for rendering
 100  *                                   hidden lines and edges. This dress will be
 101  *                                   resolved to an #AdgLineStyle instance.
 102  * @ADG_DRESS_FONT:                  default built-in font. This dress will be
 103  *                                   resolved to an #AdgFontStyle instance.
 104  * @ADG_DRESS_FONT_TEXT:             built-in font used by default for
 105  *                                   rendering common text such as #AdgToyText
 106 *                                    or the value of #AdgTable entities. This
 107 *                                    dress will be resolved to an #AdgFontStyle
 108 *                                    instance.
 109  * @ADG_DRESS_FONT_ANNOTATION:       built-in font used for rendering auxiliary
 110  *                                   text, such as the titles on #AdgTable
 111  *                                   entities. This dress will be resolved to
 112  *                                   an #AdgFontStyle instance.
 113  * @ADG_DRESS_FONT_QUOTE_TEXT:       built-in font used for rendering regular
 114  *                                   text on dimension entities, such as the
 115  *                                   nominal value and the notes of a quote.
 116  *                                   This dress will be resolved to an
 117  *                                   #AdgFontStyle instance.
 118  * @ADG_DRESS_FONT_QUOTE_ANNOTATION: built-in font used for rendering auxiliary
 119  *                                   text on dimension entities, such as the
 120  *                                   min and max limits of a quote. This dress
 121  *                                   will be resolved to an #AdgFontStyle
 122  *                                   instance.
 123  * @ADG_DRESS_DIMENSION:             default built-in for dimensions. This
 124  *                                   dress will be resolved to an #AdgDimStyle
 125  *                                   instance.
 126  * @ADG_DRESS_FILL:                  default built-in for filling. This is a
 127  *                                   pass-through dress, that is it does not
 128  *                                   change the cairo context when it is
 129  *                                   applied. This dress will be resolved to an
 130  *                                   #AdgFillStyle derived instance.
 131  * @ADG_DRESS_FILL_HATCH:            built-in dress used by default by
 132  *                                   #AdgHatch instances. This dress will be
 133  *                                   resolved to an #AdgFillStyle derived
 134  *                                   instance.
 135  * @ADG_DRESS_TABLE:                 default built-in for tables. This dress
 136  *                                   will be resolved to an #AdgTableStyle
 137  *                                   derived instance.
 138  *
 139  * An index representing a virtual #AdgStyle. The ADG comes equipped
 140  * with some built-in dress.
 141  *
 142  * Since: 1.0
 143  **/
 144
 145 /**
 146  * ADG_TYPE_DRESS:
 147  *
 148  * The type used to express a dress index. It is defined only for GObject
 149  * internal and should not be used directly (at least, as far as I know).
 150  *
 151  * Since: 1.0
 152  **/
 153
 154 /**
 155  * ADG_VALUE_HOLDS_DRESS:
 156  * @value: a #GValue
 157  *
 158  * Checks whether a #GValue is actually holding an #AdgDress value or not.
 159  *
 160  * Returns: %TRUE is @value is holding an #AdgDress, %FALSE otherwise
 161  *
 162  * Since: 1.0
 163  **/
 164
 165
 166 #include "adg-internal.h"
 167 #include "adg-dash.h"
 168 #include "adg-model.h"
 169 #include "adg-trail.h"
 170 #include "adg-marker.h"
 171 #include "adg-arrow.h"
 172 #include "adg-style.h"
 173 #include "adg-color-style.h"
 174 #include "adg-line-style.h"
 175 #include "adg-text-internal.h"
 176 #include "adg-dim-style.h"
 177 #include "adg-fill-style.h"
 178 #include "adg-ruled-fill.h"
 179 #include "adg-table-style.h"
 180
 181 #include "adg-dress.h"
 182 #include "adg-dress-private.h"
 183
 184 #define MM  *2.83464566927
 185
 186
 187 static GArray *         _adg_data_array             (void);
 188 static void             _adg_data_register          (AdgDress    dress,
 189                                                      AdgStyle   *fallback,
 190                                                      GType       ancestor_type);
 191 static void             _adg_data_register_builtins (void);
 192 static AdgDressPrivate *_adg_data_lookup            (AdgDress    dress);
 193
 194
 195 /**
 196  * adg_dress_from_name:
 197  * @name: the name of a dress
 198  *
 199  * Gets the dress bound to a @name string. No warnings are raised
 200  * if the dress is not found.
 201  *
 202  * Returns: the #AdgDress value or #ADG_DRESS_UNDEFINED if not found.
 203  *
 204  * Since: 1.0
 205  **/
 206 AdgDress
 207 adg_dress_from_name(const gchar *name)
 208 {
 209     GEnumClass *dress_class = g_type_class_ref(ADG_TYPE_DRESS);
 210     GEnumValue *enum_value = g_enum_get_value_by_name(dress_class, name);
 211     g_type_class_unref(dress_class);
 212     return enum_value != NULL ? enum_value->value : ADG_DRESS_UNDEFINED;
 213 }
 214
 215 /**
 216  * adg_dress_are_related:
 217  * @dress1: an #AdgDress
 218  * @dress2: another #AdgDress
 219  *
 220  * Checks whether @dress1 and @dress2 are related, that is
 221  * if they have the same ancestor type as returned by
 222  * adg_dress_get_ancestor_type().
 223  *
 224  * Returns: %TRUE if the dresses are related, %FALSE otherwise.
 225  *
 226  * Since: 1.0
 227  **/
 228 gboolean
 229 adg_dress_are_related(AdgDress dress1, AdgDress dress2)
 230 {
 231     GType ancestor_type1, ancestor_type2;
 232
 233     ancestor_type1 = adg_dress_get_ancestor_type(dress1);
 234     if (ancestor_type1 <= 0)
 235         return FALSE;
 236
 237     ancestor_type2 = adg_dress_get_ancestor_type(dress2);
 238     if (ancestor_type2 <= 0)
 239         return FALSE;
 240
 241     return ancestor_type1 == ancestor_type2;
 242 }
 243
 244 /**
 245  * adg_dress_set:
 246  * @dress: a pointer to an #AdgDress
 247  * @src:   the source dress
 248  *
 249  * Copies @src in @dress. This operation can be succesful only if
 250  * @dress is #ADG_DRESS_UNDEFINED or if it contains a dress related
 251  * to @src, that is adg_dress_are_related() returns %TRUE.
 252  *
 253  * Returns: %TRUE on copy done, %FALSE on copy failed or not needed.
 254  *
 255  * Since: 1.0
 256  **/
 257 gboolean
 258 adg_dress_set(AdgDress *dress, AdgDress src)
 259 {
 260     if (*dress == src)
 261         return FALSE;
 262
 263     if (*dress != ADG_DRESS_UNDEFINED && !adg_dress_are_related(*dress, src))
 264         return FALSE;
 265
 266     *dress = src;
 267     return TRUE;
 268 }
 269
 270 /**
 271  * adg_dress_get_name:
 272  * @dress: an #AdgDress
 273  *
 274  * Gets the name associated to @dress. No warnings are raised if
 275  * @dress is not found.
 276  *
 277  * Returns: the requested name or %NULL if not found.
 278  *
 279  * Since: 1.0
 280  **/
 281 const gchar *
 282 adg_dress_get_name(AdgDress dress)
 283 {
 284     GEnumClass *dress_class = g_type_class_ref(ADG_TYPE_DRESS);
 285     GEnumValue *enum_value = g_enum_get_value(dress_class, dress);
 286     g_type_class_unref(dress_class);
 287     return enum_value != NULL ? enum_value->value_name : NULL;
 288 }
 289
 290 /**
 291  * adg_dress_get_ancestor_type:
 292  * @dress: an #AdgDress
 293  *
 294  * Gets the base type that should be present in every #AdgStyle
 295  * acceptable by @dress.  No warnings are raised if @dress
 296  * is not found.
 297  *
 298  * Returns: the ancestor type or %0 on errors.
 299  *
 300  * Since: 1.0
 301  **/
 302 GType
 303 adg_dress_get_ancestor_type(AdgDress dress)
 304 {
 305     AdgDressPrivate *data = _adg_data_lookup(dress);
 306     return data != NULL ? data->ancestor_type : 0;
 307 }
 308
 309 /**
 310  * adg_dress_set_fallback:
 311  * @dress:                     an #AdgDress
 312  * @fallback: (transfer full): the new fallback style
 313  *
 314  * Associates a new @fallback style to @dress. If the dress does
 315  * not exist (it was not previously created by adg_dress_new()),
 316  * a warning message is raised and the function fails.
 317  *
 318  * @fallback is checked for compatibily with @dress. Any dress holds
 319  * an ancestor type: if this type is not found in the @fallback
 320  * hierarchy, a warning message is raised and the function fails.
 321  *
 322  * After a succesfull call, the reference to the previous fallback
 323  * (if any) is dropped while a new reference to @fallback is added.
 324  *
 325  * Since: 1.0
 326  **/
 327 void
 328 adg_dress_set_fallback(AdgDress dress, AdgStyle *fallback)
 329 {
 330     AdgDressPrivate *data = _adg_data_lookup(dress);
 331
 332     g_return_if_fail(data != NULL);
 333
 334     if (data->fallback == fallback)
 335         return;
 336
 337     /* Check if the new fallback style is compatible with this dress */
 338     if (fallback != NULL && !adg_dress_style_is_compatible(dress, fallback)) {
 339         g_warning(_("%s: the fallback style of `%d' (%s) must be a `%s' derived type, but a `%s' has been provided"),
 340                   G_STRLOC, dress, adg_dress_get_name(dress),
 341                   g_type_name(data->ancestor_type),
 342                   g_type_name(G_TYPE_FROM_INSTANCE(fallback)));
 343         return;
 344     }
 345
 346     if (data->fallback != NULL)
 347         g_object_unref(data->fallback);
 348
 349     data->fallback = fallback;
 350
 351     if (data->fallback != NULL)
 352         g_object_ref(data->fallback);
 353 }
 354
 355 /**
 356  * adg_dress_get_fallback:
 357  * @dress: an #AdgDress
 358  *
 359  * Gets the fallback style associated to @dress. No warnings
 360  * are raised if the dress is not found. The returned style
 361  * is owned by dress and should not be freed or modified.
 362  *
 363  * Returns: (transfer none): the requested #AdgStyle derived instance or %NULL if not set.
 364  *
 365  * Since: 1.0
 366  **/
 367 AdgStyle *
 368 adg_dress_get_fallback(AdgDress dress)
 369 {
 370     AdgDressPrivate *data = _adg_data_lookup(dress);
 371     return data != NULL ? data->fallback : NULL;
 372 }
 373
 374 /**
 375  * adg_dress_style_is_compatible:
 376  * @dress:                  an #AdgDress
 377  * @style: (transfer none): the #AdgStyle to check
 378  *
 379  * Checks whether @style is compatible with @dress, that is if
 380  * @style has the ancestor style type (as returned by
 381  * adg_dress_get_ancestor_type()) in its hierarchy.
 382  *
 383  * Returns: %TRUE if @dress can accept @style, %FALSE otherwise.
 384  *
 385  * Since: 1.0
 386  **/
 387 gboolean
 388 adg_dress_style_is_compatible(AdgDress dress, AdgStyle *style)
 389 {
 390     GType ancestor_type = adg_dress_get_ancestor_type(dress);
 391
 392     g_return_val_if_fail(ancestor_type > 0, FALSE);
 393     g_return_val_if_fail(ADG_IS_STYLE(style), FALSE);
 394
 395     return G_TYPE_CHECK_INSTANCE_TYPE(style, ancestor_type);
 396 }
 397
 398
 399 static GArray *
 400 _adg_data_array(void)
 401 {
 402     /* The following register keeps track of the metadata bound to every
 403      * #AdgDress value, such as the fallback style and the ancestor type.
 404      *
 405      * The AdgDress value is cohincident with the index of its metadata
 406      * inside this register, that is if %ADG_DRESS_COLOR_BACKGROUND is 2,
 407      * array->data[2] will contain its metadata.
 408      */
 409     static GArray *array = NULL;
 410
 411     if (G_UNLIKELY(array == NULL)) {
 412         array = g_array_new(FALSE, FALSE, sizeof(AdgDressPrivate));
 413         _adg_data_register_builtins();
 414     }
 415
 416     return array;
 417 }
 418
 419 static void
 420 _adg_data_register(AdgDress dress, AdgStyle *fallback, GType ancestor_type)
 421 {
 422     GArray         *array = _adg_data_array();
 423     AdgDressPrivate data;
 424
 425     data.fallback = fallback;
 426     data.ancestor_type = ancestor_type;
 427
 428     g_array_insert_vals(array, dress, g_memdup(&data, sizeof(data)), 1);
 429 }
 430
 431 static void
 432 _adg_data_register_builtins(void)
 433 {
 434     AdgDash *dash;
 435     AdgMarker *arrow1, *arrow2;
 436
 437     _adg_data_register(ADG_DRESS_UNDEFINED,
 438                        NULL,
 439                        G_TYPE_INVALID);
 440
 441
 442     /* Predefined colors */
 443
 444     _adg_data_register(ADG_DRESS_COLOR,
 445                        NULL,
 446                        ADG_TYPE_COLOR_STYLE);
 447
 448     _adg_data_register(ADG_DRESS_COLOR_BACKGROUND,
 449                        g_object_new(ADG_TYPE_COLOR_STYLE,
 450                                     "blue",  1.,
 451                                     "green", 1.,
 452                                     "red",   1.,
 453                                     NULL),
 454                        ADG_TYPE_COLOR_STYLE);
 455
 456     _adg_data_register(ADG_DRESS_COLOR_STROKE,
 457                        g_object_new(ADG_TYPE_COLOR_STYLE,
 458                                     NULL),
 459                        ADG_TYPE_COLOR_STYLE);
 460
 461     _adg_data_register(ADG_DRESS_COLOR_DIMENSION,
 462                        g_object_new(ADG_TYPE_COLOR_STYLE,
 463                                     "red",   0.,
 464                                     "green", 0.4,
 465                                     "blue",  0.6,
 466                                     NULL),
 467                        ADG_TYPE_COLOR_STYLE);
 468
 469     _adg_data_register(ADG_DRESS_COLOR_ANNOTATION,
 470                        g_object_new(ADG_TYPE_COLOR_STYLE,
 471                                     "red",   0.4,
 472                                     "green", 0.4,
 473                                     "blue",  0.2,
 474                                     NULL),
 475                        ADG_TYPE_COLOR_STYLE);
 476
 477     _adg_data_register(ADG_DRESS_COLOR_FILL,
 478                        g_object_new(ADG_TYPE_COLOR_STYLE,
 479                                     "red",   0.25,
 480                                     "green", 0.25,
 481                                     "blue",  0.25,
 482                                     NULL),
 483                        ADG_TYPE_COLOR_STYLE);
 484
 485     _adg_data_register(ADG_DRESS_COLOR_AXIS,
 486                        g_object_new(ADG_TYPE_COLOR_STYLE,
 487                                     "red",   0.,
 488                                     "green", 0.75,
 489                                     "blue",  0.25,
 490                                     NULL),
 491                        ADG_TYPE_COLOR_STYLE);
 492
 493     _adg_data_register(ADG_DRESS_COLOR_HIDDEN,
 494                        g_object_new(ADG_TYPE_COLOR_STYLE,
 495                                     "red",   0.5,
 496                                     "green", 0.5,
 497                                     "blue",  0.5,
 498                                     NULL),
 499                        ADG_TYPE_COLOR_STYLE);
 500
 501
 502     /* Predefined lines */
 503
 504     _adg_data_register(ADG_DRESS_LINE,
 505                        NULL,
 506                        ADG_TYPE_LINE_STYLE);
 507
 508     _adg_data_register(ADG_DRESS_LINE_STROKE,
 509                        g_object_new(ADG_TYPE_LINE_STYLE,
 510                                     "color-dress", ADG_DRESS_COLOR_STROKE,
 511                                     "width",       1.5,
 512                                     NULL),
 513                        ADG_TYPE_LINE_STYLE);
 514
 515     _adg_data_register(ADG_DRESS_LINE_DIMENSION,
 516                        g_object_new(ADG_TYPE_LINE_STYLE,
 517                                     "width", 0.5,
 518                                     NULL),
 519                        ADG_TYPE_LINE_STYLE);
 520
 521     _adg_data_register(ADG_DRESS_LINE_FILL,
 522                        g_object_new(ADG_TYPE_LINE_STYLE,
 523                                     "color-dress", ADG_DRESS_COLOR_FILL,
 524                                     "width",       0.5,
 525                                     NULL),
 526                        ADG_TYPE_LINE_STYLE);
 527
 528     _adg_data_register(ADG_DRESS_LINE_GRID,
 529                        g_object_new(ADG_TYPE_LINE_STYLE,
 530                                     "antialias", CAIRO_ANTIALIAS_NONE,
 531                                     "width",     1.,
 532                                     NULL),
 533                        ADG_TYPE_LINE_STYLE);
 534
 535     _adg_data_register(ADG_DRESS_LINE_FRAME,
 536                        g_object_new(ADG_TYPE_LINE_STYLE,
 537                                     "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 538                                     "antialias",   CAIRO_ANTIALIAS_NONE,
 539                                     "width",       2.,
 540                                     NULL),
 541                        ADG_TYPE_LINE_STYLE);
 542
 543
 544     dash = adg_dash_new_with_dashes(4, 2 MM, 2 MM, 10 MM, 2 MM);
 545     _adg_data_register(ADG_DRESS_LINE_AXIS,
 546                        g_object_new(ADG_TYPE_LINE_STYLE,
 547                                     "color-dress", ADG_DRESS_COLOR_AXIS,
 548                                     "width",       0.25 MM,
 549                                     "dash",        dash,
 550                                     NULL),
 551                        ADG_TYPE_LINE_STYLE);
 552     adg_dash_destroy(dash);
 553
 554     dash = adg_dash_new_with_dashes(2, 6 MM, 6 MM);
 555     _adg_data_register(ADG_DRESS_LINE_HIDDEN,
 556                        g_object_new(ADG_TYPE_LINE_STYLE,
 557                                     "color-dress", ADG_DRESS_COLOR_HIDDEN,
 558                                     "width",       0.25 MM,
 559                                     "dash",        dash,
 560                                     NULL),
 561                        ADG_TYPE_LINE_STYLE);
 562     adg_dash_destroy(dash);
 563
 564
 565     /* Predefined fonts */
 566
 567     _adg_data_register(ADG_DRESS_FONT,
 568                        g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 569                                     "family", "Serif",
 570                                     "size",   14.,
 571                                     NULL),
 572                        ADG_TYPE_BEST_FONT_STYLE);
 573
 574     _adg_data_register(ADG_DRESS_FONT_TEXT,
 575                        g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 576                                     "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 577                                     "family",      "Sans",
 578                                     "weight",      CAIRO_FONT_WEIGHT_BOLD,
 579                                     "size",        12.,
 580                                     NULL),
 581                        ADG_TYPE_BEST_FONT_STYLE);
 582
 583     _adg_data_register(ADG_DRESS_FONT_ANNOTATION,
 584                        g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 585                                     "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 586                                     "family",      "Sans",
 587                                     "size",        8.,
 588                                     NULL),
 589                        ADG_TYPE_BEST_FONT_STYLE);
 590
 591     _adg_data_register(ADG_DRESS_FONT_QUOTE_TEXT,
 592                        g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 593                                     "family", "Sans",
 594                                     "weight", CAIRO_FONT_WEIGHT_BOLD,
 595                                     "size",   12.,
 596                                     NULL),
 597                        ADG_TYPE_BEST_FONT_STYLE);
 598
 599     _adg_data_register(ADG_DRESS_FONT_QUOTE_ANNOTATION,
 600                        g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 601                                     "family",      "Sans",
 602                                     "size",        8.,
 603                                     NULL),
 604                        ADG_TYPE_BEST_FONT_STYLE);
 605
 606
 607     /* Predefined dimension styles */
 608
 609     arrow1 = (AdgMarker *) adg_arrow_new();
 610     arrow2 = (AdgMarker *) adg_arrow_new();
 611     adg_marker_set_pos(arrow2, 1);
 612     _adg_data_register(ADG_DRESS_DIMENSION,
 613                        g_object_new(ADG_TYPE_DIM_STYLE,
 614                                     "marker1", arrow1,
 615                                     "marker2", arrow2,
 616                                     NULL),
 617                        ADG_TYPE_DIM_STYLE);
 618     g_object_unref(arrow1);
 619     g_object_unref(arrow2);
 620
 621
 622     /* Predefined fill styles */
 623
 624     _adg_data_register(ADG_DRESS_FILL,
 625                        NULL,
 626                        ADG_TYPE_FILL_STYLE);
 627
 628     _adg_data_register(ADG_DRESS_FILL_HATCH,
 629                        g_object_new(ADG_TYPE_RULED_FILL,
 630                                     "line-dress", ADG_DRESS_LINE_FILL,
 631                                     NULL),
 632                        ADG_TYPE_FILL_STYLE);
 633
 634
 635     /* Predefined table styles */
 636
 637     _adg_data_register(ADG_DRESS_TABLE,
 638                        g_object_new(ADG_TYPE_TABLE_STYLE, NULL),
 639                        ADG_TYPE_TABLE_STYLE);
 640 }
 641
 642 static AdgDressPrivate *
 643 _adg_data_lookup(AdgDress dress)
 644 {
 645     GArray *array = _adg_data_array();
 646
 647     if (dress >= array->len)
 648         return NULL;
 649
 650     return ((AdgDressPrivate *) array->data) + dress;
 651 }