git.sur5r.net Git - glabels/blob - src/label-object.c

   1 /*
   2  *  label-object.c
   3  *  Copyright (C) 2001-2009  Jim Evins <evins@snaught.com>.
   4  *
   5  *  This file is part of gLabels.
   6  *
   7  *  gLabels is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  gLabels is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with gLabels.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22
  23 #include "label-object.h"
  24
  25 #include <glib/gi18n.h>
  26 #include <glib.h>
  27 #include <math.h>
  28
  29 #include "marshal.h"
  30
  31 #include "debug.h"
  32
  33
  34 /*========================================================*/
  35 /* Private defines.                                       */
  36 /*========================================================*/
  37
  38 #define DEFAULT_SHADOW_X_OFFSET (3.6)
  39 #define DEFAULT_SHADOW_Y_OFFSET (3.6)
  40 #define DEFAULT_SHADOW_COLOR    GL_COLOR_BLACK
  41 #define DEFAULT_SHADOW_OPACITY  (0.5)
  42
  43 #define HANDLE_FILL_RGBA_ARGS      0.0,   0.75,  0.0,   0.4
  44 #define HANDLE_OUTLINE_RGBA_ARGS   0.0,   0.0,   0.0,   0.8
  45
  46 #define HANDLE_OUTLINE_WIDTH_PIXELS   1.0
  47 #define HANDLE_PIXELS 7
  48
  49
  50 /*========================================================*/
  51 /* Private types.                                         */
  52 /*========================================================*/
  53
  54 struct _glLabelObjectPrivate {
  55
  56         gchar             *name;
  57
  58         gboolean           selected_flag;
  59         glLabel           *parent;
  60
  61         gdouble            x, y;
  62         gdouble            w, h;
  63         cairo_matrix_t     matrix;
  64
  65         gdouble            aspect_ratio;
  66
  67         gboolean           shadow_state;
  68         gdouble            shadow_x;
  69         gdouble            shadow_y;
  70         glColorNode       *shadow_color_node;
  71         gdouble            shadow_opacity;
  72 };
  73
  74 enum {
  75         CHANGED,
  76         MOVED,
  77         LAST_SIGNAL
  78 };
  79
  80
  81 /*========================================================*/
  82 /* Private globals.                                       */
  83 /*========================================================*/
  84
  85 static guint instance = 0;
  86
  87 static guint signals[LAST_SIGNAL] = {0};
  88
  89
  90 /*========================================================*/
  91 /* Private function prototypes.                           */
  92 /*========================================================*/
  93
  94 static void     gl_label_object_finalize  (GObject            *object);
  95
  96 static void     set_size                  (glLabelObject      *object,
  97                                            gdouble             w,
  98                                            gdouble             h,
  99                                            gboolean            checkpoint);
 100
 101
 102 /*****************************************************************************/
 103 /* Boilerplate object stuff.                                                 */
 104 /*****************************************************************************/
 105 G_DEFINE_TYPE (glLabelObject, gl_label_object, G_TYPE_OBJECT)
 106
 107
 108 static void
 109 gl_label_object_class_init (glLabelObjectClass *class)
 110 {
 111         GObjectClass       *object_class = G_OBJECT_CLASS (class);
 112
 113         gl_debug (DEBUG_LABEL, "START");
 114
 115         gl_label_object_parent_class = g_type_class_peek_parent (class);
 116
 117         object_class->finalize = gl_label_object_finalize;
 118
 119         class->set_size     = set_size;
 120         class->draw_handles = gl_label_object_draw_handles_box; /* Default style */
 121         class->handle_at    = gl_label_object_box_handle_at;    /* Default style */
 122
 123         signals[CHANGED] =
 124                 g_signal_new ("changed",
 125                               G_OBJECT_CLASS_TYPE (object_class),
 126                               G_SIGNAL_RUN_LAST,
 127                               G_STRUCT_OFFSET (glLabelObjectClass, changed),
 128                               NULL, NULL,
 129                               gl_marshal_VOID__VOID,
 130                               G_TYPE_NONE,
 131                               0);
 132
 133         signals[MOVED] =
 134                 g_signal_new ("moved",
 135                               G_OBJECT_CLASS_TYPE (object_class),
 136                               G_SIGNAL_RUN_LAST,
 137                               G_STRUCT_OFFSET (glLabelObjectClass, moved),
 138                               NULL, NULL,
 139                               gl_marshal_VOID__VOID,
 140                               G_TYPE_NONE,
 141                               0);
 142
 143         gl_debug (DEBUG_LABEL, "END");
 144 }
 145
 146
 147 static void
 148 gl_label_object_init (glLabelObject *object)
 149 {
 150         gl_debug (DEBUG_LABEL, "START");
 151
 152         object->priv = g_new0 (glLabelObjectPrivate, 1);
 153
 154         object->priv->name = g_strdup_printf ("object%d", instance++);
 155
 156         cairo_matrix_init_identity (&object->priv->matrix);
 157
 158         object->priv->shadow_state = FALSE;
 159         object->priv->shadow_x = DEFAULT_SHADOW_X_OFFSET;
 160         object->priv->shadow_y = DEFAULT_SHADOW_Y_OFFSET;
 161         object->priv->shadow_color_node = gl_color_node_new_default ();
 162         object->priv->shadow_color_node->color = DEFAULT_SHADOW_COLOR;
 163         object->priv->shadow_opacity = DEFAULT_SHADOW_OPACITY;
 164
 165         gl_debug (DEBUG_LABEL, "END");
 166 }
 167
 168
 169 static void
 170 gl_label_object_finalize (GObject *object)
 171 {
 172         glLabelObject *label_object = GL_LABEL_OBJECT (object);
 173
 174         gl_debug (DEBUG_LABEL, "START");
 175
 176         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 177
 178         g_free (label_object->priv->name);
 179         g_free (label_object->priv);
 180
 181         G_OBJECT_CLASS (gl_label_object_parent_class)->finalize (object);
 182
 183         gl_debug (DEBUG_LABEL, "END");
 184 }
 185
 186
 187 /*****************************************************************************/
 188 /* New label object.                                                         */
 189 /*****************************************************************************/
 190 GObject *
 191 gl_label_object_new (glLabel *label)
 192 {
 193         glLabelObject *object;
 194
 195         gl_debug (DEBUG_LABEL, "START");
 196
 197         object = g_object_new (gl_label_object_get_type(), NULL);
 198
 199         gl_label_object_set_parent (object, label);
 200
 201         gl_debug (DEBUG_LABEL, "END");
 202
 203         return G_OBJECT (object);
 204 }
 205
 206
 207 /*****************************************************************************/
 208 /* Duplicate object.                                                         */
 209 /*****************************************************************************/
 210 glLabelObject *
 211 gl_label_object_dup (glLabelObject *src_object,
 212                      glLabel       *label)
 213 {
 214         glLabelObject    *dst_object;
 215         gdouble           x, y, w, h;
 216         cairo_matrix_t    matrix;
 217         gboolean          shadow_state;
 218         gdouble           shadow_x, shadow_y;
 219         glColorNode      *shadow_color_node;
 220         gdouble           shadow_opacity;
 221
 222         gl_debug (DEBUG_LABEL, "START");
 223
 224         g_return_val_if_fail (src_object && GL_IS_LABEL_OBJECT (src_object), NULL);
 225
 226         dst_object = g_object_new (G_OBJECT_TYPE(src_object), NULL);
 227
 228         gl_label_object_set_parent (dst_object, label);
 229         dst_object->priv->selected_flag = src_object->priv->selected_flag;
 230
 231         gl_label_object_get_position      (src_object, &x, &y);
 232         gl_label_object_get_raw_size      (src_object, &w, &h);
 233         gl_label_object_get_matrix        (src_object, &matrix);
 234         gl_label_object_get_shadow_offset (src_object, &shadow_x, &shadow_y);
 235         shadow_color_node = gl_label_object_get_shadow_color   (src_object);
 236         shadow_opacity    = gl_label_object_get_shadow_opacity (src_object);
 237         shadow_state      = gl_label_object_get_shadow_state   (src_object);
 238
 239         gl_label_object_set_position (dst_object, x, y, FALSE);
 240         gl_label_object_set_raw_size (dst_object, w, h, FALSE);
 241         gl_label_object_set_matrix   (dst_object, &matrix);
 242         gl_label_object_set_shadow_offset  (dst_object, shadow_x, shadow_y, FALSE);
 243         gl_label_object_set_shadow_color   (dst_object, shadow_color_node, FALSE);
 244         gl_label_object_set_shadow_opacity (dst_object, shadow_opacity, FALSE);
 245         gl_label_object_set_shadow_state   (dst_object, shadow_state, FALSE);
 246
 247         gl_color_node_free (&shadow_color_node);
 248
 249         if ( GL_LABEL_OBJECT_GET_CLASS(src_object)->copy != NULL )
 250         {
 251                 /* We have an object specific method, use it */
 252                 GL_LABEL_OBJECT_GET_CLASS(src_object)->copy (dst_object, src_object);
 253         }
 254
 255         gl_debug (DEBUG_LABEL, "END");
 256
 257         return dst_object;
 258 }
 259
 260
 261 /*****************************************************************************/
 262 /* Emit "changed" signal (for derived objects).                              */
 263 /*****************************************************************************/
 264 void
 265 gl_label_object_emit_changed (glLabelObject *object)
 266 {
 267         gl_debug (DEBUG_LABEL, "START");
 268
 269         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 270
 271         g_signal_emit (G_OBJECT(object), signals[CHANGED], 0);
 272
 273         gl_debug (DEBUG_LABEL, "END");
 274 }
 275
 276
 277 /*****************************************************************************/
 278 /* Set parent label of object.                                               */
 279 /*****************************************************************************/
 280 void
 281 gl_label_object_set_parent (glLabelObject *object,
 282                             glLabel       *label)
 283 {
 284         gl_debug (DEBUG_LABEL, "START");
 285
 286         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 287         g_return_if_fail (label && GL_IS_LABEL (label));
 288
 289         object->priv->parent = label;
 290 }
 291
 292
 293 /*****************************************************************************/
 294 /* Get parent label of object.                                               */
 295 /*****************************************************************************/
 296 glLabel *
 297 gl_label_object_get_parent (glLabelObject *object)
 298 {
 299         gl_debug (DEBUG_LABEL, "START");
 300
 301         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), NULL);
 302
 303         gl_debug (DEBUG_LABEL, "END");
 304
 305         return object->priv->parent;
 306 }
 307
 308
 309 /*****************************************************************************/
 310 /* Select object.                                                            */
 311 /*****************************************************************************/
 312 void
 313 gl_label_object_select (glLabelObject     *object)
 314 {
 315         object->priv->selected_flag = TRUE;
 316 }
 317
 318
 319 /*****************************************************************************/
 320 /* Unselect object.                                                          */
 321 /*****************************************************************************/
 322 void
 323 gl_label_object_unselect (glLabelObject     *object)
 324 {
 325         object->priv->selected_flag = FALSE;
 326 }
 327
 328
 329 /*****************************************************************************/
 330 /* Is object selected?                                                       */
 331 /*****************************************************************************/
 332 gboolean
 333 gl_label_object_is_selected (glLabelObject     *object)
 334 {
 335         return object->priv->selected_flag;
 336 }
 337
 338
 339 /*****************************************************************************/
 340 /* Set name of object.                                                       */
 341 /*****************************************************************************/
 342 void
 343 gl_label_object_set_name (glLabelObject *object,
 344                           gchar         *name)
 345 {
 346         gl_debug (DEBUG_LABEL, "START");
 347
 348         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 349
 350         g_free(object->priv->name);
 351         object->priv->name = name;
 352
 353         gl_label_object_emit_changed (object);
 354
 355         gl_debug (DEBUG_LABEL, "END");
 356 }
 357
 358
 359 /*****************************************************************************/
 360 /* Get name of object.                                                       */
 361 /*****************************************************************************/
 362 gchar *
 363 gl_label_object_get_name (glLabelObject *object)
 364 {
 365         gl_debug (DEBUG_LABEL, "START");
 366
 367         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), NULL);
 368
 369         gl_debug (DEBUG_LABEL, "END");
 370
 371         return g_strdup(object->priv->name);
 372 }
 373
 374
 375 /*****************************************************************************/
 376 /* Set position of object.                                                   */
 377 /*****************************************************************************/
 378 void
 379 gl_label_object_set_position (glLabelObject *object,
 380                               gdouble        x,
 381                               gdouble        y,
 382                               gboolean       checkpoint)
 383 {
 384         gdouble  dx, dy;
 385
 386         gl_debug (DEBUG_LABEL, "START");
 387
 388         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 389
 390         if ( (x != object->priv->x) || (y != object->priv->y) )
 391         {
 392                 if ( checkpoint )
 393                 {
 394                         gl_label_checkpoint (object->priv->parent, _("Move"));
 395                 }
 396
 397                 dx = x - object->priv->x;
 398                 dy = y - object->priv->y;
 399
 400                 object->priv->x = x;
 401                 object->priv->y = y;
 402
 403                 g_signal_emit (G_OBJECT(object), signals[MOVED], 0);
 404
 405         }
 406
 407         gl_debug (DEBUG_LABEL, "END");
 408 }
 409
 410
 411 /*****************************************************************************/
 412 /* Set position of object relative to old position.                          */
 413 /*****************************************************************************/
 414 void
 415 gl_label_object_set_position_relative (glLabelObject *object,
 416                                        gdouble        dx,
 417                                        gdouble        dy,
 418                                        gboolean       checkpoint)
 419 {
 420         gl_debug (DEBUG_LABEL, "START");
 421
 422         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 423
 424         if ( (dx != 0.0) || (dy != 0.0) )
 425         {
 426                 if ( checkpoint )
 427                 {
 428                         gl_label_checkpoint (object->priv->parent, _("Move"));
 429                 }
 430
 431                 object->priv->x += dx;
 432                 object->priv->y += dy;
 433
 434                 gl_debug (DEBUG_LABEL, "       x = %f, y= %f",
 435                           object->priv->x,
 436                           object->priv->y);
 437
 438                 g_signal_emit (G_OBJECT(object), signals[MOVED], 0);
 439         }
 440
 441         gl_debug (DEBUG_LABEL, "END");
 442 }
 443
 444
 445 /*****************************************************************************/
 446 /* Get position of object.                                                   */
 447 /*****************************************************************************/
 448 void
 449 gl_label_object_get_position (glLabelObject *object,
 450                               gdouble       *x,
 451                               gdouble       *y)
 452 {
 453         gl_debug (DEBUG_LABEL, "START");
 454
 455         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 456
 457         *x = object->priv->x;
 458         *y = object->priv->y;
 459
 460         gl_debug (DEBUG_LABEL, "END");
 461 }
 462
 463
 464 /*---------------------------------------------------------------------------*/
 465 /* PRIVATE.  Default set size method.                                        */
 466 /*---------------------------------------------------------------------------*/
 467 static void
 468 set_size (glLabelObject *object,
 469           gdouble        w,
 470           gdouble        h,
 471           gboolean       checkpoint)
 472 {
 473         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 474
 475         if ( (object->priv->w != w) || (object->priv->h != h) )
 476         {
 477                 if ( checkpoint )
 478                 {
 479                         gl_label_checkpoint (object->priv->parent, _("Resize"));
 480                 }
 481
 482                 object->priv->w = w;
 483                 object->priv->h = h;
 484
 485                 gl_label_object_emit_changed (object);
 486         }
 487 }
 488
 489
 490 /*****************************************************************************/
 491 /* Set size of object.                                                       */
 492 /*****************************************************************************/
 493 void
 494 gl_label_object_set_size (glLabelObject *object,
 495                           gdouble        w,
 496                           gdouble        h,
 497                           gboolean       checkpoint)
 498 {
 499         gl_debug (DEBUG_LABEL, "START");
 500
 501         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 502
 503         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_size != NULL )
 504         {
 505                 /* We have an object specific method, use it */
 506                 GL_LABEL_OBJECT_GET_CLASS(object)->set_size (object, w, h, checkpoint);
 507
 508                 object->priv->aspect_ratio = h / w;
 509         }
 510
 511         gl_debug (DEBUG_LABEL, "END");
 512 }
 513
 514
 515 /*****************************************************************************/
 516 /* Set raw size of object.                                                   */
 517 /*****************************************************************************/
 518 void
 519 gl_label_object_set_raw_size (glLabelObject *object,
 520                               gdouble        w,
 521                               gdouble        h,
 522                               gboolean       checkpoint)
 523 {
 524         gl_debug (DEBUG_LABEL, "START");
 525
 526         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 527
 528         set_size (object, w, h, checkpoint);
 529         object->priv->aspect_ratio = h / w;
 530
 531         gl_debug (DEBUG_LABEL, "END");
 532 }
 533
 534
 535 /*****************************************************************************/
 536 /* Set size of object honoring current aspect ratio.                         */
 537 /*****************************************************************************/
 538 void
 539 gl_label_object_set_size_honor_aspect (glLabelObject *object,
 540                                        gdouble        w,
 541                                        gdouble        h,
 542                                        gboolean       checkpoint)
 543 {
 544         gl_debug (DEBUG_LABEL, "START");
 545
 546         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 547
 548         if ( h > w*object->priv->aspect_ratio )
 549         {
 550                 h = w * object->priv->aspect_ratio;
 551         }
 552         else
 553         {
 554                 w = h / object->priv->aspect_ratio;
 555         }
 556
 557         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_size != NULL )
 558         {
 559                 /* We have an object specific method, use it */
 560                 GL_LABEL_OBJECT_GET_CLASS(object)->set_size (object, w, h, checkpoint);
 561         }
 562
 563         gl_debug (DEBUG_LABEL, "END");
 564 }
 565
 566
 567 /*****************************************************************************/
 568 /* Get raw size method (don't let object content adjust size).               */
 569 /*****************************************************************************/
 570 void
 571 gl_label_object_get_raw_size (glLabelObject *object,
 572                               gdouble       *w,
 573                               gdouble       *h)
 574 {
 575         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 576
 577         *w = object->priv->w;
 578         *h = object->priv->h;
 579 }
 580
 581
 582 /*****************************************************************************/
 583 /* Get size of object.                                                       */
 584 /*****************************************************************************/
 585 void
 586 gl_label_object_get_size (glLabelObject *object,
 587                           gdouble       *w,
 588                           gdouble       *h)
 589 {
 590         gl_debug (DEBUG_LABEL, "START");
 591
 592         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 593
 594         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_size != NULL )
 595         {
 596                 /* We have an object specific method, use it */
 597                 GL_LABEL_OBJECT_GET_CLASS(object)->get_size (object, w, h);
 598         }
 599         else
 600         {
 601                 gl_label_object_get_raw_size (object, w, h);
 602         }
 603
 604         gl_debug (DEBUG_LABEL, "END");
 605 }
 606
 607
 608 /*****************************************************************************/
 609 /* Get extent of object.                                                     */
 610 /*****************************************************************************/
 611 void
 612 gl_label_object_get_extent (glLabelObject *object,
 613                             glLabelRegion *region)
 614 {
 615         gdouble        w, h;
 616         gdouble        line_w;
 617         gdouble        xa1, ya1, xa2, ya2, xa3, ya3, xa4, ya4;
 618         cairo_matrix_t matrix;
 619
 620         gl_debug (DEBUG_LABEL, "START");
 621
 622         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 623
 624         gl_label_object_get_size (object, &w, &h);
 625         line_w = gl_label_object_get_line_width (object);
 626
 627         /* setup untransformed corners of bounding box, account for line width */
 628         xa1 =   - line_w/2;
 629         ya1 =   - line_w/2;
 630         xa2 = w + line_w/2;
 631         ya2 =   - line_w/2;
 632         xa3 = w + line_w/2;
 633         ya3 = h + line_w/2;
 634         xa4 =   - line_w/2;
 635         ya4 = h + line_w/2;
 636
 637         /* transform these points */
 638         gl_label_object_get_matrix (object, &matrix);
 639         cairo_matrix_transform_point (&matrix, &xa1, &ya1);
 640         cairo_matrix_transform_point (&matrix, &xa2, &ya2);
 641         cairo_matrix_transform_point (&matrix, &xa3, &ya3);
 642         cairo_matrix_transform_point (&matrix, &xa4, &ya4);
 643
 644         /* now find the maximum extent of these points in x and y */
 645         region->x1 = MIN (xa1, MIN (xa2, MIN (xa3, xa4))) + object->priv->x;
 646         region->y1 = MIN (ya1, MIN (ya2, MIN (ya3, ya4))) + object->priv->y;
 647         region->x2 = MAX (xa1, MAX (xa2, MAX (xa3, xa4))) + object->priv->x;
 648         region->y2 = MAX (ya1, MAX (ya2, MAX (ya3, ya4))) + object->priv->y;
 649
 650         gl_debug (DEBUG_LABEL, "END");
 651 }
 652
 653
 654 /*****************************************************************************/
 655 /* Can text properties be set for this object?                               */
 656 /*****************************************************************************/
 657 gboolean
 658 gl_label_object_can_text (glLabelObject     *object)
 659 {
 660         gl_debug (DEBUG_LABEL, "");
 661
 662         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
 663
 664         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_font_family != NULL )
 665         {
 666                 return TRUE;
 667         }
 668         else
 669         {
 670                 return FALSE;
 671         }
 672 }
 673
 674
 675 /*****************************************************************************/
 676 /* Set font family for all text contained in object.                         */
 677 /*****************************************************************************/
 678 void
 679 gl_label_object_set_font_family (glLabelObject     *object,
 680                                  const gchar       *font_family,
 681                                  gboolean           checkpoint)
 682 {
 683         gl_debug (DEBUG_LABEL, "START");
 684
 685         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 686
 687         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_font_family != NULL )
 688         {
 689                 /* We have an object specific method, use it */
 690                 GL_LABEL_OBJECT_GET_CLASS(object)->set_font_family (object, font_family, checkpoint);
 691         }
 692
 693         gl_debug (DEBUG_LABEL, "END");
 694 }
 695
 696
 697 /****************************************************************************/
 698 /* Set font size for all text contained in object.                          */
 699 /****************************************************************************/
 700 void
 701 gl_label_object_set_font_size (glLabelObject     *object,
 702                                gdouble            font_size,
 703                                gboolean           checkpoint)
 704 {
 705         gl_debug (DEBUG_LABEL, "START");
 706
 707         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 708
 709         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_font_size != NULL )
 710         {
 711                 /* We have an object specific method, use it */
 712                 GL_LABEL_OBJECT_GET_CLASS(object)->set_font_size (object, font_size, checkpoint);
 713         }
 714
 715         gl_debug (DEBUG_LABEL, "END");
 716 }
 717
 718
 719 /****************************************************************************/
 720 /* Set font weight for all text contained in object.                        */
 721 /****************************************************************************/
 722 void
 723 gl_label_object_set_font_weight (glLabelObject     *object,
 724                                  PangoWeight        font_weight,
 725                                  gboolean           checkpoint)
 726 {
 727         gl_debug (DEBUG_LABEL, "START");
 728
 729         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 730
 731         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_font_weight != NULL )
 732         {
 733                 /* We have an object specific method, use it */
 734                 GL_LABEL_OBJECT_GET_CLASS(object)->set_font_weight (object, font_weight, checkpoint);
 735         }
 736
 737         gl_debug (DEBUG_LABEL, "END");
 738 }
 739
 740
 741 /****************************************************************************/
 742 /* Set font italic flag for all text contained in object.                   */
 743 /****************************************************************************/
 744 void
 745 gl_label_object_set_font_italic_flag (glLabelObject     *object,
 746                                       gboolean           font_italic_flag,
 747                                       gboolean           checkpoint)
 748 {
 749         gl_debug (DEBUG_LABEL, "START");
 750
 751         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 752
 753         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_font_italic_flag != NULL )
 754         {
 755                 /* We have an object specific method, use it */
 756                 GL_LABEL_OBJECT_GET_CLASS(object)->set_font_italic_flag (object, font_italic_flag, checkpoint);
 757         }
 758
 759         gl_debug (DEBUG_LABEL, "END");
 760 }
 761
 762
 763 /****************************************************************************/
 764 /* Set text alignment for all text contained in object.                     */
 765 /****************************************************************************/
 766 void
 767 gl_label_object_set_text_alignment (glLabelObject     *object,
 768                                     PangoAlignment     text_alignment,
 769                                     gboolean           checkpoint)
 770 {
 771         gl_debug (DEBUG_LABEL, "START");
 772
 773         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 774
 775         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_text_alignment != NULL )
 776         {
 777                 /* We have an object specific method, use it */
 778                 GL_LABEL_OBJECT_GET_CLASS(object)->set_text_alignment (object, text_alignment, checkpoint);
 779         }
 780
 781         gl_debug (DEBUG_LABEL, "END");
 782 }
 783
 784
 785 /****************************************************************************/
 786 /* Set text line spacing for all text contained in object.                  */
 787 /****************************************************************************/
 788 void
 789 gl_label_object_set_text_line_spacing (glLabelObject     *object,
 790                                        gdouble            text_line_spacing,
 791                                        gboolean           checkpoint)
 792 {
 793         gl_debug (DEBUG_LABEL, "START");
 794
 795         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 796
 797         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_text_line_spacing != NULL )
 798         {
 799                 /* We have an object specific method, use it */
 800                 GL_LABEL_OBJECT_GET_CLASS(object)->set_text_line_spacing (object, text_line_spacing, checkpoint);
 801         }
 802
 803         gl_debug (DEBUG_LABEL, "END");
 804 }
 805
 806
 807 /****************************************************************************/
 808 /* Set text color for all text contained in object.                         */
 809 /****************************************************************************/
 810 void
 811 gl_label_object_set_text_color (glLabelObject     *object,
 812                                 glColorNode       *text_color_node,
 813                                 gboolean           checkpoint)
 814 {
 815         gl_debug (DEBUG_LABEL, "START");
 816
 817         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
 818
 819         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_text_color != NULL )
 820         {
 821                 /* We have an object specific method, use it */
 822                 GL_LABEL_OBJECT_GET_CLASS(object)->set_text_color (object, text_color_node, checkpoint);
 823         }
 824
 825         gl_debug (DEBUG_LABEL, "END");
 826 }
 827
 828
 829 /*****************************************************************************/
 830 /* Get font family for all text contained in object.                         */
 831 /*****************************************************************************/
 832 gchar *
 833 gl_label_object_get_font_family (glLabelObject     *object)
 834 {
 835         gchar *ret = NULL;
 836
 837         gl_debug (DEBUG_LABEL, "START");
 838
 839         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), NULL);
 840
 841         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_font_family != NULL )
 842         {
 843                 /* We have an object specific method, use it */
 844                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_font_family (object);
 845         }
 846
 847         gl_debug (DEBUG_LABEL, "END");
 848
 849         return ret;
 850 }
 851
 852
 853 /****************************************************************************/
 854 /* Get font size for all text contained in object.                          */
 855 /****************************************************************************/
 856 gdouble
 857 gl_label_object_get_font_size (glLabelObject     *object)
 858 {
 859         gdouble ret = 0.0;
 860
 861         gl_debug (DEBUG_LABEL, "START");
 862
 863         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), 0.0);
 864
 865         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_font_size != NULL )
 866         {
 867                 /* We have an object specific method, use it */
 868                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_font_size (object);
 869         }
 870
 871         gl_debug (DEBUG_LABEL, "END");
 872
 873         return ret;
 874 }
 875
 876
 877 /****************************************************************************/
 878 /* Get font weight for all text contained in object.                        */
 879 /****************************************************************************/
 880 PangoWeight
 881 gl_label_object_get_font_weight (glLabelObject     *object)
 882 {
 883         PangoWeight     ret = PANGO_WEIGHT_NORMAL;
 884
 885         gl_debug (DEBUG_LABEL, "START");
 886
 887         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), PANGO_WEIGHT_NORMAL);
 888
 889         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_font_weight != NULL )
 890         {
 891                 /* We have an object specific method, use it */
 892                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_font_weight (object);
 893         }
 894
 895         gl_debug (DEBUG_LABEL, "END");
 896
 897         return ret;
 898 }
 899
 900
 901 /****************************************************************************/
 902 /* Get font italic flag for all text contained in object.                   */
 903 /****************************************************************************/
 904 gboolean
 905 gl_label_object_get_font_italic_flag (glLabelObject     *object)
 906 {
 907         gboolean ret = FALSE;
 908
 909         gl_debug (DEBUG_LABEL, "START");
 910
 911         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
 912
 913         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_font_italic_flag != NULL )
 914         {
 915                 /* We have an object specific method, use it */
 916                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_font_italic_flag (object);
 917         }
 918
 919         gl_debug (DEBUG_LABEL, "END");
 920
 921         return ret;
 922 }
 923
 924
 925 /****************************************************************************/
 926 /* Get text alignment for all text contained in object.                     */
 927 /****************************************************************************/
 928 PangoAlignment
 929 gl_label_object_get_text_alignment (glLabelObject     *object)
 930 {
 931         PangoAlignment ret = PANGO_ALIGN_LEFT;
 932
 933         gl_debug (DEBUG_LABEL, "START");
 934
 935         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), PANGO_ALIGN_LEFT);
 936
 937         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_text_alignment != NULL )
 938         {
 939                 /* We have an object specific method, use it */
 940                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_text_alignment (object);
 941         }
 942
 943         gl_debug (DEBUG_LABEL, "END");
 944
 945         return ret;
 946 }
 947
 948
 949 /****************************************************************************/
 950 /* Get text line spacing for all text contained in object.                  */
 951 /****************************************************************************/
 952 gdouble
 953 gl_label_object_get_text_line_spacing (glLabelObject     *object)
 954 {
 955         gdouble ret = 0.0;
 956
 957         gl_debug (DEBUG_LABEL, "START");
 958
 959         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), 0.0);
 960
 961         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_text_line_spacing != NULL )
 962         {
 963                 /* We have an object specific method, use it */
 964                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_text_line_spacing (object);
 965         }
 966
 967         gl_debug (DEBUG_LABEL, "END");
 968
 969         return ret;
 970 }
 971
 972
 973 /****************************************************************************/
 974 /* Get text color for all text contained in object.                         */
 975 /****************************************************************************/
 976 glColorNode*
 977 gl_label_object_get_text_color (glLabelObject     *object)
 978 {
 979         glColorNode *ret = NULL;
 980
 981         gl_debug (DEBUG_LABEL, "START");
 982
 983         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), 0);
 984
 985         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_text_color != NULL )
 986         {
 987                 /* We have an object specific method, use it */
 988                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_text_color (object);
 989         }
 990
 991         gl_debug (DEBUG_LABEL, "END");
 992
 993         return ret;
 994 }
 995
 996
 997 /*****************************************************************************/
 998 /* Can fill properties be set for this object?                               */
 999 /*****************************************************************************/
1000 gboolean
1001 gl_label_object_can_fill (glLabelObject     *object)
1002 {
1003         gl_debug (DEBUG_LABEL, "");
1004
1005         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
1006
1007         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_fill_color != NULL )
1008         {
1009                 return TRUE;
1010         }
1011         else
1012         {
1013                 return FALSE;
1014         }
1015
1016 }
1017
1018
1019 /****************************************************************************/
1020 /* Set fill color for object.                                               */
1021 /****************************************************************************/
1022 void
1023 gl_label_object_set_fill_color (glLabelObject     *object,
1024                                 glColorNode       *fill_color_node,
1025                                 gboolean           checkpoint)
1026 {
1027         gl_debug (DEBUG_LABEL, "START");
1028
1029         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1030
1031         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_fill_color != NULL )
1032         {
1033                 /* We have an object specific method, use it */
1034                 GL_LABEL_OBJECT_GET_CLASS(object)->set_fill_color (object, fill_color_node, checkpoint);
1035         }
1036
1037         gl_debug (DEBUG_LABEL, "END");
1038 }
1039
1040
1041 /****************************************************************************/
1042 /* Get fill color for object.                                               */
1043 /****************************************************************************/
1044 glColorNode*
1045 gl_label_object_get_fill_color (glLabelObject     *object)
1046 {
1047         glColorNode *ret = NULL;
1048
1049         gl_debug (DEBUG_LABEL, "START");
1050
1051         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), 0);
1052
1053         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_fill_color != NULL )
1054         {
1055                 /* We have an object specific method, use it */
1056                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_fill_color (object);
1057         }
1058
1059         gl_debug (DEBUG_LABEL, "END");
1060
1061         return ret;
1062 }
1063
1064
1065 /*****************************************************************************/
1066 /* Can line color property be set for this object?                           */
1067 /*****************************************************************************/
1068 gboolean
1069 gl_label_object_can_line_color (glLabelObject     *object)
1070 {
1071         gl_debug (DEBUG_LABEL, "");
1072
1073         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
1074
1075         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_line_color != NULL )
1076         {
1077                 return TRUE;
1078         }
1079         else
1080         {
1081                 return FALSE;
1082         }
1083
1084 }
1085
1086
1087 /****************************************************************************/
1088 /* Set line color for object.                                               */
1089 /****************************************************************************/
1090 void
1091 gl_label_object_set_line_color (glLabelObject     *object,
1092                                 glColorNode       *line_color_node,
1093                                 gboolean           checkpoint)
1094 {
1095         gl_debug (DEBUG_LABEL, "START");
1096
1097         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1098
1099         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_line_color != NULL )
1100         {
1101                 /* We have an object specific method, use it */
1102                 GL_LABEL_OBJECT_GET_CLASS(object)->set_line_color (object, line_color_node, checkpoint);
1103         }
1104
1105         gl_debug (DEBUG_LABEL, "END");
1106 }
1107
1108
1109 /****************************************************************************/
1110 /* Get line color for object.                                               */
1111 /****************************************************************************/
1112 glColorNode*
1113 gl_label_object_get_line_color (glLabelObject     *object)
1114 {
1115         glColorNode *ret = NULL;
1116
1117         gl_debug (DEBUG_LABEL, "START");
1118
1119         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), 0);
1120
1121         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_line_color != NULL )
1122         {
1123                 /* We have an object specific method, use it */
1124                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_line_color (object);
1125         }
1126
1127         gl_debug (DEBUG_LABEL, "END");
1128
1129         return ret;
1130 }
1131
1132
1133 /*****************************************************************************/
1134 /* Can line width property be set for this object?                           */
1135 /*****************************************************************************/
1136 gboolean
1137 gl_label_object_can_line_width (glLabelObject     *object)
1138 {
1139         gl_debug (DEBUG_LABEL, "");
1140
1141         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
1142
1143         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_line_width != NULL )
1144         {
1145                 return TRUE;
1146         }
1147         else
1148         {
1149                 return FALSE;
1150         }
1151
1152 }
1153
1154
1155 /****************************************************************************/
1156 /* Set line width for object.                                               */
1157 /****************************************************************************/
1158 void
1159 gl_label_object_set_line_width (glLabelObject     *object,
1160                                 gdouble            line_width,
1161                                 gboolean           checkpoint)
1162 {
1163         gl_debug (DEBUG_LABEL, "START");
1164
1165         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1166
1167         if ( GL_LABEL_OBJECT_GET_CLASS(object)->set_line_width != NULL )
1168         {
1169                 /* We have an object specific method, use it */
1170                 GL_LABEL_OBJECT_GET_CLASS(object)->set_line_width (object, line_width, checkpoint);
1171         }
1172
1173         gl_debug (DEBUG_LABEL, "END");
1174 }
1175
1176
1177 /****************************************************************************/
1178 /* Get line width for object.                                               */
1179 /****************************************************************************/
1180 gdouble
1181 gl_label_object_get_line_width (glLabelObject     *object)
1182 {
1183         gdouble ret = 0.0;
1184
1185         gl_debug (DEBUG_LABEL, "START");
1186
1187         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), 0.0);
1188
1189         if ( GL_LABEL_OBJECT_GET_CLASS(object)->get_line_width != NULL )
1190         {
1191                 /* We have an object specific method, use it */
1192                 ret = GL_LABEL_OBJECT_GET_CLASS(object)->get_line_width (object);
1193         }
1194
1195         gl_debug (DEBUG_LABEL, "END");
1196
1197         return ret;
1198 }
1199
1200
1201 /****************************************************************************/
1202 /* Set shadow state of object.                                              */
1203 /****************************************************************************/
1204 void
1205 gl_label_object_set_shadow_state (glLabelObject     *object,
1206                                   gboolean           state,
1207                                   gboolean           checkpoint)
1208 {
1209         gl_debug (DEBUG_LABEL, "START");
1210
1211         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1212
1213         if (object->priv->shadow_state != state)
1214         {
1215                 if ( checkpoint )
1216                 {
1217                         gl_label_checkpoint (object->priv->parent, _("Shadow state"));
1218                 }
1219
1220                 object->priv->shadow_state = state;
1221
1222                 gl_label_object_emit_changed (object);
1223         }
1224
1225         gl_debug (DEBUG_LABEL, "END");
1226 }
1227
1228
1229 /****************************************************************************/
1230 /* Get shadow state of object.                                              */
1231 /****************************************************************************/
1232 gboolean
1233 gl_label_object_get_shadow_state (glLabelObject     *object)
1234 {
1235         gl_debug (DEBUG_LABEL, "");
1236
1237         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
1238
1239         return object->priv->shadow_state;
1240 }
1241
1242
1243 /****************************************************************************/
1244 /* Set offset of object's shadow.                                           */
1245 /****************************************************************************/
1246 void
1247 gl_label_object_set_shadow_offset (glLabelObject     *object,
1248                                    gdouble            x,
1249                                    gdouble            y,
1250                                    gboolean           checkpoint)
1251 {
1252         gl_debug (DEBUG_LABEL, "START");
1253
1254         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1255
1256         if ( (x != object->priv->shadow_x) || (y != object->priv->shadow_y) )
1257         {
1258                 if ( checkpoint )
1259                 {
1260                         gl_label_checkpoint (object->priv->parent, _("Shadow offset"));
1261                 }
1262
1263                 object->priv->shadow_x = x;
1264                 object->priv->shadow_y = y;
1265
1266                 gl_label_object_emit_changed (object);
1267         }
1268
1269         gl_debug (DEBUG_LABEL, "END");
1270 }
1271
1272
1273 /****************************************************************************/
1274 /* Get offset of object's shadow.                                           */
1275 /****************************************************************************/
1276 void
1277 gl_label_object_get_shadow_offset (glLabelObject     *object,
1278                                    gdouble           *x,
1279                                    gdouble           *y)
1280 {
1281         gl_debug (DEBUG_LABEL, "START");
1282
1283         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1284
1285         *x = object->priv->shadow_x;
1286         *y = object->priv->shadow_y;
1287
1288         gl_debug (DEBUG_LABEL, "END");
1289 }
1290
1291
1292 /****************************************************************************/
1293 /* Set color of object's shadow.                                            */
1294 /****************************************************************************/
1295 void
1296 gl_label_object_set_shadow_color (glLabelObject     *object,
1297                                   glColorNode       *color_node,
1298                                   gboolean           checkpoint)
1299 {
1300         gl_debug (DEBUG_LABEL, "START");
1301
1302         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1303
1304         if ( !gl_color_node_equal (object->priv->shadow_color_node, color_node ))
1305         {
1306                 if ( checkpoint )
1307                 {
1308                         gl_label_checkpoint (object->priv->parent, _("Shadow color"));
1309                 }
1310
1311                 gl_color_node_free (&(object->priv->shadow_color_node));
1312                 object->priv->shadow_color_node = gl_color_node_dup (color_node);
1313
1314                 gl_label_object_emit_changed (object);
1315         }
1316
1317         gl_debug (DEBUG_LABEL, "END");
1318 }
1319
1320
1321 /****************************************************************************/
1322 /* Get color of object's shadow.                                            */
1323 /****************************************************************************/
1324 glColorNode*
1325 gl_label_object_get_shadow_color (glLabelObject     *object)
1326 {
1327         gl_debug (DEBUG_LABEL, "");
1328
1329         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), NULL);
1330
1331         return gl_color_node_dup (object->priv->shadow_color_node);
1332 }
1333
1334
1335 /****************************************************************************/
1336 /* Set opacity of object's shadow.                                          */
1337 /****************************************************************************/
1338 void
1339 gl_label_object_set_shadow_opacity (glLabelObject     *object,
1340                                     gdouble            alpha,
1341                                     gboolean           checkpoint)
1342 {
1343         gl_debug (DEBUG_LABEL, "START");
1344
1345         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1346
1347         if (object->priv->shadow_opacity != alpha)
1348         {
1349                 if ( checkpoint )
1350                 {
1351                         gl_label_checkpoint (object->priv->parent, _("Shadow opacity"));
1352                 }
1353
1354                 object->priv->shadow_opacity = alpha;
1355
1356                 gl_label_object_emit_changed (object);
1357         }
1358
1359         gl_debug (DEBUG_LABEL, "END");
1360 }
1361
1362
1363 /****************************************************************************/
1364 /* Get opacity of object's shadow.                                          */
1365 /****************************************************************************/
1366 gdouble
1367 gl_label_object_get_shadow_opacity (glLabelObject     *object)
1368 {
1369         gl_debug (DEBUG_LABEL, "");
1370
1371         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
1372
1373         return object->priv->shadow_opacity;
1374 }
1375
1376
1377 /****************************************************************************/
1378 /* Flip object horizontally.                                                */
1379 /****************************************************************************/
1380 void
1381 gl_label_object_flip_horiz (glLabelObject *object)
1382 {
1383         cairo_matrix_t flip_matrix;
1384
1385         gl_debug (DEBUG_LABEL, "START");
1386
1387         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1388
1389         cairo_matrix_init_scale (&flip_matrix, -1.0, 1.0);
1390         cairo_matrix_multiply (&object->priv->matrix, &object->priv->matrix, &flip_matrix);
1391
1392         gl_debug (DEBUG_LABEL, "END");
1393 }
1394
1395
1396 /****************************************************************************/
1397 /* Flip object vertically.                                                  */
1398 /****************************************************************************/
1399 void
1400 gl_label_object_flip_vert (glLabelObject *object)
1401 {
1402         cairo_matrix_t flip_matrix;
1403
1404         gl_debug (DEBUG_LABEL, "START");
1405
1406         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1407
1408         cairo_matrix_init_scale (&flip_matrix, 1.0, -1.0);
1409         cairo_matrix_multiply (&object->priv->matrix, &object->priv->matrix, &flip_matrix);
1410
1411         gl_debug (DEBUG_LABEL, "END");
1412 }
1413
1414
1415 /****************************************************************************/
1416 /* Rotate object.                                                           */
1417 /****************************************************************************/
1418 void
1419 gl_label_object_rotate (glLabelObject *object,
1420                         gdouble        theta_degs)
1421 {
1422         cairo_matrix_t rotate_matrix;
1423
1424         gl_debug (DEBUG_LABEL, "START");
1425
1426         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1427
1428         cairo_matrix_init_rotate (&rotate_matrix, theta_degs*(G_PI/180.));
1429         cairo_matrix_multiply (&object->priv->matrix, &object->priv->matrix, &rotate_matrix);
1430
1431         gl_debug (DEBUG_LABEL, "END");
1432 }
1433
1434
1435 /****************************************************************************/
1436 /* Set raw affine                                                           */
1437 /****************************************************************************/
1438 void
1439 gl_label_object_set_matrix (glLabelObject  *object,
1440                             cairo_matrix_t *matrix)
1441 {
1442         gl_debug (DEBUG_LABEL, "");
1443
1444         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1445
1446         object->priv->matrix = *matrix;
1447 }
1448
1449
1450 /****************************************************************************/
1451 /* Get raw affine                                                           */
1452 /****************************************************************************/
1453 void
1454 gl_label_object_get_matrix (glLabelObject  *object,
1455                             cairo_matrix_t *matrix)
1456 {
1457         gl_debug (DEBUG_LABEL, "");
1458
1459         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1460
1461         *matrix = object->priv->matrix;
1462 }
1463
1464
1465 /*****************************************************************************/
1466 /* Draw object                                                               */
1467 /*****************************************************************************/
1468 void
1469 gl_label_object_draw (glLabelObject *object,
1470                       cairo_t       *cr,
1471                       gboolean       screen_flag,
1472                       glMergeRecord *record)
1473
1474 {
1475         gdouble        x0, y0;
1476         cairo_matrix_t matrix;
1477         gboolean       shadow_state;
1478         gdouble        shadow_x, shadow_y;
1479
1480         gl_debug (DEBUG_LABEL, "START");
1481
1482         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1483
1484         gl_label_object_get_position (object, &x0, &y0);
1485         gl_label_object_get_matrix (object, &matrix);
1486
1487         cairo_save (cr);
1488         cairo_translate (cr, x0, y0);
1489
1490         if ( GL_LABEL_OBJECT_GET_CLASS(object)->draw_shadow != NULL )
1491         {
1492                 shadow_state = gl_label_object_get_shadow_state (object);
1493
1494                 if ( shadow_state )
1495                 {
1496                         gl_label_object_get_shadow_offset (object, &shadow_x, &shadow_y);
1497
1498                         cairo_save (cr);
1499                         cairo_translate (cr, shadow_x, shadow_y);
1500                         cairo_transform (cr, &matrix);
1501
1502                         GL_LABEL_OBJECT_GET_CLASS(object)->draw_shadow (object,
1503                                                                         cr,
1504                                                                         screen_flag,
1505                                                                         record);
1506
1507                         cairo_restore (cr);
1508                 }
1509         }
1510
1511         if ( GL_LABEL_OBJECT_GET_CLASS(object)->draw_object != NULL )
1512         {
1513                 cairo_save (cr);
1514                 cairo_transform (cr, &matrix);
1515
1516                 GL_LABEL_OBJECT_GET_CLASS(object)->draw_object (object,
1517                                                                 cr,
1518                                                                 screen_flag,
1519                                                                 record);
1520
1521                 cairo_restore (cr);
1522         }
1523
1524         cairo_restore (cr);
1525
1526         gl_debug (DEBUG_LABEL, "END");
1527 }
1528
1529
1530 /*****************************************************************************/
1531 /* Is object located at coordinates.                                         */
1532 /*****************************************************************************/
1533 gboolean
1534 gl_label_object_is_located_at (glLabelObject     *object,
1535                                cairo_t           *cr,
1536                                gdouble            x_pixels,
1537                                gdouble            y_pixels)
1538 {
1539         gboolean            ret_val = FALSE;
1540         gdouble             x0, y0;
1541         cairo_matrix_t      matrix;
1542         gdouble             x, y;
1543
1544         gl_debug (DEBUG_LABEL, "START");
1545
1546         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), FALSE);
1547
1548         if ( GL_LABEL_OBJECT_GET_CLASS(object)->draw_object != NULL )
1549         {
1550
1551                 gl_label_object_get_position (object, &x0, &y0);
1552                 gl_label_object_get_matrix (object, &matrix);
1553
1554                 cairo_save (cr);
1555
1556                 cairo_translate (cr, x0, y0);
1557                 cairo_transform (cr, &matrix);
1558
1559                 x = x_pixels;
1560                 y = y_pixels;
1561                 cairo_device_to_user (cr, &x, &y);
1562
1563                 ret_val = GL_LABEL_OBJECT_GET_CLASS(object)->object_at (object, cr, x, y);
1564
1565                 cairo_restore (cr);
1566         }
1567
1568         gl_debug (DEBUG_LABEL, "END");
1569
1570         return ret_val;
1571 }
1572
1573
1574 /*****************************************************************************/
1575 /* Draw object handles                                                       */
1576 /*****************************************************************************/
1577 void
1578 gl_label_object_draw_handles (glLabelObject     *object,
1579                               cairo_t           *cr)
1580 {
1581         gdouble        x0, y0;
1582         cairo_matrix_t matrix;
1583
1584         gl_debug (DEBUG_LABEL, "START");
1585
1586         g_return_if_fail (object && GL_IS_LABEL_OBJECT (object));
1587
1588         if ( GL_LABEL_OBJECT_GET_CLASS(object)->draw_object != NULL )
1589         {
1590
1591                 gl_label_object_get_position (object, &x0, &y0);
1592                 gl_label_object_get_matrix (object, &matrix);
1593
1594                 cairo_save (cr);
1595
1596                 cairo_translate (cr, x0, y0);
1597                 cairo_transform (cr, &matrix);
1598
1599                 GL_LABEL_OBJECT_GET_CLASS(object)->draw_handles (object, cr);
1600
1601                 cairo_restore (cr);
1602         }
1603
1604         gl_debug (DEBUG_LABEL, "END");
1605 }
1606
1607
1608 /*--------------------------------------------------------------------------*/
1609 /* Draw individual handle                                                   */
1610 /*--------------------------------------------------------------------------*/
1611 static void
1612 draw_handle (cairo_t                *cr,
1613              glLabelObject          *object,
1614              gdouble                 x_handle,
1615              gdouble                 y_handle)
1616 {
1617         gdouble scale_x, scale_y;
1618
1619
1620         gl_debug (DEBUG_VIEW, "START");
1621
1622         cairo_save (cr);
1623
1624         cairo_translate (cr, x_handle, y_handle);
1625
1626         scale_x = 1.0;
1627         scale_y = 1.0;
1628         cairo_device_to_user_distance (cr, &scale_x, &scale_y);
1629         cairo_scale (cr, scale_x, scale_y);
1630
1631         cairo_rectangle (cr,
1632                          -HANDLE_PIXELS/2.0, -HANDLE_PIXELS/2.0,
1633                          HANDLE_PIXELS, HANDLE_PIXELS);
1634
1635         cairo_set_source_rgba (cr, HANDLE_FILL_RGBA_ARGS);
1636         cairo_fill_preserve (cr);
1637
1638         cairo_set_line_width (cr, HANDLE_OUTLINE_WIDTH_PIXELS);
1639         cairo_set_source_rgba (cr, HANDLE_OUTLINE_RGBA_ARGS);
1640         cairo_stroke (cr);
1641
1642         cairo_restore (cr);
1643
1644         gl_debug (DEBUG_VIEW, "END");
1645 }
1646
1647
1648 /*--------------------------------------------------------------------------*/
1649 /* Create handle path                                                       */
1650 /*--------------------------------------------------------------------------*/
1651 static void
1652 create_handle_path (cairo_t                *cr,
1653                     glLabelObject          *object,
1654                     gdouble                 x_handle,
1655                     gdouble                 y_handle)
1656 {
1657         gdouble scale_x, scale_y;
1658
1659
1660         gl_debug (DEBUG_VIEW, "START");
1661
1662         cairo_save (cr);
1663
1664         cairo_translate (cr, x_handle, y_handle);
1665
1666         scale_x = 1.0;
1667         scale_y = 1.0;
1668         cairo_device_to_user_distance (cr, &scale_x, &scale_y);
1669         cairo_scale (cr, scale_x, scale_y);
1670
1671         cairo_rectangle (cr,
1672                          -HANDLE_PIXELS/2.0, -HANDLE_PIXELS/2.0,
1673                          HANDLE_PIXELS, HANDLE_PIXELS);
1674
1675         cairo_restore (cr);
1676
1677         gl_debug (DEBUG_VIEW, "END");
1678 }
1679
1680
1681 /*****************************************************************************/
1682 /* Draw box style handles.                                                   */
1683 /*****************************************************************************/
1684 void
1685 gl_label_object_draw_handles_box (glLabelObject     *object,
1686                                   cairo_t           *cr)
1687 {
1688         gdouble w, h;
1689
1690         gl_label_object_get_size (GL_LABEL_OBJECT(object), &w, &h);
1691
1692         /* North */
1693         draw_handle (cr, object, w/2, 0);
1694
1695         /* North East */
1696         draw_handle (cr, object, w, 0);
1697
1698         /* East */
1699         draw_handle (cr, object, w, h/2);
1700
1701         /* South East */
1702         draw_handle (cr, object, w, h);
1703
1704         /* South */
1705         draw_handle (cr, object, w/2, h);
1706
1707         /* South West */
1708         draw_handle (cr, object, 0, h);
1709
1710         /* West */
1711         draw_handle (cr, object, 0, h/2);
1712
1713         /* North West */
1714         draw_handle (cr, object, 0, 0);
1715 }
1716
1717
1718 /*****************************************************************************/
1719 /* Draw line style handles.                                                  */
1720 /*****************************************************************************/
1721 void
1722 gl_label_object_draw_handles_line (glLabelObject     *object,
1723                                    cairo_t           *cr)
1724 {
1725         gdouble w, h;
1726
1727         gl_label_object_get_size (GL_LABEL_OBJECT(object), &w, &h);
1728
1729         /* P2 */
1730         draw_handle (cr, object, w, h);
1731
1732         /* P1 */
1733         draw_handle (cr, object, 0, 0);
1734 }
1735
1736
1737 /*****************************************************************************/
1738 /* Get handle at given coordinates, if any.                                  */
1739 /*****************************************************************************/
1740 glLabelObjectHandle
1741 gl_label_object_handle_at (glLabelObject     *object,
1742                            cairo_t           *cr,
1743                            gdouble            x_pixels,
1744                            gdouble            y_pixels)
1745 {
1746         glLabelObjectHandle handle = GL_LABEL_OBJECT_HANDLE_NONE;
1747         gdouble             x0, y0;
1748         cairo_matrix_t      matrix;
1749         gdouble             x, y;
1750
1751         gl_debug (DEBUG_LABEL, "START");
1752
1753         g_return_val_if_fail (object && GL_IS_LABEL_OBJECT (object), handle);
1754
1755         if ( GL_LABEL_OBJECT_GET_CLASS(object)->draw_object != NULL )
1756         {
1757
1758                 gl_label_object_get_position (object, &x0, &y0);
1759                 gl_label_object_get_matrix (object, &matrix);
1760
1761                 cairo_save (cr);
1762
1763                 cairo_translate (cr, x0, y0);
1764                 cairo_transform (cr, &matrix);
1765
1766                 x = x_pixels;
1767                 y = y_pixels;
1768                 cairo_device_to_user (cr, &x, &y);
1769
1770                 handle = GL_LABEL_OBJECT_GET_CLASS(object)->handle_at (object, cr, x, y);
1771
1772                 cairo_restore (cr);
1773         }
1774
1775         gl_debug (DEBUG_LABEL, "END");
1776
1777         return handle;
1778 }
1779
1780
1781 /*****************************************************************************/
1782 /* Get handle at given coordinates for box style handles, if any.            */
1783 /*****************************************************************************/
1784 glLabelObjectHandle
1785 gl_label_object_box_handle_at (glLabelObject     *object,
1786                                cairo_t           *cr,
1787                                gdouble            x,
1788                                gdouble            y)
1789 {
1790         gdouble w, h;
1791
1792         gl_label_object_get_size (GL_LABEL_OBJECT(object), &w, &h);
1793
1794         /* South East */
1795         create_handle_path (cr, object, w, h);
1796         if (cairo_in_fill (cr, x, y))
1797         {
1798                 return GL_LABEL_OBJECT_HANDLE_SE;
1799         }
1800
1801         /* South West */
1802         create_handle_path (cr, object, 0, h);
1803         if (cairo_in_fill (cr, x, y))
1804         {
1805                 return GL_LABEL_OBJECT_HANDLE_SW;
1806         }
1807
1808         /* North East */
1809         create_handle_path (cr, object, w, 0);
1810         if (cairo_in_fill (cr, x, y))
1811         {
1812                 return GL_LABEL_OBJECT_HANDLE_NE;
1813         }
1814
1815         /* North West */
1816         create_handle_path (cr, object, 0, 0);
1817         if (cairo_in_fill (cr, x, y))
1818         {
1819                 return GL_LABEL_OBJECT_HANDLE_NW;
1820         }
1821
1822         /* East */
1823         create_handle_path (cr, object, w, h/2);
1824         if (cairo_in_fill (cr, x, y))
1825         {
1826                 return GL_LABEL_OBJECT_HANDLE_E;
1827         }
1828
1829         /* South */
1830         create_handle_path (cr, object, w/2, h);
1831         if (cairo_in_fill (cr, x, y))
1832         {
1833                 return GL_LABEL_OBJECT_HANDLE_S;
1834         }
1835
1836         /* West */
1837         create_handle_path (cr, object, 0, h/2);
1838         if (cairo_in_fill (cr, x, y))
1839         {
1840                 return GL_LABEL_OBJECT_HANDLE_W;
1841         }
1842
1843         /* North */
1844         create_handle_path (cr, object, w/2, 0);
1845         if (cairo_in_fill (cr, x, y))
1846         {
1847                 return GL_LABEL_OBJECT_HANDLE_N;
1848         }
1849
1850         return GL_LABEL_OBJECT_HANDLE_NONE;
1851 }
1852
1853
1854 /*****************************************************************************/
1855 /* Get handle at given coordinates for line style handles, if any.           */
1856 /*****************************************************************************/
1857 glLabelObjectHandle
1858 gl_label_object_line_handle_at (glLabelObject     *object,
1859                                 cairo_t           *cr,
1860                                 gdouble            x,
1861                                 gdouble            y)
1862 {
1863         gdouble w, h;
1864
1865         gl_label_object_get_size (GL_LABEL_OBJECT(object), &w, &h);
1866
1867         /* P2 */
1868         create_handle_path (cr, object, w, h);
1869         if (cairo_in_fill (cr, x, y))
1870         {
1871                 return GL_LABEL_OBJECT_HANDLE_P2;
1872         }
1873
1874         /* P1 */
1875         create_handle_path (cr, object, 0, h);
1876         if (cairo_in_fill (cr, x, y))
1877         {
1878                 return GL_LABEL_OBJECT_HANDLE_P1;
1879         }
1880
1881         return GL_LABEL_OBJECT_HANDLE_NONE;
1882 }
1883
1884
1885
1886
1887 /*
1888  * Local Variables:       -- emacs
1889  * mode: C                -- emacs
1890  * c-basic-offset: 8      -- emacs
1891  * tab-width: 8           -- emacs
1892  * indent-tabs-mode: nil  -- emacs
1893  * End:                   -- emacs
1894  */