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