adg/adg-line-style.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2008, 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 Library 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  * Library 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., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:line-style
  23  * @title: AdgLineStyle
  24  * @short_description: Line style related stuff
  25  *
  26  * Contains parameters on how to draw lines such as width, cap mode, join mode
  27  * and dash composition, if used.
  28  */
  29
  30 #include "adg-line-style.h"
  31 #include "adg-line-style-private.h"
  32 #include "adg-intl.h"
  33 #include "adg-util.h"
  34
  35 #define PARENT_CLASS ((AdgStyleClass *) adg_line_style_parent_class)
  36
  37
  38 enum
  39 {
  40   PROP_0,
  41   PROP_WIDTH,
  42   PROP_CAP,
  43   PROP_JOIN,
  44   PROP_MITER_LIMIT,
  45   PROP_ANTIALIAS,
  46   PROP_DASH
  47 };
  48
  49
  50 static void     get_property            (GObject        *object,
  51                                          guint           prop_id,
  52                                          GValue         *value,
  53                                          GParamSpec     *pspec);
  54 static void     set_property            (GObject        *object,
  55                                          guint           prop_id,
  56                                          const GValue   *value,
  57                                          GParamSpec     *pspec);
  58
  59
  60 G_DEFINE_TYPE (AdgLineStyle, adg_line_style, ADG_TYPE_STYLE)
  61
  62
  63 static void
  64 adg_line_style_class_init (AdgLineStyleClass *klass)
  65 {
  66   GObjectClass *gobject_class;
  67   GParamSpec   *param;
  68
  69   gobject_class = (GObjectClass *) klass;
  70
  71   g_type_class_add_private (klass, sizeof (AdgLineStylePrivate));
  72
  73   gobject_class->get_property = get_property;
  74   gobject_class->set_property = set_property;
  75
  76   param = g_param_spec_double ("width",
  77                                P_("Line Width"),
  78                                P_("The line thickness in device unit"),
  79                                0., G_MAXDOUBLE, 2.,
  80                                G_PARAM_READWRITE);
  81   g_object_class_install_property (gobject_class, PROP_WIDTH, param);
  82
  83   param = g_param_spec_int ("cap",
  84                             P_("Line Cap"),
  85                             P_("The line cap mode"),
  86                             G_MININT, G_MAXINT, CAIRO_LINE_CAP_ROUND,
  87                             G_PARAM_READWRITE);
  88   g_object_class_install_property (gobject_class, PROP_CAP, param);
  89
  90   param = g_param_spec_int ("join",
  91                             P_("Line Join"),
  92                             P_("The line join mode"),
  93                             G_MININT, G_MAXINT, CAIRO_LINE_JOIN_MITER,
  94                             G_PARAM_READWRITE);
  95   g_object_class_install_property (gobject_class, PROP_JOIN, param);
  96
  97   param = g_param_spec_double ("miter-limit",
  98                                P_("Miter Limit"),
  99                                P_("Whether the lines should be joined with a bevel instead of a miter"),
 100                                0., G_MAXDOUBLE, 10.,
 101                                G_PARAM_READWRITE);
 102   g_object_class_install_property (gobject_class, PROP_MITER_LIMIT, param);
 103
 104   param = g_param_spec_int ("antialias",
 105                             P_("Antialiasing Mode"),
 106                             P_("Type of antialiasing to do when rendering lines"),
 107                             G_MININT, G_MAXINT, CAIRO_ANTIALIAS_DEFAULT,
 108                             G_PARAM_READWRITE);
 109   g_object_class_install_property (gobject_class, PROP_ANTIALIAS, param);
 110
 111   /* TODO: PROP_DASH (PROP_DASHES, PROP_NUM_DASHES, PROP_DASH_OFFSET) */
 112 }
 113
 114 static void
 115 adg_line_style_init (AdgLineStyle *line_style)
 116 {
 117   AdgLineStylePrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (line_style,
 118                                                            ADG_TYPE_LINE_STYLE,
 119                                                            AdgLineStylePrivate);
 120
 121   priv->width = 2.;
 122   priv->cap = CAIRO_LINE_CAP_ROUND;
 123   priv->join = CAIRO_LINE_JOIN_MITER;
 124   priv->miter_limit = 10.;
 125   priv->dashes = NULL;
 126   priv->num_dashes = 0;
 127   priv->dash_offset = 0.;
 128
 129   line_style->priv = priv;
 130 }
 131
 132 static void
 133 get_property (GObject    *object,
 134               guint       prop_id,
 135               GValue     *value,
 136               GParamSpec *pspec)
 137 {
 138   AdgLineStyle *line_style = (AdgLineStyle *) object;
 139
 140   switch (prop_id)
 141     {
 142     case PROP_WIDTH:
 143       g_value_set_double (value, line_style->priv->width);
 144       break;
 145     case PROP_CAP:
 146       g_value_set_int (value, line_style->priv->cap);
 147       break;
 148     case PROP_JOIN:
 149       g_value_set_int (value, line_style->priv->join);
 150       break;
 151     case PROP_MITER_LIMIT:
 152       g_value_set_double (value, line_style->priv->miter_limit);
 153       break;
 154     case PROP_ANTIALIAS:
 155       g_value_set_int (value, line_style->priv->antialias);
 156       break;
 157     case PROP_DASH:
 158       /* TODO */
 159       break;
 160     default:
 161       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 162       break;
 163     }
 164 }
 165
 166 static void
 167 set_property (GObject      *object,
 168               guint         prop_id,
 169               const GValue *value,
 170               GParamSpec   *pspec)
 171 {
 172   AdgLineStyle *line_style = (AdgLineStyle *) object;
 173
 174   switch (prop_id)
 175     {
 176     case PROP_WIDTH:
 177       line_style->priv->width = g_value_get_double (value);
 178       break;
 179     case PROP_CAP:
 180       line_style->priv->cap = g_value_get_int (value);
 181       break;
 182     case PROP_JOIN:
 183       line_style->priv->join = g_value_get_int (value);
 184       break;
 185     case PROP_MITER_LIMIT:
 186       line_style->priv->miter_limit = g_value_get_double (value);
 187       break;
 188     case PROP_ANTIALIAS:
 189       line_style->priv->antialias = g_value_get_int (value);
 190       break;
 191     case PROP_DASH:
 192       /* TODO */
 193       break;
 194     default:
 195       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 196       break;
 197     }
 198 }
 199
 200
 201 AdgStyle *
 202 adg_line_style_from_id (AdgLineStyleId id)
 203 {
 204   static AdgStyle **builtins = NULL;
 205
 206   if G_UNLIKELY (builtins == NULL)
 207     {
 208       builtins = g_new (AdgStyle *, ADG_LINE_STYLE_LAST);
 209
 210       builtins[ADG_LINE_STYLE_DRAW] = g_object_new (ADG_TYPE_LINE_STYLE,
 211                                                     "width", 2.,
 212                                                     NULL);
 213       builtins[ADG_LINE_STYLE_CENTER] = g_object_new (ADG_TYPE_LINE_STYLE,
 214                                                       "g", 1.,
 215                                                       "width", 0.75,
 216                                                       NULL);
 217       builtins[ADG_LINE_STYLE_HIDDEN] = g_object_new (ADG_TYPE_LINE_STYLE,
 218                                                       "a", 0.5,
 219                                                       "width", 0.75,
 220                                                       NULL);
 221       builtins[ADG_LINE_STYLE_XATCH] = g_object_new (ADG_TYPE_LINE_STYLE,
 222                                                      "b", 1.,
 223                                                      "width", 1.25,
 224                                                      NULL);
 225       builtins[ADG_LINE_STYLE_DIM] = g_object_new (ADG_TYPE_LINE_STYLE,
 226                                                    "r", 1.,
 227                                                    "width", 0.75,
 228                                                    NULL);
 229     }
 230
 231   g_return_val_if_fail (id < ADG_LINE_STYLE_LAST, NULL);
 232   return builtins[id];
 233 }
 234
 235 void
 236 adg_line_style_apply (const AdgLineStyle *line_style,
 237                       cairo_t            *cr)
 238 {
 239   double device_width;
 240   double dummy = 0.;
 241
 242   g_return_if_fail (line_style != NULL);
 243   g_return_if_fail (cr != NULL);
 244
 245   device_width = line_style->priv->width;
 246   cairo_device_to_user_distance (cr, &device_width, &dummy);
 247   cairo_set_line_width (cr, device_width);
 248
 249   cairo_set_line_cap (cr, line_style->priv->cap);
 250   cairo_set_line_join (cr, line_style->priv->join);
 251   cairo_set_miter_limit (cr, line_style->priv->miter_limit);
 252   cairo_set_antialias (cr, line_style->priv->antialias);
 253
 254   if (line_style->priv->num_dashes > 0)
 255     {
 256       g_return_if_fail (line_style->priv->dashes != NULL);
 257
 258       cairo_set_dash (cr, line_style->priv->dashes, line_style->priv->num_dashes,
 259                       line_style->priv->dash_offset);
 260     }
 261 }