adg/adg-arrow-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:arrow-style
  23  * @title: AdgArrowStyle
  24  * @short_description: Arrow rendering related stuff
  25  *
  26  * Contains parameters on how to draw arrows, providing a way to register a
  27  * custom rendering callback.
  28  */
  29
  30 #include "adg-arrow-style.h"
  31 #include "adg-arrow-style-private.h"
  32 #include "adg-intl.h"
  33 #include "adg-util.h"
  34
  35 #include <math.h>
  36
  37 #define PARENT_CLASS ((AdgStyleClass *) adg_arrow_style_parent_class)
  38
  39
  40 enum
  41 {
  42   PROP_0,
  43   PROP_SIZE,
  44   PROP_ANGLE,
  45   PROP_MARGIN,
  46   PROP_RENDERER
  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 static GPtrArray *      get_pool                (void);
  60 static void             arrow_renderer          (AdgArrowStyle  *arrow_style,
  61                                                  cairo_t        *cr,
  62                                                  CpmlPath       *segment);
  63 static void             triangle_renderer       (AdgArrowStyle  *arrow_style,
  64                                                  cairo_t        *cr,
  65                                                  CpmlPath       *segment);
  66 static void             dot_renderer            (AdgArrowStyle  *arrow_style,
  67                                                  cairo_t        *cr,
  68                                                  CpmlPath       *segment);
  69 static void             circle_renderer         (AdgArrowStyle  *arrow_style,
  70                                                  cairo_t        *cr,
  71                                                  CpmlPath       *segment);
  72 static void             block_renderer          (AdgArrowStyle  *arrow_style,
  73                                                  cairo_t        *cr,
  74                                                  CpmlPath       *segment);
  75 static void             square_renderer         (AdgArrowStyle  *arrow_style,
  76                                                  cairo_t        *cr,
  77                                                  CpmlPath       *segment);
  78 static void             tick_renderer           (AdgArrowStyle  *arrow_style,
  79                                                  cairo_t        *cr,
  80                                                  CpmlPath       *segment);
  81 static void             draw_triangle           (cairo_t        *cr,
  82                                                  AdgArrowStyle  *arrow_style,
  83                                                  CpmlPath       *segment);
  84 static void             draw_circle             (cairo_t        *cr,
  85                                                  AdgArrowStyle  *arrow_style,
  86                                                  CpmlPath       *segment);
  87
  88
  89 G_DEFINE_TYPE (AdgArrowStyle, adg_arrow_style, ADG_TYPE_STYLE)
  90
  91
  92 static void
  93 adg_arrow_style_class_init (AdgArrowStyleClass *klass)
  94 {
  95   GObjectClass  *gobject_class;
  96   AdgStyleClass *style_class;
  97   GParamSpec    *param;
  98
  99   gobject_class = (GObjectClass *) klass;
 100   style_class = (AdgStyleClass *) klass;
 101
 102   g_type_class_add_private (klass, sizeof (AdgArrowStylePrivate));
 103
 104   gobject_class->get_property = get_property;
 105   gobject_class->set_property = set_property;
 106
 107   style_class->get_pool = get_pool;
 108
 109   param = g_param_spec_double ("size",
 110                                P_("Arrow Size"),
 111                                P_("The size of the arrow, a renderer dependent parameter"),
 112                                -G_MAXDOUBLE, G_MAXDOUBLE, 14.,
 113                                G_PARAM_READWRITE);
 114   g_object_class_install_property (gobject_class, PROP_SIZE, param);
 115
 116   param = g_param_spec_double ("angle",
 117                                P_("Arrow Angle"),
 118                                P_("The angle of the arrow, a renderer dependent parameter"),
 119                                -G_MAXDOUBLE, G_MAXDOUBLE, G_PI / 6.,
 120                                G_PARAM_READWRITE);
 121   g_object_class_install_property (gobject_class, PROP_ANGLE, param);
 122
 123   param = g_param_spec_double ("margin",
 124                                P_("Arrow Margin"),
 125                                P_("The margin of the arrow, a renderer dependent parameter"),
 126                                -G_MAXDOUBLE, G_MAXDOUBLE, 14.,
 127                                G_PARAM_READWRITE);
 128   g_object_class_install_property (gobject_class, PROP_MARGIN, param);
 129
 130   param = g_param_spec_pointer ("renderer",
 131                                 P_("Renderer Callback"),
 132                                 P_("The callback to call to renderer this arrow type"),
 133                                 G_PARAM_READWRITE);
 134   g_object_class_install_property (gobject_class, PROP_RENDERER, param);
 135 }
 136
 137 static void
 138 adg_arrow_style_init (AdgArrowStyle *arrow_style)
 139 {
 140   AdgArrowStylePrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (arrow_style,
 141                                                             ADG_TYPE_ARROW_STYLE,
 142                                                             AdgArrowStylePrivate);
 143
 144   priv->size = 14.;
 145   priv->angle = G_PI / 6.;
 146   priv->margin = 14.;
 147   priv->renderer = NULL;
 148
 149   arrow_style->priv = priv;
 150 }
 151
 152 static void
 153 get_property (GObject    *object,
 154               guint       prop_id,
 155               GValue     *value,
 156               GParamSpec *pspec)
 157 {
 158   AdgArrowStyle *arrow_style = (AdgArrowStyle *) object;
 159
 160   switch (prop_id)
 161     {
 162     case PROP_SIZE:
 163       g_value_set_double (value, arrow_style->priv->size);
 164       break;
 165     case PROP_ANGLE:
 166       g_value_set_double (value, arrow_style->priv->angle);
 167       break;
 168     case PROP_MARGIN:
 169       g_value_set_double (value, arrow_style->priv->margin);
 170       break;
 171     case PROP_RENDERER:
 172       g_value_set_pointer (value, arrow_style->priv->renderer);
 173       break;
 174     default:
 175       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 176       break;
 177     }
 178 }
 179
 180 static void
 181 set_property (GObject      *object,
 182               guint         prop_id,
 183               const GValue *value,
 184               GParamSpec   *pspec)
 185 {
 186   AdgArrowStyle *arrow_style = (AdgArrowStyle *) object;
 187
 188   switch (prop_id)
 189     {
 190     case PROP_SIZE:
 191       arrow_style->priv->size = g_value_get_double (value);
 192       break;
 193     case PROP_ANGLE:
 194       arrow_style->priv->angle = g_value_get_double (value);
 195       break;
 196     case PROP_MARGIN:
 197       arrow_style->priv->margin = g_value_get_double (value);
 198       break;
 199     case PROP_RENDERER:
 200       arrow_style->priv->renderer = g_value_get_pointer (value);
 201       break;
 202     default:
 203       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 204       break;
 205     }
 206 }
 207
 208
 209 /**
 210  * adg_arrow_style_get_slot:
 211  *
 212  * Gets the slot id for this style class.
 213  *
 214  * Return value: the slot
 215  **/
 216 AdgStyleSlot
 217 adg_arrow_style_get_slot (void)
 218 {
 219   static AdgStyleSlot slot = -1;
 220
 221   if G_UNLIKELY (slot < 0)
 222     slot = adg_context_get_slot (ADG_TYPE_ARROW_STYLE);
 223
 224   return slot;
 225 }
 226
 227 /**
 228  * adg_arrow_style_new:
 229  *
 230  * Constructs a new arrow style initialized with default params.
 231  *
 232  * Return value: a new arrow style
 233  **/
 234 AdgStyle *
 235 adg_arrow_style_new (void)
 236 {
 237   return g_object_new (ADG_TYPE_ARROW_STYLE, NULL);
 238 }
 239
 240 /**
 241  * adg_arrow_style_render:
 242  * @arrow_style: an #AdgArrowStyle instance
 243  * @cr: the cairo context to use
 244  * @segment: the #CpmlPath where the arrow must be rendered
 245  *
 246  * Renders an arrow on @cr at the beginning of @segment in the way
 247  * specified by @arrow_style.
 248  **/
 249 void
 250 adg_arrow_style_render (AdgArrowStyle *arrow_style,
 251                         cairo_t       *cr,
 252                         CpmlPath      *segment)
 253 {
 254   g_return_if_fail (arrow_style != NULL);
 255   g_return_if_fail (cr != NULL);
 256   g_return_if_fail (segment != NULL);
 257
 258   /* NULL renderer */
 259   if (arrow_style->priv->renderer == NULL)
 260     return;
 261
 262   PARENT_CLASS->apply ((AdgStyle *) arrow_style, cr);
 263   arrow_style->priv->renderer (arrow_style, cr, segment);
 264 }
 265
 266 /**
 267  * adg_arrow_style_get_size:
 268  * @arrow_style: an #AdgArrowStyle object
 269  *
 270  * Gets the size (in paper units) of the arrow (renderer dependent value).
 271  *
 272  * Return value: the size value
 273  **/
 274 gdouble
 275 adg_arrow_style_get_size (AdgArrowStyle *arrow_style)
 276 {
 277   g_return_val_if_fail (ADG_IS_ARROW_STYLE (arrow_style), 0.);
 278
 279   return arrow_style->priv->size;
 280 }
 281
 282 /**
 283  * adg_arrow_style_set_size:
 284  * @arrow_style: an #AdgArrowStyle object
 285  * @size: the new size
 286  *
 287  * Sets a new size.
 288  **/
 289 void
 290 adg_arrow_style_set_size (AdgArrowStyle *arrow_style,
 291                           gdouble        size)
 292 {
 293   g_return_if_fail (ADG_IS_ARROW_STYLE (arrow_style));
 294
 295   arrow_style->priv->size = size;
 296   g_object_notify ((GObject *) arrow_style, "size");
 297 }
 298
 299 /**
 300  * adg_arrow_style_get_angle:
 301  * @arrow_style: an #AdgArrowStyle object
 302  *
 303  * Gets the angle (in degree) of the arrow (renderer dependent value).
 304  *
 305  * Return value: the angle value
 306  **/
 307 gdouble
 308 adg_arrow_style_get_angle (AdgArrowStyle *arrow_style)
 309 {
 310   g_return_val_if_fail (ADG_IS_ARROW_STYLE (arrow_style), 0.);
 311
 312   return arrow_style->priv->angle;
 313 }
 314
 315 /**
 316  * adg_arrow_style_set_angle:
 317  * @arrow_style: an #AdgArrowStyle object
 318  * @angle: the new angle
 319  *
 320  * Sets a new angle.
 321  **/
 322 void
 323 adg_arrow_style_set_angle (AdgArrowStyle *arrow_style,
 324                            gdouble        angle)
 325 {
 326   g_return_if_fail (ADG_IS_ARROW_STYLE (arrow_style));
 327
 328   arrow_style->priv->angle = angle;
 329   g_object_notify ((GObject *) arrow_style, "angle");
 330 }
 331
 332 /**
 333  * adg_arrow_style_get_margin:
 334  * @arrow_style: an #AdgArrowStyle object
 335  *
 336  * Gets the margin (in paper units) of this arrow (renderer dependent value).
 337  * The margin is also used to trim the baseline of this amount.
 338  *
 339  * Return value: the margin value
 340  **/
 341 gdouble
 342 adg_arrow_style_get_margin (AdgArrowStyle *arrow_style)
 343 {
 344   g_return_val_if_fail (ADG_IS_ARROW_STYLE (arrow_style), 0.);
 345
 346   return arrow_style->priv->margin;
 347 }
 348
 349 /**
 350  * adg_arrow_style_set_margin:
 351  * @arrow_style: an #AdgArrowStyle object
 352  * @margin: the new margin
 353  *
 354  * Sets a new margin.
 355  **/
 356 void
 357 adg_arrow_style_set_margin (AdgArrowStyle *arrow_style,
 358                             gdouble        margin)
 359 {
 360   g_return_if_fail (ADG_IS_ARROW_STYLE (arrow_style));
 361
 362   arrow_style->priv->margin = margin;
 363   g_object_notify ((GObject *) arrow_style, "margin");
 364 }
 365
 366 /**
 367  * adg_arrow_style_get_renderer:
 368  * @arrow_style: an #AdgArrowStyle object
 369  *
 370  * Gets the renderer of @arrow_style.
 371  *
 372  * Return value: the renderer value
 373  **/
 374 const AdgArrowRenderer
 375 adg_arrow_style_get_renderer (AdgArrowStyle *arrow_style)
 376 {
 377   g_return_val_if_fail (ADG_IS_ARROW_STYLE (arrow_style), NULL);
 378
 379   return arrow_style->priv->renderer;
 380 }
 381
 382 /**
 383  * adg_arrow_style_set_renderer:
 384  * @arrow_style: an #AdgArrowStyle object
 385  * @renderer: the new renderer
 386  *
 387  * Sets a new renderer.
 388  **/
 389 void
 390 adg_arrow_style_set_renderer (AdgArrowStyle   *arrow_style,
 391                               AdgArrowRenderer renderer)
 392 {
 393   g_return_if_fail (ADG_IS_ARROW_STYLE (arrow_style));
 394
 395   arrow_style->priv->renderer = renderer;
 396   g_object_notify ((GObject *) arrow_style, "renderer");
 397 }
 398
 399
 400 static GPtrArray *
 401 get_pool (void)
 402 {
 403   static GPtrArray *pool = NULL;
 404
 405   if G_UNLIKELY (pool == NULL)
 406     {
 407       pool = g_ptr_array_sized_new (ADG_ARROW_STYLE_LAST);
 408
 409       pool->pdata[ADG_ARROW_STYLE_ARROW] = g_object_new (ADG_TYPE_ARROW_STYLE,
 410                                                          "renderer", arrow_renderer,
 411                                                          NULL);
 412       pool->pdata[ADG_ARROW_STYLE_TRIANGLE] = g_object_new (ADG_TYPE_ARROW_STYLE,
 413                                                             "renderer", triangle_renderer,
 414                                                             NULL);
 415       pool->pdata[ADG_ARROW_STYLE_DOT] = g_object_new (ADG_TYPE_ARROW_STYLE,
 416                                                        "size", 5.,
 417                                                        "angle", 0.,
 418                                                        "margin", 2.5,
 419                                                        "renderer", dot_renderer,
 420                                                        NULL);
 421       pool->pdata[ADG_ARROW_STYLE_CIRCLE] = g_object_new (ADG_TYPE_ARROW_STYLE,
 422                                                           "size", 10.,
 423                                                           "angle", 0.,
 424                                                           "margin", 5.,
 425                                                           "renderer", circle_renderer,
 426                                                           NULL);
 427       pool->pdata[ADG_ARROW_STYLE_BLOCK] = g_object_new (ADG_TYPE_ARROW_STYLE,
 428                                                          "size", 10.,
 429                                                          "angle", 0.,
 430                                                          "margin", 5.,
 431                                                          "renderer", block_renderer,
 432                                                          NULL);
 433       pool->pdata[ADG_ARROW_STYLE_SQUARE] = g_object_new (ADG_TYPE_ARROW_STYLE,
 434                                                           "size", 10.,
 435                                                           "angle", 0.,
 436                                                           "margin", -0.1,
 437                                                           "renderer", square_renderer,
 438                                                           NULL);
 439       pool->pdata[ADG_ARROW_STYLE_TICK] = g_object_new (ADG_TYPE_ARROW_STYLE,
 440                                                         "size", 20.,
 441                                                         "angle", G_PI / 3.,
 442                                                         "margin", 0.,
 443                                                         "renderer", tick_renderer,
 444                                                         NULL);
 445
 446       pool->len = ADG_ARROW_STYLE_LAST;
 447     }
 448
 449   return pool;
 450 }
 451
 452 static void
 453 arrow_renderer (AdgArrowStyle *arrow_style,
 454                 cairo_t       *cr,
 455                 CpmlPath      *segment)
 456 {
 457   draw_triangle (cr, arrow_style, segment);
 458   cairo_fill (cr);
 459 }
 460
 461 static void
 462 triangle_renderer (AdgArrowStyle *arrow_style,
 463                    cairo_t       *cr,
 464                    CpmlPath      *segment)
 465 {
 466   draw_triangle (cr, arrow_style, segment);
 467   cairo_stroke (cr);
 468 }
 469
 470 static void
 471 dot_renderer (AdgArrowStyle *arrow_style,
 472               cairo_t       *cr,
 473               CpmlPath      *segment)
 474 {
 475   draw_circle (cr, arrow_style, segment);
 476   cairo_fill (cr);
 477 }
 478
 479 static void
 480 circle_renderer (AdgArrowStyle *arrow_style,
 481                  cairo_t       *cr,
 482                  CpmlPath      *segment)
 483 {
 484   draw_circle (cr, arrow_style, segment);
 485   cairo_stroke (cr);
 486 }
 487
 488 static void
 489 block_renderer (AdgArrowStyle *arrow_style,
 490                 cairo_t       *cr,
 491                 CpmlPath      *segment)
 492 {
 493   ADG_STUB ();
 494 }
 495
 496 static void
 497 square_renderer (AdgArrowStyle *arrow_style,
 498                  cairo_t       *cr,
 499                  CpmlPath      *segment)
 500 {
 501   ADG_STUB ();
 502 }
 503
 504 static void
 505 tick_renderer (AdgArrowStyle *arrow_style,
 506                cairo_t       *cr,
 507                CpmlPath      *segment)
 508 {
 509   ADG_STUB ();
 510 }
 511
 512 static void
 513 draw_triangle (cairo_t       *cr,
 514                AdgArrowStyle *arrow_style,
 515                CpmlPath      *segment)
 516 {
 517   double   length, height_2;
 518   double   tmp;
 519   CpmlPair tail, tail1, tail2;
 520   CpmlPair vector;
 521
 522   length = arrow_style->priv->size;
 523   height_2 = tan (arrow_style->priv->angle / 2.0) * length;
 524   cairo_device_to_user_distance (cr, &length, &height_2);
 525
 526   switch (segment->cairo_path.data[0].header.type)
 527     {
 528     case CAIRO_PATH_LINE_TO:
 529       cpml_primitive_get_pair (segment, &vector, CPML_FIRST);
 530       vector.x -= segment->org.x;
 531       vector.y -= segment->org.y;
 532       cpml_vector_from_pair (&vector, &vector);
 533
 534       tail.x = vector.x*length + segment->org.x;
 535       tail.y = vector.y*length + segment->org.y;
 536
 537       tmp = vector.x;
 538       vector.x = -vector.y*height_2;
 539       vector.y = tmp*height_2;
 540
 541       tail1.x = tail.x+vector.x;
 542       tail1.y = tail.y+vector.y;
 543
 544       tail2.x = tail.x-vector.x;
 545       tail2.y = tail.y-vector.y;
 546
 547       cairo_move_to (cr, segment->org.x, segment->org.y);
 548       cairo_line_to (cr, tail1.x, tail1.y);
 549       cairo_line_to (cr, tail2.x, tail2.y);
 550       cairo_close_path (cr);
 551
 552       break;
 553     case CAIRO_PATH_CURVE_TO:
 554       ADG_STUB ();
 555       break;
 556     default:
 557       g_assert_not_reached ();
 558     }
 559 }
 560
 561 static void
 562 draw_circle (cairo_t       *cr,
 563              AdgArrowStyle *arrow_style,
 564              CpmlPath      *segment)
 565 {
 566   double radius = arrow_style->priv->size / 2.;
 567   double dummy = 0.;
 568
 569   cairo_device_to_user_distance (cr, &radius, &dummy);
 570   cairo_new_path (cr);
 571   cairo_arc (cr, segment->org.x, segment->org.y, radius, 0., M_PI);
 572 }