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-pattern.h"
  42 #include "adg-dress.h"
  43 #include "adg-color-style.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
  54 /**
  55  * ADG_DRESS_UNDEFINED:
  56  *
  57  * A value reperesenting an undefined #AdgDress.
  58  *
  59  * Since: 1.0
  60  **/
  61
  62 /**
  63  * ADG_DRESS_COLOR:
  64  *
  65  * The default builtin #AdgDress color.
  66  * This is a pass-through dress, that is it does not change
  67  * the cairo context when it is applied.
  68  *
  69  * This dress will be resolved to an #AdgColorStyle instance.
  70  *
  71  * Since: 1.0
  72  **/
  73 AdgDress
  74 _adg_dress_color(void)
  75 {
  76     static AdgDress dress = 0;
  77
  78     if (G_UNLIKELY(dress == 0)) {
  79         dress = adg_dress_new_full("color", NULL, ADG_TYPE_COLOR_STYLE);
  80     }
  81
  82     return dress;
  83 }
  84
  85 /**
  86  * ADG_DRESS_COLOR_BACKGROUND:
  87  *
  88  * The default builtin #AdgDress color to be used as the #AdgCanvas
  89  * background. The fallback style is a full opaque white.
  90  *
  91  * This dress will be resolved to an #AdgColorStyle instance.
  92  *
  93  * Since: 1.0
  94  **/
  95 AdgDress
  96 _adg_dress_color_background(void)
  97 {
  98     static AdgDress dress = 0;
  99
 100     if (G_UNLIKELY(dress == 0)) {
 101         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 102                                           "blue", 1., "green", 1.,
 103                                           "red", 1., NULL);
 104
 105         dress = adg_dress_new("color-background", fallback);
 106         g_object_unref(fallback);
 107     }
 108
 109     return dress;
 110 }
 111
 112 /**
 113  * ADG_DRESS_COLOR_STROKE:
 114  *
 115  * The default builtin #AdgDress color for #AdgStroke entities.
 116  * The fallback style is a full opaque black.
 117  *
 118  * This dress will be resolved to an #AdgColorStyle instance.
 119  *
 120  * Since: 1.0
 121  **/
 122 AdgDress
 123 _adg_dress_color_stroke(void)
 124 {
 125     static AdgDress dress = 0;
 126
 127     if (G_UNLIKELY(dress == 0)) {
 128         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE, NULL);
 129
 130         dress = adg_dress_new("color-stroke", fallback);
 131         g_object_unref(fallback);
 132     }
 133
 134     return dress;
 135 }
 136
 137 /**
 138  * ADG_DRESS_COLOR_DIMENSION:
 139  *
 140  * The builtin #AdgDress color used by default in #AdgDimStyle.
 141  * The fallback style is a somewhat full opaque blue.
 142  *
 143  * This dress will be resolved to an #AdgColorStyle instance.
 144  *
 145  * Since: 1.0
 146  **/
 147 AdgDress
 148 _adg_dress_color_dimension(void)
 149 {
 150     static AdgDress dress = 0;
 151
 152     if (G_UNLIKELY(dress == 0)) {
 153         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 154                                           "red", 0.,
 155                                           "green", 0.4,
 156                                           "blue", 0.6,
 157                                           NULL);
 158
 159         dress = adg_dress_new("color-dimension", fallback);
 160         g_object_unref(fallback);
 161     }
 162
 163     return dress;
 164 }
 165
 166 /**
 167  * ADG_DRESS_COLOR_ANNOTATION:
 168  *
 169  * The builtin #AdgDress color used for rendering helper entities
 170  * such as #AdgToyText, #AdgTable and #AdgTitleBlock. The fallback
 171  * style is a full opaque greenish variant.
 172  *
 173  * This dress will be resolved to an #AdgColorStyle instance.
 174  *
 175  * Since: 1.0
 176  **/
 177 AdgDress
 178 _adg_dress_color_annotation(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.4,
 185                                           "green", 0.4,
 186                                           "blue", 0.2,
 187                                           NULL);
 188
 189         dress = adg_dress_new("color-annotation", fallback);
 190         g_object_unref(fallback);
 191     }
 192
 193     return dress;
 194 }
 195
 196 /**
 197  * ADG_DRESS_COLOR_FILL:
 198  *
 199  * The builtin #AdgDress color used by default by #AdgFillStyle
 200  * based styles. The fallback style is a full opaque %0.25 gray.
 201  *
 202  * This dress will be resolved to an #AdgColorStyle instance.
 203  *
 204  * Since: 1.0
 205  **/
 206 AdgDress
 207 _adg_dress_color_fill(void)
 208 {
 209     static AdgDress dress = 0;
 210
 211     if (G_UNLIKELY(dress == 0)) {
 212         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 213                                           "red", 0.25,
 214                                           "green", 0.25,
 215                                           "blue", 0.25, NULL);
 216
 217         dress = adg_dress_new("color-fill", fallback);
 218         g_object_unref(fallback);
 219     }
 220
 221     return dress;
 222 }
 223
 224 /**
 225  * ADG_DRESS_LINE:
 226  *
 227  * The default builtin #AdgDress line.
 228  * This is a pass-through dress, that is it does not change
 229  * the cairo context when it is applied.
 230  *
 231  * This dress will be resolved to an #AdgLineStyle instance.
 232  *
 233  * Since: 1.0
 234  **/
 235 AdgDress
 236 _adg_dress_line(void)
 237 {
 238     static AdgDress dress = 0;
 239
 240     if (G_UNLIKELY(dress == 0)) {
 241         dress = adg_dress_new_full("line", NULL, ADG_TYPE_LINE_STYLE);
 242     }
 243
 244     return dress;
 245 }
 246
 247 /**
 248  * ADG_DRESS_LINE_STROKE:
 249  *
 250  * The builtin #AdgDress line type to be used by default
 251  * for rendering #AdgStroke entities. The fallback style is
 252  * a line with #ADG_DRESS_COLOR_STROKE color and a thickness
 253  * of %1.5.
 254  *
 255  * This dress will be resolved to an #AdgLineStyle instance.
 256  *
 257  * Since: 1.0
 258  **/
 259 AdgDress
 260 _adg_dress_line_stroke(void)
 261 {
 262     static AdgDress dress = 0;
 263
 264     if (G_UNLIKELY(dress == 0)) {
 265         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 266                                           "color-dress", ADG_DRESS_COLOR_STROKE,
 267                                           "width", 1.5, NULL);
 268
 269         dress = adg_dress_new("line-stroke", fallback);
 270         g_object_unref(fallback);
 271     }
 272
 273     return dress;
 274 }
 275
 276 /**
 277  * ADG_DRESS_LINE_DIMENSION:
 278  *
 279  * The builtin #AdgDress line type used by default
 280  * for rendering base and extension lines of dimensions.
 281  * The fallback style is a line with a thickness of %0.5
 282  * and a pass-through color dress.
 283  *
 284  * This dress will be resolved to an #AdgLineStyle instance.
 285  *
 286  * Since: 1.0
 287  **/
 288 AdgDress
 289 _adg_dress_line_dimension(void)
 290 {
 291     static AdgDress dress = 0;
 292
 293     if (G_UNLIKELY(dress == 0)) {
 294         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 295                                           "width", 0.5, NULL);
 296
 297         dress = adg_dress_new("line-dimension", fallback);
 298         g_object_unref(fallback);
 299     }
 300
 301     return dress;
 302 }
 303
 304 /**
 305  * ADG_DRESS_LINE_FILL:
 306  *
 307  * The builtin #AdgDress line type used by #AdgFillStyle
 308  * based styles. The fallback style is a line with
 309  * #ADG_DRESS_COLOR_FILL color and a thickness of %0.5.
 310  *
 311  * This dress will be resolved to an #AdgLineStyle instance.
 312  *
 313  * Since: 1.0
 314  **/
 315 AdgDress
 316 _adg_dress_line_fill(void)
 317 {
 318     static AdgDress dress = 0;
 319
 320     if (G_UNLIKELY(dress == 0)) {
 321         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 322                                           "color-dress", ADG_DRESS_COLOR_FILL,
 323                                           "width", 0.5, NULL);
 324
 325         dress = adg_dress_new("line-fill", fallback);
 326         g_object_unref(fallback);
 327     }
 328
 329     return dress;
 330 }
 331
 332 /**
 333  * ADG_DRESS_LINE_GRID:
 334  *
 335  * The builtin #AdgDress line type used for rendering the grid
 336  * of #AdgTable entities, that is the frame of the cells.
 337  * The fallback style is a line with a thickness of %1 and a
 338  * pass-through color dress, rendered without antialiasing.
 339  *
 340  * This dress will be resolved to an #AdgLineStyle instance.
 341  *
 342  * Since: 1.0
 343  **/
 344 AdgDress
 345 _adg_dress_line_grid(void)
 346 {
 347     static AdgDress dress = 0;
 348
 349     if (G_UNLIKELY(dress == 0)) {
 350         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 351                                           "antialias", CAIRO_ANTIALIAS_NONE,
 352                                           "width", 1., NULL);
 353
 354         dress = adg_dress_new("line-grid", fallback);
 355         g_object_unref(fallback);
 356     }
 357
 358     return dress;
 359 }
 360
 361 /**
 362  * ADG_DRESS_LINE_FRAME:
 363  *
 364  * The builtin #AdgDress line type used for rendering the frame
 365  * of #AdgTable entities, that is the frame around the whole table.
 366  * The fallback style is a line with a thickness of %2 and a
 367  * #ADG_DRESS_COLOR_ANNOTATION color dress, rendered without
 368  * antialiasing.
 369  *
 370  * This dress will be resolved to an #AdgLineStyle instance.
 371  *
 372  * Since: 1.0
 373  **/
 374 AdgDress
 375 _adg_dress_line_frame(void)
 376 {
 377     static AdgDress dress = 0;
 378
 379     if (G_UNLIKELY(dress == 0)) {
 380         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 381                                           "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 382                                           "antialias", CAIRO_ANTIALIAS_NONE,
 383                                           "width", 2., NULL);
 384
 385         dress = adg_dress_new("line-frame", fallback);
 386         g_object_unref(fallback);
 387     }
 388
 389     return dress;
 390 }
 391
 392 /**
 393  * ADG_DRESS_FONT:
 394  *
 395  * The default builtin #AdgDress font. The fallback style is
 396  * a %Sans %14 font with a pass-through color dress.
 397  *
 398  * This dress will be resolved to an #AdgFontStyle instance.
 399  *
 400  * Since: 1.0
 401  **/
 402 AdgDress
 403 _adg_dress_font(void)
 404 {
 405     static AdgDress dress = 0;
 406
 407     if (G_UNLIKELY(dress == 0)) {
 408         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 409                                           "family", "Serif",
 410                                           "size", 14., NULL);
 411
 412         dress = adg_dress_new("font", fallback);
 413         g_object_unref(fallback);
 414     }
 415
 416     return dress;
 417 }
 418
 419 /**
 420  * ADG_DRESS_FONT_TEXT:
 421  *
 422  * The builtin #AdgDress font used by default for rendering
 423  * common text such as #AdgToyText or the value of #AdgTable
 424  * entities. The fallback style is %Sans %12 %bold with an
 425  * #ADG_DRESS_COLOR_ANNOTATION color dress.
 426  *
 427  * This dress will be resolved to an #AdgFontStyle instance.
 428  *
 429  * Since: 1.0
 430  **/
 431 AdgDress
 432 _adg_dress_font_text(void)
 433 {
 434     static AdgDress dress = 0;
 435
 436     if (G_UNLIKELY(dress == 0)) {
 437         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 438                                           "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 439                                           "family", "Sans",
 440                                           "weight", CAIRO_FONT_WEIGHT_BOLD,
 441                                           "size", 12., NULL);
 442
 443         dress = adg_dress_new("font-text", fallback);
 444         g_object_unref(fallback);
 445     }
 446
 447     return dress;
 448 }
 449
 450 /**
 451  * ADG_DRESS_FONT_ANNOTATION:
 452  *
 453  * The builtin #AdgDress font used for rendering auxiliary text,
 454  * such as the titles on #AdgTable entities. The fallback style
 455  * is a %Sans %8 with an #ADG_DRESS_COLOR_ANNOTATION color dress.
 456  *
 457  * This dress will be resolved to an #AdgFontStyle instance.
 458  *
 459  * Since: 1.0
 460  **/
 461 AdgDress
 462 _adg_dress_font_annotation(void)
 463 {
 464     static AdgDress dress = 0;
 465
 466     if (G_UNLIKELY(dress == 0)) {
 467         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 468                                           "color-dress", ADG_DRESS_COLOR_ANNOTATION,
 469                                           "family", "Sans",
 470                                           "size", 8., NULL);
 471
 472         dress = adg_dress_new("font-annotation", fallback);
 473         g_object_unref(fallback);
 474     }
 475
 476     return dress;
 477 }
 478
 479 /**
 480  * ADG_DRESS_FONT_QUOTE_TEXT:
 481  *
 482  * The builtin #AdgDress font used for rendering regular text
 483  * on dimension entities, such as the nominal value and the
 484  * notes of a quote. The fallback style is %Sans %12 %bold with
 485  * a pass-through color dress.
 486  *
 487  * This dress will be resolved to an #AdgFontStyle instance.
 488  *
 489  * Since: 1.0
 490  **/
 491 AdgDress
 492 _adg_dress_font_quote_text(void)
 493 {
 494     static AdgDress dress = 0;
 495
 496     if (G_UNLIKELY(dress == 0)) {
 497         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 498                                           "family", "Sans",
 499                                           "weight", CAIRO_FONT_WEIGHT_BOLD,
 500                                           "size", 12., NULL);
 501
 502         dress = adg_dress_new("font-quote-text", fallback);
 503         g_object_unref(fallback);
 504     }
 505
 506     return dress;
 507 }
 508
 509 /**
 510  * ADG_DRESS_FONT_QUOTE_ANNOTATION:
 511  *
 512  * The builtin #AdgDress font used for rendering auxiliary text
 513  * on dimension entities, such as the min and max limits of a
 514  * quote. The fallback style is a %Sans %8 with a pass-through
 515  * color dress.
 516  *
 517  * This dress will be resolved to an #AdgFontStyle instance.
 518  *
 519  * Since: 1.0
 520  **/
 521 AdgDress
 522 _adg_dress_font_quote_annotation(void)
 523 {
 524     static AdgDress dress = 0;
 525
 526     if (G_UNLIKELY(dress == 0)) {
 527         AdgStyle *fallback = g_object_new(ADG_TYPE_BEST_FONT_STYLE,
 528                                           "family", "Sans",
 529                                           "size", 8., NULL);
 530
 531         dress = adg_dress_new("font-quote-annotation", fallback);
 532         g_object_unref(fallback);
 533     }
 534
 535     return dress;
 536 }
 537
 538 /**
 539  * ADG_DRESS_DIMENSION:
 540  *
 541  * The default builtin #AdgDress for dimensions. The fallback
 542  * style is the default #AdgDimStyle implementation with
 543  * #AdgArrow markers (as returned by adg_arrow_new() on both sides.
 544  *
 545  * This dress will be resolved to an #AdgDimStyle instance.
 546  *
 547  * Since: 1.0
 548  **/
 549 AdgDress
 550 _adg_dress_dimension(void)
 551 {
 552     static AdgDress dress = 0;
 553
 554     if (G_UNLIKELY(dress == 0)) {
 555         AdgMarker *arrow = (AdgMarker *) adg_arrow_new();
 556         AdgStyle *fallback = g_object_new(ADG_TYPE_DIM_STYLE, NULL);
 557
 558         adg_dim_style_set_marker1((AdgDimStyle *) fallback, arrow);
 559         adg_marker_set_pos(arrow, 1);
 560         adg_dim_style_set_marker2((AdgDimStyle *) fallback, arrow);
 561
 562         dress = adg_dress_new("dimension", fallback);
 563         g_object_unref(fallback);
 564         g_object_unref(arrow);
 565     }
 566
 567     return dress;
 568 }
 569
 570 /**
 571  * ADG_DRESS_FILL:
 572  *
 573  * The default builtin #AdgDress for filling.
 574  * This is a pass-through dress, that is it does not change
 575  * the cairo context when it is applied.
 576  *
 577  * This dress will be resolved to an #AdgFillStyle derived instance.
 578  *
 579  * Since: 1.0
 580  **/
 581 AdgDress
 582 _adg_dress_fill(void)
 583 {
 584     static AdgDress dress = 0;
 585
 586     if (G_UNLIKELY(dress == 0)) {
 587         dress = adg_dress_new_full("fill", NULL, ADG_TYPE_FILL_STYLE);
 588     }
 589
 590     return dress;
 591 }
 592
 593 /**
 594  * ADG_DRESS_FILL_HATCH:
 595  *
 596  * The builtin dress used by default by #AdgHatch instances.
 597  * The fallback style is the default implementation of the
 598  * #AdgRuledFill instance.
 599  *
 600  * This dress will be resolved to an #AdgFillStyle derived instance.
 601  *
 602  * Since: 1.0
 603  **/
 604 AdgDress
 605 _adg_dress_fill_hatch(void)
 606 {
 607     static AdgDress dress = 0;
 608
 609     if (G_UNLIKELY(dress == 0)) {
 610         AdgStyle *fallback = g_object_new(ADG_TYPE_RULED_FILL,
 611                                           "line-dress", ADG_DRESS_LINE_FILL,
 612                                           NULL);
 613
 614         dress = adg_dress_new_full("fill-hatch", fallback, ADG_TYPE_FILL_STYLE);
 615         g_object_unref(fallback);
 616     }
 617
 618     return dress;
 619 }
 620
 621 /**
 622  * ADG_DRESS_TABLE:
 623  *
 624  * The default builtin #AdgDress for tables. The fallback style
 625  * is the default implementation of the #AdgTableStyle instance.
 626  *
 627  * This dress will be resolved to an #AdgTableStyle derived instance.
 628  *
 629  * Since: 1.0
 630  **/
 631 AdgDress
 632 _adg_dress_table(void)
 633 {
 634     static AdgDress dress = 0;
 635
 636     if (G_UNLIKELY(dress == 0)) {
 637         AdgStyle *fallback = g_object_new(ADG_TYPE_TABLE_STYLE, NULL);
 638         dress = adg_dress_new_full("table", fallback, ADG_TYPE_TABLE_STYLE);
 639         g_object_unref(fallback);
 640     }
 641
 642     return dress;
 643 }