src/adg/adg-dress-builtins.c

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