adg/adg-dress-builtins.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009 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
  32
  33 #include "adg-dress-builtins.h"
  34 #include "adg-color-style.h"
  35 #include "adg-line-style.h"
  36 #include "adg-font-style.h"
  37 #include "adg-dim-style.h"
  38 #include "adg-arrow.h"
  39 #include "adg-ruled-fill.h"
  40 #include "adg-table-style.h"
  41
  42
  43 /**
  44  * ADG_DRESS_UNDEFINED:
  45  *
  46  * A value reperesenting an undefined #AdgDress.
  47  **/
  48
  49 /**
  50  * ADG_DRESS_COLOR:
  51  *
  52  * The default builtin #AdgDress color. This is a transparent dress
  53  * without a fallback style.
  54  *
  55  * This dress will be resolved to an #AdgColorStyle instance.
  56  **/
  57 AdgDress
  58 _adg_dress_color(void)
  59 {
  60     static AdgDress dress = 0;
  61
  62     if (G_UNLIKELY(dress == 0)) {
  63         dress = adg_dress_new_full("color", NULL, ADG_TYPE_COLOR_STYLE);
  64     }
  65
  66     return dress;
  67 }
  68
  69 /**
  70  * ADG_DRESS_COLOR_STROKE:
  71  *
  72  * The default builtin #AdgDress color for #AdgStroke entities.
  73  * The fallback style is the default implementation of #AdgColor
  74  * (that is %black).
  75  *
  76  * This dress will be resolved to an #AdgColorStyle instance.
  77  **/
  78 AdgDress
  79 _adg_dress_color_stroke(void)
  80 {
  81     static AdgDress dress = 0;
  82
  83     if (G_UNLIKELY(dress == 0)) {
  84         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE, NULL);
  85
  86         dress = adg_dress_new("color-stroke", fallback);
  87         g_object_unref(fallback);
  88     }
  89
  90     return dress;
  91 }
  92
  93 /**
  94  * ADG_DRESS_COLOR_DIMENSION:
  95  *
  96  * The builtin #AdgDress color used by default in #AdgDimStyle.
  97  * The fallback style is a %0.75 red.
  98  *
  99  * This dress will be resolved to an #AdgColorStyle instance.
 100  **/
 101 AdgDress
 102 _adg_dress_color_dimension(void)
 103 {
 104     static AdgDress dress = 0;
 105
 106     if (G_UNLIKELY(dress == 0)) {
 107         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 108                                           "red", 0.667, NULL);
 109
 110         dress = adg_dress_new("color-dimension", fallback);
 111         g_object_unref(fallback);
 112     }
 113
 114     return dress;
 115 }
 116
 117 /**
 118  * ADG_DRESS_COLOR_HATCH:
 119  *
 120  * The default builtin #AdgDress color for #AdgHatch entities.
 121  * The fallback style is a %0.5 blue.
 122  *
 123  * This dress will be resolved to an #AdgColorStyle instance.
 124  **/
 125 AdgDress
 126 _adg_dress_color_hatch(void)
 127 {
 128     static AdgDress dress = 0;
 129
 130     if (G_UNLIKELY(dress == 0)) {
 131         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 132                                           "blue", 0.333, NULL);
 133
 134         dress = adg_dress_new("color-hatch", fallback);
 135         g_object_unref(fallback);
 136     }
 137
 138     return dress;
 139 }
 140
 141 /**
 142  * ADG_DRESS_LINE:
 143  *
 144  * The default builtin #AdgDress line. This is a transparent dress
 145  * without a fallback style.
 146  *
 147  * This dress will be resolved to an #AdgLineStyle instance.
 148  **/
 149 AdgDress
 150 _adg_dress_line(void)
 151 {
 152     static AdgDress dress = 0;
 153
 154     if (G_UNLIKELY(dress == 0)) {
 155         dress = adg_dress_new_full("line", NULL, ADG_TYPE_LINE_STYLE);
 156     }
 157
 158     return dress;
 159 }
 160
 161 /**
 162  * ADG_DRESS_LINE_MEDIUM:
 163  *
 164  * The default generic builtin #AdgDress line type: it is used by
 165  * default for rendering #AdgStroke entities. The fallback style
 166  * is a default line with a thickness of %1.5.
 167  *
 168  * This dress will be resolved to an #AdgLineStyle instance.
 169  **/
 170 AdgDress
 171 _adg_dress_line_medium(void)
 172 {
 173     static AdgDress dress = 0;
 174
 175     if (G_UNLIKELY(dress == 0)) {
 176         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 177                                           "width", 1.5, NULL);
 178
 179         dress = adg_dress_new("line-medium", fallback);
 180         g_object_unref(fallback);
 181     }
 182
 183     return dress;
 184 }
 185
 186 /**
 187  * ADG_DRESS_LINE_THIN:
 188  *
 189  * A generic builtin #AdgDress line type for thin lines.
 190  * The fallback style is a default line with a thickness of %1.
 191  *
 192  * This dress will be resolved to an #AdgLineStyle instance.
 193  **/
 194 AdgDress
 195 _adg_dress_line_thin(void)
 196 {
 197     static AdgDress dress = 0;
 198
 199     if (G_UNLIKELY(dress == 0)) {
 200         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 201                                           "width", 1., NULL);
 202
 203         dress = adg_dress_new("line-thin", fallback);
 204         g_object_unref(fallback);
 205     }
 206
 207     return dress;
 208 }
 209
 210 /**
 211  * ADG_DRESS_LINE_THICK:
 212  *
 213  * A generic builtin #AdgDress line type for thick lines.
 214  * The fallback style is a default line with a thickness of %2.
 215  *
 216  * This dress will be resolved to an #AdgLineStyle instance.
 217  **/
 218 AdgDress
 219 _adg_dress_line_thick(void)
 220 {
 221     static AdgDress dress = 0;
 222
 223     if (G_UNLIKELY(dress == 0)) {
 224         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 225                                           "width", 2., NULL);
 226
 227         dress = adg_dress_new("line-thick", fallback);
 228         g_object_unref(fallback);
 229     }
 230
 231     return dress;
 232 }
 233
 234 /**
 235  * ADG_DRESS_LINE_THINNER:
 236  *
 237  * A generic builtin #AdgDress line type for really thin lines:
 238  * it is used by default for rendering base and extension lines
 239  * of dimension entities. The fallback style is a default line
 240  * with a thickness of %0.75.
 241  *
 242  * This dress will be resolved to an #AdgLineStyle instance.
 243  **/
 244 AdgDress
 245 _adg_dress_line_thinner(void)
 246 {
 247     static AdgDress dress = 0;
 248
 249     if (G_UNLIKELY(dress == 0)) {
 250         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 251                                           "width", 0.75, NULL);
 252
 253         dress = adg_dress_new("line-thinner", fallback);
 254         g_object_unref(fallback);
 255     }
 256
 257     return dress;
 258 }
 259
 260 /**
 261  * ADG_DRESS_LINE_THICKER:
 262  *
 263  * A generic builtin #AdgDress line type for really thick lines.
 264  * The fallback style is a default line with a thickness of %2.5.
 265  *
 266  * This dress will be resolved to an #AdgLineStyle instance.
 267  **/
 268 AdgDress
 269 _adg_dress_line_thicker(void)
 270 {
 271     static AdgDress dress = 0;
 272
 273     if (G_UNLIKELY(dress == 0)) {
 274         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 275                                           "width", 2.5, NULL);
 276
 277         dress = adg_dress_new("line-thicker", fallback);
 278         g_object_unref(fallback);
 279     }
 280
 281     return dress;
 282 }
 283
 284 /**
 285  * ADG_DRESS_LINE_HATCH:
 286  *
 287  * The builtin #AdgDress line type used by the default #AdgRuledFill
 288  * style implementation. The fallback style is a default line with
 289  * a thickness of %1 and an #ADG_DRESS_COLOR_HATCH color dress.
 290  *
 291  * This dress will be resolved to an #AdgLineStyle instance.
 292  **/
 293 AdgDress
 294 _adg_dress_line_hatch(void)
 295 {
 296     static AdgDress dress = 0;
 297
 298     if (G_UNLIKELY(dress == 0)) {
 299         AdgLineStyle *thin_style;
 300         AdgStyle *fallback;
 301
 302         thin_style = (AdgLineStyle *) adg_dress_get_fallback(ADG_DRESS_LINE_THIN);
 303         fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 304                                 "width", adg_line_style_get_width(thin_style),
 305                                 "color-dress", ADG_DRESS_COLOR_HATCH, NULL);
 306
 307         dress = adg_dress_new("line-hatch", fallback);
 308         g_object_unref(fallback);
 309     }
 310
 311     return dress;
 312 }
 313
 314 /**
 315  * ADG_DRESS_LINE_GRID:
 316  *
 317  * The builtin #AdgDress line type used for rendering grids of
 318  * #AdgTable entities. The fallback style is a default line with
 319  * a thickness of %1 and no antialiasing.
 320  *
 321  * This dress will be resolved to an #AdgLineStyle instance.
 322  **/
 323 AdgDress
 324 _adg_dress_line_grid(void)
 325 {
 326     static AdgDress dress = 0;
 327
 328     if (G_UNLIKELY(dress == 0)) {
 329         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 330                                           "antialias", CAIRO_ANTIALIAS_NONE,
 331                                           "width", 1., NULL);
 332
 333         dress = adg_dress_new("line-grid", fallback);
 334         g_object_unref(fallback);
 335     }
 336
 337     return dress;
 338 }
 339
 340 /**
 341  * ADG_DRESS_LINE_FRAME:
 342  *
 343  * The builtin #AdgDress line type used for rendering frames of
 344  * #AdgTable entities. The fallback style is a default line with
 345  * a thickness of %2 and no antialiasing.
 346  *
 347  * This dress will be resolved to an #AdgLineStyle instance.
 348  **/
 349 AdgDress
 350 _adg_dress_line_frame(void)
 351 {
 352     static AdgDress dress = 0;
 353
 354     if (G_UNLIKELY(dress == 0)) {
 355         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 356                                           "antialias", CAIRO_ANTIALIAS_NONE,
 357                                           "width", 2., NULL);
 358
 359         dress = adg_dress_new("line-frame", fallback);
 360         g_object_unref(fallback);
 361     }
 362
 363     return dress;
 364 }
 365
 366 /**
 367  * ADG_DRESS_TEXT:
 368  *
 369  * The default builtin #AdgDress font. The fallback style is
 370  * %Sans %14.
 371  *
 372  * This dress will be resolved to an #AdgFontStyle instance.
 373  **/
 374 AdgDress
 375 _adg_dress_text(void)
 376 {
 377     static AdgDress dress = 0;
 378
 379     if (G_UNLIKELY(dress == 0)) {
 380         AdgStyle *fallback = g_object_new(ADG_TYPE_FONT_STYLE,
 381                                           "family", "Serif",
 382                                           "size", 14., NULL);
 383
 384         dress = adg_dress_new("text", fallback);
 385         g_object_unref(fallback);
 386     }
 387
 388     return dress;
 389 }
 390
 391 /**
 392  * ADG_DRESS_TEXT_VALUE:
 393  *
 394  * The builtin #AdgDress font used to render the nominal value of a
 395  * dimension. The fallback style is %Sans %12 %bold.
 396  *
 397  * This dress will be resolved to an #AdgFontStyle instance.
 398  **/
 399 AdgDress
 400 _adg_dress_text_value(void)
 401 {
 402     static AdgDress dress = 0;
 403
 404     if (G_UNLIKELY(dress == 0)) {
 405         AdgStyle *fallback = g_object_new(ADG_TYPE_FONT_STYLE,
 406                                           "family", "Sans",
 407                                           "weight", CAIRO_FONT_WEIGHT_BOLD,
 408                                           "size", 12., NULL);
 409
 410         dress = adg_dress_new("text-value", fallback);
 411         g_object_unref(fallback);
 412     }
 413
 414     return dress;
 415 }
 416
 417 /**
 418  * ADG_DRESS_TEXT_LIMIT:
 419  *
 420  * The builtin #AdgDress font used to render the limits of either
 421  * the min and max values of a dimension. The fallback style
 422  * is a %Sans %8.
 423  *
 424  * This dress will be resolved to an #AdgFontStyle instance.
 425  **/
 426 AdgDress
 427 _adg_dress_text_limit(void)
 428 {
 429     static AdgDress dress = 0;
 430
 431     if (G_UNLIKELY(dress == 0)) {
 432         AdgStyle *fallback = g_object_new(ADG_TYPE_FONT_STYLE,
 433                                           "family", "Sans",
 434                                           "size", 8., NULL);
 435
 436         dress = adg_dress_new("text-limit", fallback);
 437         g_object_unref(fallback);
 438     }
 439
 440     return dress;
 441 }
 442
 443 /**
 444  * ADG_DRESS_DIMENSION:
 445  *
 446  * The default builtin #AdgDress for dimensioning. The fallback
 447  * style is the default #AdgDimStyle implementation with #AdgArrow
 448  * as markers on both sides.
 449  *
 450  * This dress will be resolved to an #AdgDimStyle instance.
 451  **/
 452 AdgDress
 453 _adg_dress_dimension(void)
 454 {
 455     static AdgDress dress = 0;
 456
 457     if (G_UNLIKELY(dress == 0)) {
 458         AdgMarker *arrow = g_object_new(ADG_TYPE_ARROW, NULL);
 459         AdgStyle *fallback = g_object_new(ADG_TYPE_DIM_STYLE, NULL);
 460
 461         adg_dim_style_use_marker1((AdgDimStyle *) fallback, arrow);
 462         adg_marker_set_pos(arrow, 1);
 463         adg_dim_style_use_marker2((AdgDimStyle *) fallback, arrow);
 464
 465         dress = adg_dress_new("dimension", fallback);
 466         g_object_unref(fallback);
 467         g_object_unref(arrow);
 468     }
 469
 470     return dress;
 471 }
 472
 473 /**
 474  * ADG_DRESS_FILL:
 475  *
 476  * The default builtin #AdgDress for filling. This is a transparent
 477  * dress without a fallback style.
 478  *
 479  * This dress will be resolved to an #AdgFillStyle derived instance.
 480  **/
 481 AdgDress
 482 _adg_dress_fill(void)
 483 {
 484     static AdgDress dress = 0;
 485
 486     if (G_UNLIKELY(dress == 0)) {
 487         dress = adg_dress_new_full("fill", NULL, ADG_TYPE_FILL_STYLE);
 488     }
 489
 490     return dress;
 491 }
 492
 493 /**
 494  * ADG_DRESS_FILL_HATCH:
 495  *
 496  * The default builtin #AdgDress used by #AdgHatch instances.
 497  * The fallback style is the default implementation of the
 498  * #AdgRuledFill instance.
 499  *
 500  * This dress will be resolved to an #AdgFillStyle derived instance.
 501  **/
 502 AdgDress
 503 _adg_dress_fill_hatch(void)
 504 {
 505     static AdgDress dress = 0;
 506
 507     if (G_UNLIKELY(dress == 0)) {
 508         AdgStyle *fallback = g_object_new(ADG_TYPE_RULED_FILL,
 509                                           "line-dress", ADG_DRESS_LINE_HATCH,
 510                                           NULL);
 511
 512         dress = adg_dress_new_full("fill-hatch", fallback,
 513                                    ADG_TYPE_FILL_STYLE);
 514         g_object_unref(fallback);
 515     }
 516
 517     return dress;
 518 }
 519
 520 /**
 521  * ADG_DRESS_TABLE:
 522  *
 523  * The default builtin #AdgDress for tables. The fallback style
 524  * is the default implementation of the #AdgTableStyle instance.
 525  *
 526  * This dress will be resolved to an #AdgTableStyle derived instance.
 527  **/
 528 AdgDress
 529 _adg_dress_table(void)
 530 {
 531     static AdgDress dress = 0;
 532
 533     if (G_UNLIKELY(dress == 0)) {
 534         AdgStyle *fallback = g_object_new(ADG_TYPE_TABLE_STYLE, NULL);
 535         dress = adg_dress_new_full("table", fallback, ADG_TYPE_TABLE_STYLE);
 536         g_object_unref(fallback);
 537     }
 538
 539     return dress;
 540 }