src/adg/adg-dress-builtins.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012  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-builtins
  23  * @Section_Id:dress-builtins
  24  * @title: Built-in dresses
  25  * @short_description: A list of predefined dresses implemented
  26  *                     by the ADG canvas
  27  *
  28  * This is a collection of built-it dresses used internally by
  29  * the ADG library to provide some useful defaults.
  30  *
  31  * Since: 1.0
  32  **/
  33
  34
  35 #include "adg-internal.h"
  36 #include "adg-text-internal.h"
  37
  38 #include "adg-model.h"
  39 #include "adg-trail.h"
  40 #include "adg-marker.h"
  41 #include "adg-dress.h"
  42 #include "adg-color-style.h"
  43 #include "adg-dash.h"
  44 #include "adg-line-style.h"
  45 #include "adg-fill-style.h"
  46 #include "adg-dim-style.h"
  47 #include "adg-table-style.h"
  48 #include "adg-arrow.h"
  49 #include "adg-ruled-fill.h"
  50
  51 #include "adg-dress-builtins.h"
  52
  53 #define MM  *2.83464566927
  54
  55
  56 /**
  57  * ADG_DRESS_UNDEFINED:
  58  *
  59  * A value reperesenting an undefined #AdgDress.
  60  *
  61  * Since: 1.0
  62  **/
  63
  64 /**
  65  * ADG_DRESS_COLOR:
  66  *
  67  * The default builtin #AdgDress color.
  68  * This is a pass-through dress, that is it does not change
  69  * the cairo context when it is applied.
  70  *
  71  * This dress will be resolved to an #AdgColorStyle instance.
  72  *
  73  * Since: 1.0
  74  **/
  75 AdgDress
  76 _adg_dress_color(void)
  77 {
  78     static AdgDress dress = 0;
  79
  80     if (G_UNLIKELY(dress == 0)) {
  81         dress = adg_dress_new_full("color", NULL, ADG_TYPE_COLOR_STYLE);
  82     }
  83
  84     return dress;
  85 }
  86
  87 /**
  88  * ADG_DRESS_COLOR_BACKGROUND:
  89  *
  90  * The default builtin #AdgDress color to be used as the #AdgCanvas
  91  * background. The fallback style is a full opaque white.
  92  *
  93  * This dress will be resolved to an #AdgColorStyle instance.
  94  *
  95  * Since: 1.0
  96  **/
  97 AdgDress
  98 _adg_dress_color_background(void)
  99 {
 100     static AdgDress dress = 0;
 101
 102     if (G_UNLIKELY(dress == 0)) {
 103         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 104                                           "blue", 1., "green", 1.,
 105                                           "red", 1., NULL);
 106
 107         dress = adg_dress_new("color-background", fallback);
 108         g_object_unref(fallback);
 109     }
 110
 111     return dress;
 112 }
 113
 114 /**
 115  * ADG_DRESS_COLOR_STROKE:
 116  *
 117  * The default builtin #AdgDress color for #AdgStroke entities.
 118  * The fallback style is a full opaque black.
 119  *
 120  * This dress will be resolved to an #AdgColorStyle instance.
 121  *
 122  * Since: 1.0
 123  **/
 124 AdgDress
 125 _adg_dress_color_stroke(void)
 126 {
 127     static AdgDress dress = 0;
 128
 129     if (G_UNLIKELY(dress == 0)) {
 130         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE, NULL);
 131
 132         dress = adg_dress_new("color-stroke", fallback);
 133         g_object_unref(fallback);
 134     }
 135
 136     return dress;
 137 }
 138
 139 /**
 140  * ADG_DRESS_COLOR_DIMENSION:
 141  *
 142  * The builtin #AdgDress color used by default in #AdgDimStyle.
 143  * The fallback style is a somewhat full opaque blue.
 144  *
 145  * This dress will be resolved to an #AdgColorStyle instance.
 146  *
 147  * Since: 1.0
 148  **/
 149 AdgDress
 150 _adg_dress_color_dimension(void)
 151 {
 152     static AdgDress dress = 0;
 153
 154     if (G_UNLIKELY(dress == 0)) {
 155         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 156                                           "red", 0.,
 157                                           "green", 0.4,
 158                                           "blue", 0.6,
 159                                           NULL);
 160
 161         dress = adg_dress_new("color-dimension", fallback);
 162         g_object_unref(fallback);
 163     }
 164
 165     return dress;
 166 }
 167
 168 /**
 169  * ADG_DRESS_COLOR_ANNOTATION:
 170  *
 171  * The builtin #AdgDress color used for rendering helper entities
 172  * such as #AdgToyText, #AdgTable and #AdgTitleBlock. The fallback
 173  * style is a full opaque greenish variant.
 174  *
 175  * This dress will be resolved to an #AdgColorStyle instance.
 176  *
 177  * Since: 1.0
 178  **/
 179 AdgDress
 180 _adg_dress_color_annotation(void)
 181 {
 182     static AdgDress dress = 0;
 183
 184     if (G_UNLIKELY(dress == 0)) {
 185         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 186                                           "red", 0.4,
 187                                           "green", 0.4,
 188                                           "blue", 0.2,
 189                                           NULL);
 190
 191         dress = adg_dress_new("color-annotation", fallback);
 192         g_object_unref(fallback);
 193     }
 194
 195     return dress;
 196 }
 197
 198 /**
 199  * ADG_DRESS_COLOR_FILL:
 200  *
 201  * The builtin #AdgDress color used by default by #AdgFillStyle
 202  * based styles. The fallback style is a full opaque %0.25 gray.
 203  *
 204  * This dress will be resolved to an #AdgColorStyle instance.
 205  *
 206  * Since: 1.0
 207  **/
 208 AdgDress
 209 _adg_dress_color_fill(void)
 210 {
 211     static AdgDress dress = 0;
 212
 213     if (G_UNLIKELY(dress == 0)) {
 214         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 215                                           "red", 0.25,
 216                                           "green", 0.25,
 217                                           "blue", 0.25, NULL);
 218
 219         dress = adg_dress_new("color-fill", fallback);
 220         g_object_unref(fallback);
 221     }
 222
 223     return dress;
 224 }
 225
 226 /**
 227  * ADG_DRESS_COLOR_AXIS:
 228  *
 229  * The default builtin #AdgDress color for stroking #ADG_DRESS_LINE_AXIS
 230  * lines. The fallback color is green.
 231  *
 232  * This dress will be resolved to an #AdgColorStyle instance.
 233  *
 234  * Since: 1.0
 235  **/
 236 AdgDress
 237 _adg_dress_color_axis(void)
 238 {
 239     static AdgDress dress = 0;
 240
 241     if (G_UNLIKELY(dress == 0)) {
 242         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 243                                           "red", 0.,
 244                                           "green", 0.75,
 245                                           "blue", 0.25, NULL);
 246
 247         dress = adg_dress_new("color-axis", fallback);
 248         g_object_unref(fallback);
 249     }
 250
 251     return dress;
 252 }
 253
 254 /**
 255  * ADG_DRESS_COLOR_HIDDEN:
 256  *
 257  * The default builtin #AdgDress color for stroking #ADG_DRESS_LINE_HIDDEN
 258  * lines. The fallback color is gray.
 259  *
 260  * This dress will be resolved to an #AdgColorStyle instance.
 261  *
 262  * Since: 1.0
 263  **/
 264 AdgDress
 265 _adg_dress_color_hidden(void)
 266 {
 267     static AdgDress dress = 0;
 268
 269     if (G_UNLIKELY(dress == 0)) {
 270         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 271                                           "red", 0.5,
 272                                           "green", 0.5,
 273                                           "blue", 0.5, NULL);
 274
 275         dress = adg_dress_new("color-hidden", fallback);
 276         g_object_unref(fallback);
 277     }
 278
 279     return dress;
 280 }
 281
 282 /**
 283  * ADG_DRESS_LINE:
 284  *
 285  * The default builtin #AdgDress line.
 286  * This is a pass-through dress, that is it does not change
 287  * the cairo context when it is applied.
 288  *
 289  * This dress will be resolved to an #AdgLineStyle instance.
 290  *
 291  * Since: 1.0
 292  **/
 293 AdgDress
 294 _adg_dress_line(void)
 295 {
 296     static AdgDress dress = 0;
 297
 298     if (G_UNLIKELY(dress == 0)) {
 299         dress = adg_dress_new_full("line", NULL, ADG_TYPE_LINE_STYLE);
 300     }
 301
 302     return dress;
 303 }
 304
 305 /**
 306  * ADG_DRESS_LINE_STROKE:
 307  *
 308  * The builtin #AdgDress line type to be used by default
 309  * for rendering #AdgStroke entities. The fallback style is
 310  * a line with #ADG_DRESS_COLOR_STROKE color and a thickness
 311  * of %1.5.
 312  *
 313  * This dress will be resolved to an #AdgLineStyle instance.
 314  *
 315  * Since: 1.0
 316  **/
 317 AdgDress
 318 _adg_dress_line_stroke(void)
 319 {
 320     static AdgDress dress = 0;
 321
 322     if (G_UNLIKELY(dress == 0)) {
 323         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 324                                           "color-dress", ADG_DRESS_COLOR_STROKE,
 325                                           "width", 1.5, NULL);
 326
 327         dress = adg_dress_new("line-stroke", fallback);
 328         g_object_unref(fallback);
 329     }
 330
 331     return dress;
 332 }
 333
 334 /**
 335  * ADG_DRESS_LINE_DIMENSION:
 336  *
 337  * The builtin #AdgDress line type used by default
 338  * for rendering base and extension lines of dimensions.
 339  * The fallback style is a line with a thickness of %0.5
 340  * and a pass-through color dress.
 341  *
 342  * This dress will be resolved to an #AdgLineStyle instance.
 343  *
 344  * Since: 1.0
 345  **/
 346 AdgDress
 347 _adg_dress_line_dimension(void)
 348 {
 349     static AdgDress dress = 0;
 350
 351     if (G_UNLIKELY(dress == 0)) {
 352         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 353                                           "width", 0.5, NULL);
 354
 355         dress = adg_dress_new("line-dimension", fallback);
 356         g_object_unref(fallback);
 357     }
 358
 359     return dress;
 360 }
 361
 362 /**
 363  * ADG_DRESS_LINE_FILL:
 364  *
 365  * The builtin #AdgDress line type used by #AdgFillStyle
 366  * based styles. The fallback style is a line with
 367  * #ADG_DRESS_COLOR_FILL color and a thickness of %0.5.
 368  *
 369  * This dress will be resolved to an #AdgLineStyle instance.
 370  *
 371  * Since: 1.0
 372  **/
 373 AdgDress
 374 _adg_dress_line_fill(void)
 375 {
 376     static AdgDress dress = 0;
 377
 378     if (G_UNLIKELY(dress == 0)) {
 379         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 380                                           "color-dress", ADG_DRESS_COLOR_FILL,
 381                                           "width", 0.5, NULL);
 382
 383         dress = adg_dress_new("line-fill", fallback);
 384         g_object_unref(fallback);
 385     }
 386
 387     return dress;
 388 }
 389
 390 /**
 391  * ADG_DRESS_LINE_GRID:
 392  *
 393  * The builtin #AdgDress line type used for rendering the grid
 394  * of #AdgTable entities, that is the frame of the cells.
 395  * The fallback style is a line with a thickness of %1 and a
 396  * pass-through color dress, rendered without antialiasing.
 397  *
 398  * This dress will be resolved to an #AdgLineStyle instance.
 399  *
 400  * Since: 1.0
 401  **/
 402 AdgDress
 403 _adg_dress_line_grid(void)
 404 {
 405     static AdgDress dress = 0;
 406
 407     if (G_UNLIKELY(dress == 0)) {
 408         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 409                                           "antialias", CAIRO_ANTIALIAS_NONE,
 410                                           "width", 1., NULL);
 411
 412         dress = adg_dress_new("line-grid", fallback);
 413         g_object_unref(fallback);
 414     }
 415
 416     return dress;
 417 }
 418
 419 /**
 420  * ADG_DRESS_LINE_FRAME:
 421  *
 422  * The builtin #AdgDress line type used for rendering the frame
 423  * of #AdgTable entities, that is the frame around the whole table.
 424  * The fallback style is a line with a thickness of %2 and a
 425  * #ADG_DRESS_COLOR_ANNOTATION color dress, rendered without
 426  * antialiasing.
 427  *
 428  * This dress will be resolved to an #AdgLineStyle instance.
 429  *
 430  * Since: 1.0
 431  **/
 432 AdgDress
 433 _adg_dress_line_frame(void)
 434 {
 435     static AdgDress dress = 0;
 436
 437     if (G_UNLIKELY(dress == 0)) {
 438         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 439                                           "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 440                                           "antialias", CAIRO_ANTIALIAS_NONE,
 441                                           "width", 2., NULL);
 442
 443         dress = adg_dress_new("line-frame", fallback);
 444         g_object_unref(fallback);
 445     }
 446
 447     return dress;
 448 }
 449
 450 /**
 451  * ADG_DRESS_LINE_AXIS:
 452  *
 453  * The builtin #AdgDress line type used for rendering axis and
 454  * centerlines.
 455  *
 456  * This dress will be resolved to an #AdgLineStyle instance.
 457  *
 458  * Since: 1.0
 459  **/
 460 AdgDress
 461 _adg_dress_line_axis(void)
 462 {
 463     static AdgDress dress = 0;
 464
 465     if (G_UNLIKELY(dress == 0)) {
 466         AdgDash *dash;
 467         AdgStyle *fallback;
 468
 469         dash = adg_dash_new_with_dashes(4, 2 MM, 2 MM, 10 MM, 2 MM);
 470         fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 471                                 "dash", dash,
 472                                 "color-dress", ADG_DRESS_COLOR_AXIS,
 473                                 "width", 0.25 MM, NULL);
 474         adg_dash_destroy(dash);
 475
 476         dress = adg_dress_new("line-axis", fallback);
 477         g_object_unref(fallback);
 478     }
 479
 480     return dress;
 481 }
 482
 483 /**
 484  * ADG_DRESS_LINE_HIDDEN:
 485  *
 486  * The builtin #AdgDress line type used for rendering hidden
 487  * lines and edges.
 488  *
 489  * This dress will be resolved to an #AdgLineStyle instance.
 490  *
 491  * Since: 1.0
 492  **/
 493 AdgDress
 494 _adg_dress_line_hidden(void)
 495 {
 496     static AdgDress dress = 0;
 497
 498     if (G_UNLIKELY(dress == 0)) {
 499         AdgDash *dash;
 500         AdgStyle *fallback;
 501
 502         dash = adg_dash_new_with_dashes(2, 6 MM, 6 MM);
 503         fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 504                                 "dash", dash,
 505                                 "color-dress", ADG_DRESS_COLOR_HIDDEN,
 506                                 "width", 0.25 MM, NULL);
 507         adg_dash_destroy(dash);
 508
 509         dress = adg_dress_new("line-hidden", fallback);
 510         g_object_unref(fallback);
 511     }
 512
 513     return dress;
 514 }
 515
 516 /**
 517  * ADG_DRESS_FONT:
 518  *
 519  * The default builtin #AdgDress font. The fallback style is
 520  * a %Sans %14 font with a pass-through color dress.
 521  *
 522  * This dress will be resolved to an #AdgFontStyle instance.
 523  *
 524  * Since: 1.0
 525  **/
 526 AdgDress
 527 _adg_dress_font(void)
 528 {
 529     static AdgDress dress = 0;
 530
 531     if (G_UNLIKELY(dress == 0)) {
 532         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 533                                           "family", "Serif",
 534                                           "size", 14., NULL);
 535
 536         dress = adg_dress_new("font", fallback);
 537         g_object_unref(fallback);
 538     }
 539
 540     return dress;
 541 }
 542
 543 /**
 544  * ADG_DRESS_FONT_TEXT:
 545  *
 546  * The builtin #AdgDress font used by default for rendering
 547  * common text such as #AdgToyText or the value of #AdgTable
 548  * entities. The fallback style is %Sans %12 %bold with an
 549  * #ADG_DRESS_COLOR_ANNOTATION color dress.
 550  *
 551  * This dress will be resolved to an #AdgFontStyle instance.
 552  *
 553  * Since: 1.0
 554  **/
 555 AdgDress
 556 _adg_dress_font_text(void)
 557 {
 558     static AdgDress dress = 0;
 559
 560     if (G_UNLIKELY(dress == 0)) {
 561         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 562                                           "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 563                                           "family", "Sans",
 564                                           "weight", CAIRO_FONT_WEIGHT_BOLD,
 565                                           "size", 12., NULL);
 566
 567         dress = adg_dress_new("font-text", fallback);
 568         g_object_unref(fallback);
 569     }
 570
 571     return dress;
 572 }
 573
 574 /**
 575  * ADG_DRESS_FONT_ANNOTATION:
 576  *
 577  * The builtin #AdgDress font used for rendering auxiliary text,
 578  * such as the titles on #AdgTable entities. The fallback style
 579  * is a %Sans %8 with an #ADG_DRESS_COLOR_ANNOTATION color dress.
 580  *
 581  * This dress will be resolved to an #AdgFontStyle instance.
 582  *
 583  * Since: 1.0
 584  **/
 585 AdgDress
 586 _adg_dress_font_annotation(void)
 587 {
 588     static AdgDress dress = 0;
 589
 590     if (G_UNLIKELY(dress == 0)) {
 591         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 592                                           "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 593                                           "family", "Sans",
 594                                           "size", 8., NULL);
 595
 596         dress = adg_dress_new("font-annotation", fallback);
 597         g_object_unref(fallback);
 598     }
 599
 600     return dress;
 601 }
 602
 603 /**
 604  * ADG_DRESS_FONT_QUOTE_TEXT:
 605  *
 606  * The builtin #AdgDress font used for rendering regular text
 607  * on dimension entities, such as the nominal value and the
 608  * notes of a quote. The fallback style is %Sans %12 %bold with
 609  * a pass-through color dress.
 610  *
 611  * This dress will be resolved to an #AdgFontStyle instance.
 612  *
 613  * Since: 1.0
 614  **/
 615 AdgDress
 616 _adg_dress_font_quote_text(void)
 617 {
 618     static AdgDress dress = 0;
 619
 620     if (G_UNLIKELY(dress == 0)) {
 621         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 622                                           "family", "Sans",
 623                                           "weight", CAIRO_FONT_WEIGHT_BOLD,
 624                                           "size", 12., NULL);
 625
 626         dress = adg_dress_new("font-quote-text", fallback);
 627         g_object_unref(fallback);
 628     }
 629
 630     return dress;
 631 }
 632
 633 /**
 634  * ADG_DRESS_FONT_QUOTE_ANNOTATION:
 635  *
 636  * The builtin #AdgDress font used for rendering auxiliary text
 637  * on dimension entities, such as the min and max limits of a
 638  * quote. The fallback style is a %Sans %8 with a pass-through
 639  * color dress.
 640  *
 641  * This dress will be resolved to an #AdgFontStyle instance.
 642  *
 643  * Since: 1.0
 644  **/
 645 AdgDress
 646 _adg_dress_font_quote_annotation(void)
 647 {
 648     static AdgDress dress = 0;
 649
 650     if (G_UNLIKELY(dress == 0)) {
 651         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 652                                           "family", "Sans",
 653                                           "size", 8., NULL);
 654
 655         dress = adg_dress_new("font-quote-annotation", fallback);
 656         g_object_unref(fallback);
 657     }
 658
 659     return dress;
 660 }
 661
 662 /**
 663  * ADG_DRESS_DIMENSION:
 664  *
 665  * The default builtin #AdgDress for dimensions. The fallback
 666  * style is the default #AdgDimStyle implementation with
 667  * #AdgArrow markers (as returned by adg_arrow_new() on both sides.
 668  *
 669  * This dress will be resolved to an #AdgDimStyle instance.
 670  *
 671  * Since: 1.0
 672  **/
 673 AdgDress
 674 _adg_dress_dimension(void)
 675 {
 676     static AdgDress dress = 0;
 677
 678     if (G_UNLIKELY(dress == 0)) {
 679         AdgMarker *arrow = (AdgMarker *) adg_arrow_new();
 680         AdgStyle *fallback = g_object_new(ADG_TYPE_DIM_STYLE, NULL);
 681
 682         adg_dim_style_set_marker1((AdgDimStyle *) fallback, arrow);
 683         adg_marker_set_pos(arrow, 1);
 684         adg_dim_style_set_marker2((AdgDimStyle *) fallback, arrow);
 685
 686         dress = adg_dress_new("dimension", fallback);
 687         g_object_unref(fallback);
 688         g_object_unref(arrow);
 689     }
 690
 691     return dress;
 692 }
 693
 694 /**
 695  * ADG_DRESS_FILL:
 696  *
 697  * The default builtin #AdgDress for filling.
 698  * This is a pass-through dress, that is it does not change
 699  * the cairo context when it is applied.
 700  *
 701  * This dress will be resolved to an #AdgFillStyle derived instance.
 702  *
 703  * Since: 1.0
 704  **/
 705 AdgDress
 706 _adg_dress_fill(void)
 707 {
 708     static AdgDress dress = 0;
 709
 710     if (G_UNLIKELY(dress == 0)) {
 711         dress = adg_dress_new_full("fill", NULL, ADG_TYPE_FILL_STYLE);
 712     }
 713
 714     return dress;
 715 }
 716
 717 /**
 718  * ADG_DRESS_FILL_HATCH:
 719  *
 720  * The builtin dress used by default by #AdgHatch instances.
 721  * The fallback style is the default implementation of the
 722  * #AdgRuledFill instance.
 723  *
 724  * This dress will be resolved to an #AdgFillStyle derived instance.
 725  *
 726  * Since: 1.0
 727  **/
 728 AdgDress
 729 _adg_dress_fill_hatch(void)
 730 {
 731     static AdgDress dress = 0;
 732
 733     if (G_UNLIKELY(dress == 0)) {
 734         AdgStyle *fallback = g_object_new(ADG_TYPE_RULED_FILL,
 735                                           "line-dress", ADG_DRESS_LINE_FILL,
 736                                           NULL);
 737
 738         dress = adg_dress_new_full("fill-hatch", fallback, ADG_TYPE_FILL_STYLE);
 739         g_object_unref(fallback);
 740     }
 741
 742     return dress;
 743 }
 744
 745 /**
 746  * ADG_DRESS_TABLE:
 747  *
 748  * The default builtin #AdgDress for tables. The fallback style
 749  * is the default implementation of the #AdgTableStyle instance.
 750  *
 751  * This dress will be resolved to an #AdgTableStyle derived instance.
 752  *
 753  * Since: 1.0
 754  **/
 755 AdgDress
 756 _adg_dress_table(void)
 757 {
 758     static AdgDress dress = 0;
 759
 760     if (G_UNLIKELY(dress == 0)) {
 761         AdgStyle *fallback = g_object_new(ADG_TYPE_TABLE_STYLE, NULL);
 762         dress = adg_dress_new_full("table", fallback, ADG_TYPE_TABLE_STYLE);
 763         g_object_unref(fallback);
 764     }
 765
 766     return dress;
 767 }