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-ruled-fill.h"
  39 #include "adg-arrow.h"
  40
  41
  42 /**
  43  * ADG_DRESS_UNDEFINED:
  44  *
  45  * A value reperesenting an undefined #AdgDress.
  46  **/
  47
  48 /**
  49  * ADG_DRESS_COLOR:
  50  *
  51  * The default builtin #AdgDress color. This is a transparent dress
  52  * without a fallback style.
  53  *
  54  * This dress will be resolved to an #AdgColorStyle instance.
  55  **/
  56 AdgDress
  57 _adg_dress_color(void)
  58 {
  59     static AdgDress dress = 0;
  60
  61     if (G_UNLIKELY(dress == 0)) {
  62         dress = adg_dress_new_full("color", NULL, ADG_TYPE_COLOR_STYLE);
  63     }
  64
  65     return dress;
  66 }
  67
  68 /**
  69  * ADG_DRESS_COLOR_STROKE:
  70  *
  71  * The default builtin #AdgDress color for #AdgStroke entities.
  72  * The fallback style is the default implementation of #AdgColor
  73  * (that is %black).
  74  *
  75  * This dress will be resolved to an #AdgColorStyle instance.
  76  **/
  77 AdgDress
  78 _adg_dress_color_stroke(void)
  79 {
  80     static AdgDress dress = 0;
  81
  82     if (G_UNLIKELY(dress == 0)) {
  83         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE, NULL);
  84
  85         dress = adg_dress_new("color-stroke", fallback);
  86         g_object_unref(fallback);
  87     }
  88
  89     return dress;
  90 }
  91
  92 /**
  93  * ADG_DRESS_COLOR_DIMENSION:
  94  *
  95  * The builtin #AdgDress color used by default in #AdgDimStyle.
  96  * The fallback style is a %0.75 red.
  97  *
  98  * This dress will be resolved to an #AdgColorStyle instance.
  99  **/
 100 AdgDress
 101 _adg_dress_color_dimension(void)
 102 {
 103     static AdgDress dress = 0;
 104
 105     if (G_UNLIKELY(dress == 0)) {
 106         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 107                                           "red", 0.75, NULL);
 108
 109         dress = adg_dress_new("color-dimension", fallback);
 110         g_object_unref(fallback);
 111     }
 112
 113     return dress;
 114 }
 115
 116 /**
 117  * ADG_DRESS_COLOR_HATCH:
 118  *
 119  * The default builtin #AdgDress color for #AdgHatch entities.
 120  * The fallback style is a %0.5 blue.
 121  *
 122  * This dress will be resolved to an #AdgColorStyle instance.
 123  **/
 124 AdgDress
 125 _adg_dress_color_hatch(void)
 126 {
 127     static AdgDress dress = 0;
 128
 129     if (G_UNLIKELY(dress == 0)) {
 130         AdgStyle *fallback = g_object_new(ADG_TYPE_COLOR_STYLE,
 131                                           "blue", 0.5, NULL);
 132
 133         dress = adg_dress_new("color-hatch", fallback);
 134         g_object_unref(fallback);
 135     }
 136
 137     return dress;
 138 }
 139
 140 /**
 141  * ADG_DRESS_LINE:
 142  *
 143  * The default builtin #AdgDress line. This is a transparent dress
 144  * without a fallback style.
 145  *
 146  * This dress will be resolved to an #AdgLineStyle instance.
 147  **/
 148 AdgDress
 149 _adg_dress_line(void)
 150 {
 151     static AdgDress dress = 0;
 152
 153     if (G_UNLIKELY(dress == 0)) {
 154         dress = adg_dress_new_full("line", NULL, ADG_TYPE_LINE_STYLE);
 155     }
 156
 157     return dress;
 158 }
 159
 160 /**
 161  * ADG_DRESS_LINE_STROKE:
 162  *
 163  * The builtin #AdgDress line used by default by #AdgStroke entities.
 164  * The fallback style is a default line with a thickness of %1.75.
 165  *
 166  * This dress will be resolved to an #AdgLineStyle instance.
 167  **/
 168 AdgDress
 169 _adg_dress_line_stroke(void)
 170 {
 171     static AdgDress dress = 0;
 172
 173     if (G_UNLIKELY(dress == 0)) {
 174         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 175                                           "width", 1.75, NULL);
 176
 177         dress = adg_dress_new("line-stroke", fallback);
 178         g_object_unref(fallback);
 179     }
 180
 181     return dress;
 182 }
 183
 184 /**
 185  * ADG_DRESS_LINE_DIMENSION:
 186  *
 187  * The builtin #AdgDress line type used by base and extension lines
 188  * for dimensions. The fallback style is a default line with a
 189  * thickness of %0.75.
 190  *
 191  * This dress will be resolved to an #AdgLineStyle instance.
 192  **/
 193 AdgDress
 194 _adg_dress_line_dimension(void)
 195 {
 196     static AdgDress dress = 0;
 197
 198     if (G_UNLIKELY(dress == 0)) {
 199         AdgStyle *fallback = g_object_new(ADG_TYPE_LINE_STYLE,
 200                                           "width", 0.75, NULL);
 201
 202         dress = adg_dress_new("line-dimension", fallback);
 203         g_object_unref(fallback);
 204     }
 205
 206     return dress;
 207 }
 208
 209 /**
 210  * ADG_DRESS_LINE_HATCH:
 211  *
 212  * The builtin #AdgDress line type used by the default #AdgRuledFill
 213  * style implementation. The fallback style is a default line with
 214  * a thickness of %1.
 215  *
 216  * This dress will be resolved to an #AdgLineStyle instance.
 217  **/
 218 AdgDress
 219 _adg_dress_line_hatch(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                                           "color-dress", ADG_DRESS_COLOR_HATCH,
 226                                           "width", 1., NULL);
 227
 228         dress = adg_dress_new("line-hatch", fallback);
 229         g_object_unref(fallback);
 230     }
 231
 232     return dress;
 233 }
 234
 235 /**
 236  * ADG_DRESS_TEXT:
 237  *
 238  * The default builtin #AdgDress font. The fallback style is
 239  * %Sans %14.
 240  *
 241  * This dress will be resolved to an #AdgFontStyle instance.
 242  **/
 243 AdgDress
 244 _adg_dress_text(void)
 245 {
 246     static AdgDress dress = 0;
 247
 248     if (G_UNLIKELY(dress == 0)) {
 249         AdgStyle *fallback = g_object_new(ADG_TYPE_FONT_STYLE,
 250                                           "family", "Serif",
 251                                           "size", 14., NULL);
 252
 253         dress = adg_dress_new("text", fallback);
 254         g_object_unref(fallback);
 255     }
 256
 257     return dress;
 258 }
 259
 260 /**
 261  * ADG_DRESS_TEXT_VALUE:
 262  *
 263  * The builtin #AdgDress font used to render the nominal value of a
 264  * dimension. The fallback style is %Sans %12 %bold.
 265  *
 266  * This dress will be resolved to an #AdgFontStyle instance.
 267  **/
 268 AdgDress
 269 _adg_dress_text_value(void)
 270 {
 271     static AdgDress dress = 0;
 272
 273     if (G_UNLIKELY(dress == 0)) {
 274         AdgStyle *fallback = g_object_new(ADG_TYPE_FONT_STYLE,
 275                                           "family", "Sans",
 276                                           "weight", CAIRO_FONT_WEIGHT_BOLD,
 277                                           "size", 12., NULL);
 278
 279         dress = adg_dress_new("text-value", fallback);
 280         g_object_unref(fallback);
 281     }
 282
 283     return dress;
 284 }
 285
 286 /**
 287  * ADG_DRESS_TEXT_LIMIT:
 288  *
 289  * The builtin #AdgDress font used to render the limits of either
 290  * the min and max values of a dimension. The fallback style
 291  * is a %Sans %8.
 292  *
 293  * This dress will be resolved to an #AdgFontStyle instance.
 294  **/
 295 AdgDress
 296 _adg_dress_text_limit(void)
 297 {
 298     static AdgDress dress = 0;
 299
 300     if (G_UNLIKELY(dress == 0)) {
 301         AdgStyle *fallback = g_object_new(ADG_TYPE_FONT_STYLE,
 302                                           "family", "Sans",
 303                                           "size", 8., NULL);
 304
 305         dress = adg_dress_new("text-limit", fallback);
 306         g_object_unref(fallback);
 307     }
 308
 309     return dress;
 310 }
 311
 312 /**
 313  * ADG_DRESS_DIMENSION:
 314  *
 315  * The default builtin #AdgDress for dimensioning. The fallback
 316  * style is the default #AdgDimStyle implementation with #AdgArrow
 317  * as markers on both sides.
 318  *
 319  * This dress will be resolved to an #AdgDimStyle instance.
 320  **/
 321 AdgDress
 322 _adg_dress_dimension(void)
 323 {
 324     static AdgDress dress = 0;
 325
 326     if (G_UNLIKELY(dress == 0)) {
 327         AdgMarker *arrow = g_object_new(ADG_TYPE_ARROW, NULL);
 328         AdgStyle *fallback = g_object_new(ADG_TYPE_DIM_STYLE, NULL);
 329
 330         adg_dim_style_use_marker1((AdgDimStyle *) fallback, arrow);
 331         adg_marker_set_pos(arrow, 1);
 332         adg_dim_style_use_marker2((AdgDimStyle *) fallback, arrow);
 333
 334         dress = adg_dress_new("dimension", fallback);
 335         g_object_unref(fallback);
 336         g_object_unref(arrow);
 337     }
 338
 339     return dress;
 340 }
 341
 342 /**
 343  * ADG_DRESS_FILL:
 344  *
 345  * The default builtin #AdgDress for filling. This is a transparent
 346  * dress without a fallback style.
 347  *
 348  * This dress will be resolved to an #AdgFillStyle derived instance.
 349  **/
 350 AdgDress
 351 _adg_dress_fill(void)
 352 {
 353     static AdgDress dress = 0;
 354
 355     if (G_UNLIKELY(dress == 0)) {
 356         dress = adg_dress_new_full("fill", NULL, ADG_TYPE_FILL_STYLE);
 357     }
 358
 359     return dress;
 360 }
 361
 362 /**
 363  * ADG_DRESS_FILL_HATCH:
 364  *
 365  * The default builtin #AdgDress for used by #AdgHatch instances.
 366  * The fallback style is the default implementation of the
 367  * #AdgRuledFill instance.
 368  *
 369  * This dress will be resolved to an #AdgFillStyle derived instance.
 370  **/
 371 AdgDress
 372 _adg_dress_fill_hatch(void)
 373 {
 374     static AdgDress dress = 0;
 375
 376     if (G_UNLIKELY(dress == 0)) {
 377         AdgStyle *fallback = g_object_new(ADG_TYPE_RULED_FILL,
 378                                           "line-dress", ADG_DRESS_LINE_HATCH,
 379                                           NULL);
 380
 381         dress = adg_dress_new_full("fill-hatch", fallback,
 382                                    ADG_TYPE_FILL_STYLE);
 383         g_object_unref(fallback);
 384     }
 385
 386     return dress;
 387 }