src/sp-shape.cpp

   1 #define __SP_SHAPE_C__
   2
   3 /*
   4  * Base class for shapes, including <path> element
   5  *
   6  * Author:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *
   9  * Copyright (C) 1999-2002 Lauris Kaplinski
  10  * Copyright (C) 2000-2001 Ximian, Inc.
  11  * Copyright (C) 2004 John Cliff
  12  *
  13  * Released under GNU GPL, read the file 'COPYING' for more information
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include "config.h"
  18 #endif
  19
  20
  21 #include <libnr/n-art-bpath.h>
  22 #include <libnr/nr-matrix-fns.h>
  23 #include <libnr/nr-matrix-ops.h>
  24 #include <libnr/nr-matrix-translate-ops.h>
  25 #include <libnr/nr-scale-matrix-ops.h>
  26
  27 #include <sigc++/functors/ptr_fun.h>
  28 #include <sigc++/adaptors/bind.h>
  29
  30 #include "macros.h"
  31 #include "display/nr-arena-shape.h"
  32 #include "print.h"
  33 #include "document.h"
  34 #include "marker-status.h"
  35 #include "style.h"
  36 #include "sp-marker.h"
  37 #include "sp-path.h"
  38 #include "prefs-utils.h"
  39
  40 #define noSHAPE_VERBOSE
  41
  42 static void sp_shape_class_init (SPShapeClass *klass);
  43 static void sp_shape_init (SPShape *shape);
  44 static void sp_shape_finalize (GObject *object);
  45
  46 static void sp_shape_build (SPObject * object, SPDocument * document, Inkscape::XML::Node * repr);
  47 static void sp_shape_release (SPObject *object);
  48
  49 static void sp_shape_update (SPObject *object, SPCtx *ctx, unsigned int flags);
  50 static void sp_shape_modified (SPObject *object, unsigned int flags);
  51
  52 static void sp_shape_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const flags);
  53 void sp_shape_print (SPItem * item, SPPrintContext * ctx);
  54 static NRArenaItem *sp_shape_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags);
  55 static void sp_shape_hide (SPItem *item, unsigned int key);
  56 static void sp_shape_snappoints (SPItem const *item, SnapPointsIter p);
  57
  58 static void sp_shape_update_marker_view (SPShape *shape, NRArenaItem *ai);
  59
  60 static SPItemClass *parent_class;
  61
  62 /**
  63  * Registers the SPShape class with Gdk and returns its type number.
  64  */
  65 GType
  66 sp_shape_get_type (void)
  67 {
  68         static GType type = 0;
  69         if (!type) {
  70                 GTypeInfo info = {
  71                         sizeof (SPShapeClass),
  72                         NULL, NULL,
  73                         (GClassInitFunc) sp_shape_class_init,
  74                         NULL, NULL,
  75                         sizeof (SPShape),
  76                         16,
  77                         (GInstanceInitFunc) sp_shape_init,
  78                         NULL,   /* value_table */
  79                 };
  80                 type = g_type_register_static (SP_TYPE_ITEM, "SPShape", &info, (GTypeFlags)0);
  81         }
  82         return type;
  83 }
  84
  85 /**
  86  * Initializes a SPShapeClass object.  Establishes the function pointers to the class'
  87  * member routines in the class vtable, and sets pointers to parent classes.
  88  */
  89 static void
  90 sp_shape_class_init (SPShapeClass *klass)
  91 {
  92         GObjectClass *gobject_class;
  93         SPObjectClass *sp_object_class;
  94         SPItemClass * item_class;
  95         SPPathClass * path_class;
  96
  97         gobject_class = (GObjectClass *) klass;
  98         sp_object_class = (SPObjectClass *) klass;
  99         item_class = (SPItemClass *) klass;
 100         path_class = (SPPathClass *) klass;
 101
 102         parent_class = (SPItemClass *)g_type_class_peek_parent (klass);
 103
 104         gobject_class->finalize = sp_shape_finalize;
 105
 106         sp_object_class->build = sp_shape_build;
 107         sp_object_class->release = sp_shape_release;
 108         sp_object_class->update = sp_shape_update;
 109         sp_object_class->modified = sp_shape_modified;
 110
 111         item_class->bbox = sp_shape_bbox;
 112         item_class->print = sp_shape_print;
 113         item_class->show = sp_shape_show;
 114         item_class->hide = sp_shape_hide;
 115         item_class->snappoints = sp_shape_snappoints;
 116 }
 117
 118 /**
 119  * Initializes an SPShape object.
 120  */
 121 static void
 122 sp_shape_init (SPShape *shape)
 123 {
 124     for ( int i = 0 ; i < SP_MARKER_LOC_QTY ; i++ ) {
 125         new (&shape->release_connect[i]) sigc::connection();
 126         new (&shape->modified_connect[i]) sigc::connection();
 127     }
 128 }
 129
 130 static void
 131 sp_shape_finalize (GObject *object)
 132 {
 133     SPShape *shape=(SPShape *)object;
 134
 135     for ( int i = 0 ; i < SP_MARKER_LOC_QTY ; i++ ) {
 136         shape->release_connect[i].disconnect();
 137         shape->release_connect[i].~connection();
 138         shape->modified_connect[i].disconnect();
 139         shape->modified_connect[i].~connection();
 140     }
 141
 142     if (((GObjectClass *) (parent_class))->finalize) {
 143         (* ((GObjectClass *) (parent_class))->finalize)(object);
 144     }
 145 }
 146
 147 /**
 148  * Virtual build callback for SPMarker.
 149  *
 150  * This is to be invoked immediately after creation of an SPShape.  This is
 151  * just a stub.
 152  *
 153  * \see sp_object_build()
 154  */
 155 static void
 156 sp_shape_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 157 {
 158         if (((SPObjectClass *) (parent_class))->build) {
 159           (*((SPObjectClass *) (parent_class))->build) (object, document, repr);
 160         }
 161 }
 162
 163 /**
 164  * Removes, releases and unrefs all children of object
 165  *
 166  * This is the inverse of sp_shape_build().  It must be invoked as soon
 167  * as the shape is removed from the tree, even if it is still referenced
 168  * by other objects.  This routine also disconnects/unrefs markers and
 169  * curves attached to it.
 170  *
 171  * \see sp_object_release()
 172  */
 173 static void
 174 sp_shape_release (SPObject *object)
 175 {
 176         SPItem *item;
 177         SPShape *shape;
 178         SPItemView *v;
 179         int i;
 180
 181         item = (SPItem *) object;
 182         shape = (SPShape *) object;
 183
 184         for (i=SP_MARKER_LOC_START; i<SP_MARKER_LOC_QTY; i++) {
 185           if (shape->marker[i]) {
 186             sp_signal_disconnect_by_data (shape->marker[i], object);
 187             for (v = item->display; v != NULL; v = v->next) {
 188               sp_marker_hide ((SPMarker *) shape->marker[i], NR_ARENA_ITEM_GET_KEY (v->arenaitem) + i);
 189             }
 190             shape->marker[i] = sp_object_hunref (shape->marker[i], object);
 191           }
 192         }
 193         if (shape->curve) {
 194                 shape->curve = sp_curve_unref (shape->curve);
 195         }
 196
 197         if (((SPObjectClass *) parent_class)->release) {
 198           ((SPObjectClass *) parent_class)->release (object);
 199         }
 200 }
 201
 202 /**
 203  * Updates the shape when its attributes have changed.  Also establishes
 204  * marker objects to match the style settings.
 205  */
 206 static void
 207 sp_shape_update (SPObject *object, SPCtx *ctx, unsigned int flags)
 208 {
 209     SPItem *item = (SPItem *) object;
 210     SPShape *shape = (SPShape *) object;
 211
 212         if (((SPObjectClass *) (parent_class))->update) {
 213           (* ((SPObjectClass *) (parent_class))->update) (object, ctx, flags);
 214         }
 215
 216         /* This stanza checks that an object's marker style agrees with
 217          * the marker objects it has allocated.  sp_shape_set_marker ensures
 218          * that the appropriate marker objects are present (or absent) to
 219          * match the style.
 220          */
 221         /* TODO:  It would be nice if this could be done at an earlier level */
 222         for (int i = 0 ; i < SP_MARKER_LOC_QTY ; i++) {
 223             sp_shape_set_marker (object, i, object->style->marker[i].value);
 224           }
 225
 226         if (flags & (SP_OBJECT_STYLE_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
 227                 SPStyle *style;
 228                 style = SP_OBJECT_STYLE (object);
 229                 if (style->stroke_width.unit == SP_CSS_UNIT_PERCENT) {
 230                         SPItemCtx *ictx = (SPItemCtx *) ctx;
 231                         double const aw = 1.0 / NR::expansion(ictx->i2vp);
 232                         style->stroke_width.computed = style->stroke_width.value * aw;
 233                         for (SPItemView *v = ((SPItem *) (shape))->display; v != NULL; v = v->next) {
 234                                 nr_arena_shape_set_style ((NRArenaShape *) v->arenaitem, style);
 235                         }
 236                 }
 237         }
 238
 239         if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG)) {
 240                 /* This is suboptimal, because changing parent style schedules recalculation */
 241                 /* But on the other hand - how can we know that parent does not tie style and transform */
 242                 NR::Rect const paintbox = SP_ITEM(object)->invokeBbox(NR::identity());
 243                 for (SPItemView *v = SP_ITEM (shape)->display; v != NULL; v = v->next) {
 244                     NRArenaShape * const s = NR_ARENA_SHAPE(v->arenaitem);
 245                     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 246                         nr_arena_shape_set_path(s, shape->curve, (flags & SP_OBJECT_USER_MODIFIED_FLAG_B));
 247                     }
 248                     s->setPaintBox(paintbox);
 249                 }
 250         }
 251
 252         if (sp_shape_has_markers (shape)) {
 253
 254             /* Dimension marker views */
 255             for (SPItemView *v = item->display; v != NULL; v = v->next) {
 256
 257                 if (!v->arenaitem->key) {
 258                     /* Get enough keys for all, start, mid and end marker types,
 259                     ** and set this view's arenaitem key to the first of these keys.
 260                     */
 261                     NR_ARENA_ITEM_SET_KEY (
 262                         v->arenaitem,
 263                         sp_item_display_key_new (SP_MARKER_LOC_QTY)
 264                         );
 265                 }
 266
 267                 for (int i = 0 ; i < SP_MARKER_LOC_QTY ; i++) {
 268                     if (shape->marker[i]) {
 269                         sp_marker_show_dimension ((SPMarker *) shape->marker[i],
 270                                                   NR_ARENA_ITEM_GET_KEY (v->arenaitem) + i - SP_MARKER_LOC,
 271                                                   sp_shape_number_of_markers (shape, i));
 272                     }
 273                 }
 274             }
 275
 276             /* Update marker views */
 277             for (SPItemView *v = item->display; v != NULL; v = v->next) {
 278                 sp_shape_update_marker_view (shape, v->arenaitem);
 279             }
 280         }
 281 }
 282
 283
 284 /**
 285 * Works out whether a marker of a given type is required at a particular
 286 * point on a shape.
 287 *
 288 * \param shape Shape of interest.
 289 * \param m Marker type (e.g. SP_MARKER_LOC_START)
 290 * \param bp Path segment.
 291 * \return 1 if a marker is required here, otherwise 0.
 292 */
 293 bool
 294 sp_shape_marker_required(SPShape const *shape, int const m, NArtBpath *bp)
 295 {
 296     if (shape->marker[m] == NULL) {
 297         return false;
 298     }
 299
 300     if (bp == SP_CURVE_BPATH(shape->curve))
 301         return m == SP_MARKER_LOC_START;
 302     else if (bp[1].code == NR_END)
 303         return m == SP_MARKER_LOC_END;
 304     else
 305         return m == SP_MARKER_LOC_MID;
 306 }
 307
 308 static bool
 309 is_moveto(NRPathcode const c)
 310 {
 311     return c == NR_MOVETO || c == NR_MOVETO_OPEN;
 312 }
 313
 314 /**
 315  * Helper function that advances a subpath's bpath to the first subpath
 316  * by checking for moveto segments.
 317  *
 318  * \pre The bpath[] containing bp begins with a moveto.
 319  */
 320 static NArtBpath const *
 321 first_seg_in_subpath(NArtBpath const *bp)
 322 {
 323     while (!is_moveto(bp->code)) {
 324         --bp;
 325     }
 326     return bp;
 327 }
 328
 329 /**
 330  * Advances the bpath to the last segment in the subpath.
 331  */
 332 static NArtBpath const *
 333 last_seg_in_subpath(NArtBpath const *bp)
 334 {
 335     for(;;) {
 336         ++bp;
 337         switch (bp->code) {
 338             case NR_MOVETO:
 339             case NR_MOVETO_OPEN:
 340             case NR_END:
 341                 --bp;
 342                 return bp;
 343
 344             default: continue;
 345         }
 346     }
 347 }
 348
 349
 350 /* A subpath begins with a moveto and ends immediately before the next moveto or NR_END.
 351  * (`moveto' here means either NR_MOVETO or NR_MOVETO_OPEN.)  I'm assuming that non-empty
 352  * paths always begin with a moveto.
 353  *
 354  * The control points of the subpath are the control points of the path elements of the subpath.
 355  *
 356  * As usual, the control points of a moveto or NR_LINETO are {c(3)}, and
 357  * the control points of a NR_CURVETO are {c(1), c(2), c(3)}.
 358  * (It follows from the definition that NR_END isn't part of a subpath.)
 359  *
 360  * The initial control point is bpath[bi0].c(3).
 361  *
 362  * Reference: http://www.w3.org/TR/SVG11/painting.html#MarkerElement, the `orient' attribute.
 363  * Reference for behaviour of zero-length segments:
 364  * http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
 365  */
 366
 367 static double const no_tangent = 128.0;  /* arbitrarily-chosen value outside the range of atan2, i.e. outside of [-pi, pi]. */
 368
 369 /**
 370  * Helper function to calculate the outgoing tangent of a path
 371  * ( atan2(other - p0) )
 372  * \pre The bpath[] containing bp0 begins with a moveto.
 373  */
 374 static double
 375 outgoing_tangent(NArtBpath const *bp0)
 376 {
 377     /* See notes in comment block above. */
 378
 379     g_assert(bp0->code != NR_END);
 380     NR::Point const &p0 = bp0->c(3);
 381     NR::Point other;
 382     for (NArtBpath const *bp = bp0;;) {
 383         ++bp;
 384         switch (bp->code) {
 385             case NR_LINETO:
 386                 other = bp->c(3);
 387                 if (other != p0) {
 388                     goto found;
 389                 }
 390                 break;
 391
 392             case NR_CURVETO:
 393                 for (unsigned ci = 1; ci <= 3; ++ci) {
 394                     other = bp->c(ci);
 395                     if (other != p0) {
 396                         goto found;
 397                     }
 398                 }
 399                 break;
 400
 401             case NR_MOVETO_OPEN:
 402             case NR_END:
 403             case NR_MOVETO:
 404                 bp = first_seg_in_subpath(bp0);
 405                 if (bp == bp0) {
 406                     /* Gone right around the subpath without finding any different point since the
 407                      * initial moveto. */
 408                     return no_tangent;
 409                 }
 410                 if (bp->code != NR_MOVETO) {
 411                     /* Open subpath. */
 412                     return no_tangent;
 413                 }
 414                 other = bp->c(3);
 415                 if (other != p0) {
 416                     goto found;
 417                 }
 418                 break;
 419         }
 420
 421         if (bp == bp0) {
 422             /* Back where we started, so zero-length subpath. */
 423             return no_tangent;
 424
 425             /* Note: this test must come after we've looked at element bp, in case bp0 is a curve:
 426              * we must look at c(1) and c(2).  (E.g. single-curve subpath.)
 427              */
 428         }
 429     }
 430
 431 found:
 432     return atan2( other - p0 );
 433 }
 434
 435 /**
 436  * Helper function to calculate the incoming tangent of a path
 437  * ( atan2(p0 - other) )
 438  *
 439  * \pre The bpath[] containing bp0 begins with a moveto.
 440  */
 441 static double
 442 incoming_tangent(NArtBpath const *bp0)
 443 {
 444     /* See notes in comment block before outgoing_tangent. */
 445
 446     g_assert(bp0->code != NR_END);
 447     NR::Point const &p0 = bp0->c(3);
 448     NR::Point other;
 449     for (NArtBpath const *bp = bp0;;) {
 450         switch (bp->code) {
 451             case NR_LINETO:
 452                 other = bp->c(3);
 453                 if (other != p0) {
 454                     goto found;
 455                 }
 456                 --bp;
 457                 break;
 458
 459             case NR_CURVETO:
 460                 for (unsigned ci = 3; ci != 0; --ci) {
 461                     other = bp->c(ci);
 462                     if (other != p0) {
 463                         goto found;
 464                     }
 465                 }
 466                 --bp;
 467                 break;
 468
 469             case NR_MOVETO:
 470             case NR_MOVETO_OPEN:
 471                 other = bp->c(3);
 472                 if (other != p0) {
 473                     goto found;
 474                 }
 475                 if (bp->code != NR_MOVETO) {
 476                     /* Open subpath. */
 477                     return no_tangent;
 478                 }
 479                 bp = last_seg_in_subpath(bp0);
 480                 break;
 481
 482             default: /* includes NR_END */
 483                 g_error("Found invalid path code %u in middle of path.", bp->code);
 484                 return no_tangent;
 485         }
 486
 487         if (bp == bp0) {
 488             /* Back where we started from: zero-length subpath. */
 489             return no_tangent;
 490         }
 491     }
 492
 493 found:
 494     return atan2( p0 - other );
 495 }
 496
 497
 498 /**
 499  * Calculate the transform required to get a marker's path object in the
 500  * right place for particular path segment on a shape.  You should
 501  * call sp_shape_marker_required first to see if a marker is required
 502  * at this point.
 503  *
 504  * \see sp_shape_marker_required.
 505  *
 506  * \param shape Shape which the marker is for.
 507  * \param m Marker type (e.g. SP_MARKER_LOC_START)
 508  * \param bp Path segment which the arrow is for.
 509  * \return Transform matrix.
 510  */
 511 NR::Matrix
 512 sp_shape_marker_get_transform(SPShape const *shape, NArtBpath const *bp)
 513 {
 514     g_return_val_if_fail(( is_moveto(SP_CURVE_BPATH(shape->curve)[0].code)
 515                            && ( 0 < shape->curve->end )
 516                            && ( SP_CURVE_BPATH(shape->curve)[shape->curve->end].code == NR_END ) ),
 517                          NR::Matrix(NR::translate(bp->c(3))));
 518     double const angle1 = incoming_tangent(bp);
 519     double const angle2 = outgoing_tangent(bp);
 520
 521     /* angle1 and angle2 are now each either unset (i.e. still 100 from their initialization) or in
 522        [-pi, pi] from atan2. */
 523     g_assert((-3.15 < angle1 && angle1 < 3.15) || (angle1 == no_tangent));
 524     g_assert((-3.15 < angle2 && angle2 < 3.15) || (angle2 == no_tangent));
 525
 526     double ret_angle;
 527     if (angle1 == no_tangent) {
 528         /* First vertex of an open subpath. */
 529         ret_angle = ( angle2 == no_tangent
 530                       ? 0.
 531                       : angle2 );
 532     } else if (angle2 == no_tangent) {
 533         /* Last vertex of an open subpath. */
 534         ret_angle = angle1;
 535     } else {
 536         ret_angle = .5 * (angle1 + angle2);
 537
 538         if ( fabs( angle2 - angle1 ) > M_PI ) {
 539             /* ret_angle is in the middle of the larger of the two sectors between angle1 and
 540              * angle2, so flip it by 180degrees to force it to the middle of the smaller sector.
 541              *
 542              * (Imagine a circle with rays drawn at angle1 and angle2 from the centre of the
 543              * circle.  Those two rays divide the circle into two sectors.)
 544              */
 545             ret_angle += M_PI;
 546         }
 547     }
 548
 549     return NR::Matrix(NR::rotate(ret_angle)) * NR::translate(bp->c(3));
 550 }
 551
 552 /**
 553  * Updates the instances (views) of a given marker in a shape.
 554  * Marker views have to be scaled already.  The transformation
 555  * is retrieved and then shown by calling sp_marker_show_instance.
 556  */
 557 static void
 558 sp_shape_update_marker_view (SPShape *shape, NRArenaItem *ai)
 559 {
 560         SPStyle *style = ((SPObject *) shape)->style;
 561
 562         marker_status("sp_shape_update_marker_view:  Updating views of markers");
 563
 564         for (int i = SP_MARKER_LOC_START; i < SP_MARKER_LOC_QTY; i++) {
 565             if (shape->marker[i] == NULL) {
 566                 continue;
 567             }
 568
 569             int n = 0;
 570
 571             for (NArtBpath *bp = SP_CURVE_BPATH(shape->curve); bp->code != NR_END; bp++) {
 572                 if (sp_shape_marker_required (shape, i, bp)) {
 573                     NR::Matrix const m(sp_shape_marker_get_transform(shape, bp));
 574                     sp_marker_show_instance ((SPMarker* ) shape->marker[i], ai,
 575                                              NR_ARENA_ITEM_GET_KEY(ai) + i, n, m,
 576                                              style->stroke_width.computed);
 577                     n++;
 578                 }
 579             }
 580         }
 581 }
 582
 583 /**
 584  * Sets modified flag for all sub-item views.
 585  */
 586 static void
 587 sp_shape_modified (SPObject *object, unsigned int flags)
 588 {
 589         SPShape *shape = SP_SHAPE (object);
 590
 591         if (((SPObjectClass *) (parent_class))->modified) {
 592           (* ((SPObjectClass *) (parent_class))->modified) (object, flags);
 593         }
 594
 595         if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
 596                 for (SPItemView *v = SP_ITEM (shape)->display; v != NULL; v = v->next) {
 597                         nr_arena_shape_set_style (NR_ARENA_SHAPE (v->arenaitem), object->style);
 598                 }
 599         }
 600 }
 601
 602 /**
 603  * Calculates the bounding box for item, storing it into bbox.
 604  * This also includes the bounding boxes of any markers included in the shape.
 605  */
 606 static void sp_shape_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const flags)
 607 {
 608     SPShape const *shape = SP_SHAPE (item);
 609
 610     if (shape->curve) {
 611
 612         NRRect  cbbox;
 613         NRBPath bp;
 614
 615         bp.path = SP_CURVE_BPATH (shape->curve);
 616
 617         cbbox.x0 = cbbox.y0 = NR_HUGE;
 618         cbbox.x1 = cbbox.y1 = -NR_HUGE;
 619
 620         nr_path_matrix_bbox_union(&bp, transform, &cbbox);
 621
 622         SPStyle* style=SP_OBJECT_STYLE (item);
 623         if (style->stroke.type != SP_PAINT_TYPE_NONE) {
 624             double const scale = expansion(transform);
 625             if ( fabs(style->stroke_width.computed * scale) > 0.01 ) { // sinon c'est 0=oon veut pas de bord
 626                 double const width = MAX(0.125, style->stroke_width.computed * scale);
 627                 if ( fabs(cbbox.x1-cbbox.x0) > -0.00001 && fabs(cbbox.y1-cbbox.y0) > -0.00001 ) {
 628                     cbbox.x0-=0.5*width;
 629                     cbbox.x1+=0.5*width;
 630                     cbbox.y0-=0.5*width;
 631                     cbbox.y1+=0.5*width;
 632                 }
 633             }
 634         }
 635
 636         // Union with bboxes of the markers, if any
 637         if (sp_shape_has_markers (shape)) {
 638             for (NArtBpath* bp = SP_CURVE_BPATH(shape->curve); bp->code != NR_END; bp++) {
 639                 for (int m = SP_MARKER_LOC_START; m < SP_MARKER_LOC_QTY; m++) {
 640                     if (sp_shape_marker_required (shape, m, bp)) {
 641
 642                         SPMarker* marker = SP_MARKER (shape->marker[m]);
 643                         SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (shape->marker[m]));
 644
 645                         NR::Matrix tr(sp_shape_marker_get_transform(shape, bp));
 646
 647                         if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
 648                             tr = NR::scale(style->stroke_width.computed) * tr;
 649                         }
 650
 651                         // total marker transform
 652                         tr = marker_item->transform * marker->c2p * tr * transform;
 653
 654                         // get bbox of the marker with that transform
 655                         NRRect marker_bbox;
 656                         sp_item_invoke_bbox (marker_item, &marker_bbox, tr, true);
 657                         // union it with the shape bbox
 658                         nr_rect_d_union (&cbbox, &cbbox, &marker_bbox);
 659                     }
 660                 }
 661             }
 662         }
 663
 664         // copy our bbox to the variable we're given
 665         *bbox = cbbox;
 666     }
 667 }
 668
 669 /**
 670  * Prepares shape for printing.  Handles printing of comments for printing
 671  * debugging, sizes the item to fit into the document width/height,
 672  * applies print fill/stroke, sets transforms for markers, and adds
 673  * comment labels.
 674  */
 675 void
 676 sp_shape_print (SPItem *item, SPPrintContext *ctx)
 677 {
 678         NRRect pbox, dbox, bbox;
 679
 680         SPShape *shape = SP_SHAPE(item);
 681
 682         if (!shape->curve) return;
 683
 684         gint add_comments = prefs_get_int_attribute_limited ("printing.debug", "add-label-comments", 0, 0, 1);
 685         if (add_comments) {
 686             gchar * comment = g_strdup_printf("begin '%s'",
 687                                               SP_OBJECT(item)->defaultLabel());
 688             sp_print_comment(ctx, comment);
 689             g_free(comment);
 690         }
 691
 692         /* fixme: Think (Lauris) */
 693         sp_item_invoke_bbox(item, &pbox, NR::identity(), TRUE);
 694         dbox.x0 = 0.0;
 695         dbox.y0 = 0.0;
 696         dbox.x1 = sp_document_width (SP_OBJECT_DOCUMENT (item));
 697         dbox.y1 = sp_document_height (SP_OBJECT_DOCUMENT (item));
 698         sp_item_bbox_desktop (item, &bbox);
 699         NR::Matrix const i2d = sp_item_i2d_affine(item);
 700
 701         SPStyle* style = SP_OBJECT_STYLE (item);
 702
 703         if (style->fill.type != SP_PAINT_TYPE_NONE) {
 704                 NRBPath bp;
 705                 bp.path = SP_CURVE_BPATH(shape->curve);
 706                 sp_print_fill (ctx, &bp, i2d, style, &pbox, &dbox, &bbox);
 707         }
 708
 709         if (style->stroke.type != SP_PAINT_TYPE_NONE) {
 710                 NRBPath bp;
 711                 bp.path = SP_CURVE_BPATH(shape->curve);
 712                 sp_print_stroke (ctx, &bp, i2d, style, &pbox, &dbox, &bbox);
 713         }
 714
 715         for (NArtBpath* bp = SP_CURVE_BPATH(shape->curve); bp->code != NR_END; bp++) {
 716             for (int m = SP_MARKER_LOC_START; m < SP_MARKER_LOC_QTY; m++) {
 717                 if (sp_shape_marker_required (shape, m, bp)) {
 718
 719                     SPMarker* marker = SP_MARKER (shape->marker[m]);
 720                     SPItem* marker_item = sp_item_first_item_child (SP_OBJECT (shape->marker[m]));
 721
 722                     NR::Matrix tr(sp_shape_marker_get_transform(shape, bp));
 723
 724                     if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
 725                         tr = NR::scale(style->stroke_width.computed) * tr;
 726                     }
 727
 728                     tr = marker_item->transform * marker->c2p * tr;
 729
 730                     NR::Matrix old_tr = marker_item->transform;
 731                     marker_item->transform = tr;
 732                     sp_item_invoke_print (marker_item, ctx);
 733                     marker_item->transform = old_tr;
 734                 }
 735             }
 736         }
 737
 738         if (add_comments) {
 739             gchar * comment = g_strdup_printf("end '%s'",
 740                                               SP_OBJECT(item)->defaultLabel());
 741             sp_print_comment(ctx, comment);
 742             g_free(comment);
 743         }
 744 }
 745
 746 /**
 747  * Sets style, path, and paintbox.  Updates marker views, including dimensions.
 748  */
 749 static NRArenaItem *
 750 sp_shape_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags)
 751 {
 752         SPObject *object = SP_OBJECT(item);
 753         SPShape *shape = SP_SHAPE(item);
 754
 755         NRArenaItem *arenaitem = NRArenaShape::create(arena);
 756         NRArenaShape * const s = NR_ARENA_SHAPE(arenaitem);
 757         nr_arena_shape_set_style(s, object->style);
 758         nr_arena_shape_set_path(s, shape->curve, false);
 759         NR::Rect const paintbox = item->invokeBbox(NR::identity());
 760         s->setPaintBox(paintbox);
 761
 762         if (sp_shape_has_markers (shape)) {
 763
 764             /* Dimension the marker views */
 765             if (!arenaitem->key) {
 766                 NR_ARENA_ITEM_SET_KEY (arenaitem, sp_item_display_key_new (SP_MARKER_LOC_QTY));
 767             }
 768
 769             for (int i = 0; i < SP_MARKER_LOC_QTY; i++) {
 770                 if (shape->marker[i]) {
 771                     sp_marker_show_dimension ((SPMarker *) shape->marker[i],
 772                                               NR_ARENA_ITEM_GET_KEY (arenaitem) + i - SP_MARKER_LOC,
 773                                               sp_shape_number_of_markers (shape, i));
 774                 }
 775             }
 776
 777
 778             /* Update marker views */
 779             sp_shape_update_marker_view (shape, arenaitem);
 780         }
 781
 782         return arenaitem;
 783 }
 784
 785 /**
 786  * Hides/removes marker views from the shape.
 787  */
 788 static void
 789 sp_shape_hide (SPItem *item, unsigned int key)
 790 {
 791         SPShape *shape;
 792         SPItemView *v;
 793         int i;
 794
 795         shape = (SPShape *) item;
 796
 797         for (i=0; i<SP_MARKER_LOC_QTY; i++) {
 798           if (shape->marker[i]) {
 799             for (v = item->display; v != NULL; v = v->next) {
 800                 if (key == v->key) {
 801               sp_marker_hide ((SPMarker *) shape->marker[i],
 802                                     NR_ARENA_ITEM_GET_KEY (v->arenaitem) + i);
 803                 }
 804             }
 805           }
 806         }
 807
 808         if (((SPItemClass *) parent_class)->hide) {
 809           ((SPItemClass *) parent_class)->hide (item, key);
 810         }
 811 }
 812
 813 /**
 814 * \param shape Shape.
 815 * \return TRUE if the shape has any markers, or FALSE if not.
 816 */
 817 int
 818 sp_shape_has_markers (SPShape const *shape)
 819 {
 820     /* Note, we're ignoring 'marker' settings, which technically should apply for
 821        all three settings.  This should be fixed later such that if 'marker' is
 822        specified, then all three should appear. */
 823
 824     return (
 825         shape->curve &&
 826         (shape->marker[SP_MARKER_LOC_START] ||
 827          shape->marker[SP_MARKER_LOC_MID] ||
 828          shape->marker[SP_MARKER_LOC_END])
 829         );
 830 }
 831
 832
 833 /**
 834 * \param shape Shape.
 835 * \param type Marker type (e.g. SP_MARKER_LOC_START)
 836 * \return Number of markers that the shape has of this type.
 837 */
 838 int
 839 sp_shape_number_of_markers (SPShape *shape, int type)
 840 {
 841     int n = 0;
 842     for (NArtBpath* bp = SP_CURVE_BPATH(shape->curve); bp->code != NR_END; bp++) {
 843         if (sp_shape_marker_required (shape, type, bp)) {
 844             n++;
 845         }
 846     }
 847
 848     return n;
 849 }
 850
 851 /**
 852  * Checks if the given marker is used in the shape, and if so, it
 853  * releases it by calling sp_marker_hide.  Also detaches signals
 854  * and unrefs the marker from the shape.
 855  */
 856 static void
 857 sp_shape_marker_release (SPObject *marker, SPShape *shape)
 858 {
 859         SPItem *item;
 860         int i;
 861
 862         item = (SPItem *) shape;
 863
 864         marker_status("sp_shape_marker_release:  Releasing markers");
 865         for (i = SP_MARKER_LOC_START; i < SP_MARKER_LOC_QTY; i++) {
 866           if (marker == shape->marker[i]) {
 867             SPItemView *v;
 868             /* Hide marker */
 869             for (v = item->display; v != NULL; v = v->next) {
 870               sp_marker_hide ((SPMarker *) (shape->marker[i]), NR_ARENA_ITEM_GET_KEY (v->arenaitem) + i);
 871               /* fixme: Do we need explicit remove here? (Lauris) */
 872               /* nr_arena_item_set_mask (v->arenaitem, NULL); */
 873             }
 874             /* Detach marker */
 875             sp_signal_disconnect_by_data (shape->marker[i], item);
 876             shape->marker[i] = sp_object_hunref (shape->marker[i], item);
 877           }
 878         }
 879 }
 880
 881 /**
 882  * No-op.  Exists for handling 'modified' messages
 883  */
 884 static void
 885 sp_shape_marker_modified (SPObject *marker, guint flags, SPItem *item)
 886 {
 887         /* I think mask does update automagically */
 888         /* g_warning ("Item %s mask %s modified", SP_OBJECT_ID (item), SP_OBJECT_ID (mask)); */
 889 }
 890
 891 /**
 892  * Adds a new marker to shape object at the location indicated by key.  value
 893  * must be a valid URI reference resolvable from the shape object (i.e., present
 894  * in the document <defs>).  If the shape object already has a marker
 895  * registered at the given position, it is removed first.  Then the
 896  * new marker is hrefed and its signals connected.
 897  */
 898 void
 899 sp_shape_set_marker (SPObject *object, unsigned int key, const gchar *value)
 900 {
 901     SPItem *item = (SPItem *) object;
 902     SPShape *shape = (SPShape *) object;
 903
 904     if (key < SP_MARKER_LOC_START || key > SP_MARKER_LOC_END) {
 905         return;
 906     }
 907
 908     SPObject *mrk = sp_uri_reference_resolve (SP_OBJECT_DOCUMENT (object), value);
 909     if (mrk != shape->marker[key]) {
 910         if (shape->marker[key]) {
 911             SPItemView *v;
 912
 913             /* Detach marker */
 914             shape->release_connect[key].disconnect();
 915             shape->modified_connect[key].disconnect();
 916
 917             /* Hide marker */
 918             for (v = item->display; v != NULL; v = v->next) {
 919                 sp_marker_hide ((SPMarker *) (shape->marker[key]),
 920                                 NR_ARENA_ITEM_GET_KEY (v->arenaitem) + key);
 921                 /* fixme: Do we need explicit remove here? (Lauris) */
 922                 /* nr_arena_item_set_mask (v->arenaitem, NULL); */
 923             }
 924
 925             /* Unref marker */
 926             shape->marker[key] = sp_object_hunref (shape->marker[key], object);
 927         }
 928         if (SP_IS_MARKER (mrk)) {
 929             shape->marker[key] = sp_object_href (mrk, object);
 930             shape->release_connect[key] = mrk->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_shape_marker_release), shape));
 931             shape->modified_connect[key] = mrk->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_shape_marker_modified), shape));
 932         }
 933     }
 934 }
 935
 936
 937
 938 /* Shape section */
 939
 940 /**
 941  * Calls any registered handlers for the set_shape action
 942  */
 943 void
 944 sp_shape_set_shape (SPShape *shape)
 945 {
 946         g_return_if_fail (shape != NULL);
 947         g_return_if_fail (SP_IS_SHAPE (shape));
 948
 949         if (SP_SHAPE_CLASS (G_OBJECT_GET_CLASS (shape))->set_shape) {
 950           SP_SHAPE_CLASS (G_OBJECT_GET_CLASS (shape))->set_shape (shape);
 951         }
 952 }
 953
 954 /**
 955  * Adds a curve to the shape.  If owner is specified, a reference
 956  * will be made, otherwise the curve will be copied into the shape.
 957  * Any existing curve in the shape will be unreferenced first.
 958  * This routine also triggers a request to update the display.
 959  */
 960 void
 961 sp_shape_set_curve (SPShape *shape, SPCurve *curve, unsigned int owner)
 962 {
 963         if (shape->curve) {
 964                 shape->curve = sp_curve_unref (shape->curve);
 965         }
 966         if (curve) {
 967                 if (owner) {
 968                         shape->curve = sp_curve_ref (curve);
 969                 } else {
 970                         shape->curve = sp_curve_copy (curve);
 971                 }
 972         }
 973         SP_OBJECT(shape)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 974 }
 975
 976 /**
 977  * Return duplicate of curve (if any exists) or NULL if there is no curve
 978  */
 979 SPCurve *
 980 sp_shape_get_curve (SPShape *shape)
 981 {
 982         if (shape->curve) {
 983                 return sp_curve_copy (shape->curve);
 984         }
 985         return NULL;
 986 }
 987
 988 /* NOT FOR GENERAL PUBLIC UNTIL SORTED OUT (Lauris) */
 989 void
 990 sp_shape_set_curve_insync (SPShape *shape, SPCurve *curve, unsigned int owner)
 991 {
 992         if (shape->curve) {
 993                 shape->curve = sp_curve_unref (shape->curve);
 994         }
 995         if (curve) {
 996                 if (owner) {
 997                         shape->curve = sp_curve_ref (curve);
 998                 } else {
 999                         shape->curve = sp_curve_copy (curve);
1000                 }
1001         }
1002 }
1003
1004 /**
1005  * Sets the snappoint p to the end point of the path segment
1006  */
1007 static void sp_shape_snappoints(SPItem const *item, SnapPointsIter p)
1008 {
1009     g_assert(item != NULL);
1010     g_assert(SP_IS_SHAPE(item));
1011
1012     SPShape const *shape = SP_SHAPE(item);
1013     if (shape->curve == NULL) {
1014         return;
1015     }
1016
1017     NR::Matrix const i2d (sp_item_i2d_affine (item));
1018
1019     /* Use the end points of each segment of the path */
1020     NArtBpath const *bp = SP_CURVE_BPATH(shape->curve);
1021     while (bp->code != NR_END) {
1022         *p = bp->c(3) * i2d;
1023         bp++;
1024     }
1025 }
1026
1027
1028 /*
1029   Local Variables:
1030   mode:c++
1031   c-file-style:"stroustrup"
1032   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1033   indent-tabs-mode:nil
1034   fill-column:99
1035   End:
1036 */
1037 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :