src/sp-marker.cpp

   1 #define __SP_MARKER_C__
   2
   3 /*
   4  * SVG <marker> implementation
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *
   9  * Copyright (C) 1999-2003 Lauris Kaplinski
  10  *
  11  * Released under GNU GPL, read the file 'COPYING' for more information
  12  */
  13
  14 #include "config.h"
  15
  16
  17 #include "libnr/nr-matrix-fns.h"
  18 #include "libnr/nr-matrix-ops.h"
  19 #include "libnr/nr-scale-matrix-ops.h"
  20 #include "libnr/nr-rotate-fns.h"
  21 #include "svg/svg.h"
  22 #include "display/nr-arena-group.h"
  23 #include "xml/repr.h"
  24 #include "attributes.h"
  25 #include "sp-marker.h"
  26
  27 struct SPMarkerView {
  28         SPMarkerView *next;
  29         unsigned int key;
  30         unsigned int size;
  31         NRArenaItem *items[1];
  32 };
  33
  34 static void sp_marker_class_init (SPMarkerClass *klass);
  35 static void sp_marker_init (SPMarker *marker);
  36
  37 static void sp_marker_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
  38 static void sp_marker_release (SPObject *object);
  39 static void sp_marker_set (SPObject *object, unsigned int key, const gchar *value);
  40 static void sp_marker_update (SPObject *object, SPCtx *ctx, guint flags);
  41 static Inkscape::XML::Node *sp_marker_write (SPObject *object, Inkscape::XML::Node *repr, guint flags);
  42
  43 static NRArenaItem *sp_marker_private_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags);
  44 static void sp_marker_private_hide (SPItem *item, unsigned int key);
  45 static void sp_marker_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const flags);
  46 static void sp_marker_print (SPItem *item, SPPrintContext *ctx);
  47
  48 static void sp_marker_view_remove (SPMarker *marker, SPMarkerView *view, unsigned int destroyitems);
  49
  50 static SPGroupClass *parent_class;
  51
  52 GType
  53 sp_marker_get_type (void)
  54 {
  55         static GType type = 0;
  56         if (!type) {
  57                 GTypeInfo info = {
  58                         sizeof (SPMarkerClass),
  59                         NULL, NULL,
  60                         (GClassInitFunc) sp_marker_class_init,
  61                         NULL, NULL,
  62                         sizeof (SPMarker),
  63                         16,
  64                         (GInstanceInitFunc) sp_marker_init,
  65                         NULL,   /* value_table */
  66                 };
  67                 type = g_type_register_static (SP_TYPE_GROUP, "SPMarker", &info, (GTypeFlags)0);
  68         }
  69         return type;
  70 }
  71
  72 static void
  73 sp_marker_class_init (SPMarkerClass *klass)
  74 {
  75         GObjectClass *object_class;
  76         SPObjectClass *sp_object_class;
  77         SPItemClass *sp_item_class;
  78
  79         object_class = G_OBJECT_CLASS (klass);
  80         sp_object_class = (SPObjectClass *) klass;
  81         sp_item_class = (SPItemClass *) klass;
  82
  83         parent_class = (SPGroupClass *)g_type_class_ref (SP_TYPE_GROUP);
  84
  85         sp_object_class->build = sp_marker_build;
  86         sp_object_class->release = sp_marker_release;
  87         sp_object_class->set = sp_marker_set;
  88         sp_object_class->update = sp_marker_update;
  89         sp_object_class->write = sp_marker_write;
  90
  91         sp_item_class->show = sp_marker_private_show;
  92         sp_item_class->hide = sp_marker_private_hide;
  93         sp_item_class->bbox = sp_marker_bbox;
  94         sp_item_class->print = sp_marker_print;
  95 }
  96
  97 static void
  98 sp_marker_init (SPMarker *marker)
  99 {
 100         marker->viewBox_set = FALSE;
 101
 102         nr_matrix_set_identity (&marker->c2p);
 103 }
 104
 105 static void
 106 sp_marker_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 107 {
 108         SPGroup *group;
 109         SPMarker *marker;
 110
 111         group = (SPGroup *) object;
 112         marker = (SPMarker *) object;
 113
 114         sp_object_read_attr (object, "markerUnits");
 115         sp_object_read_attr (object, "refX");
 116         sp_object_read_attr (object, "refY");
 117         sp_object_read_attr (object, "markerWidth");
 118         sp_object_read_attr (object, "markerHeight");
 119         sp_object_read_attr (object, "orient");
 120         sp_object_read_attr (object, "viewBox");
 121         sp_object_read_attr (object, "preserveAspectRatio");
 122
 123         if (((SPObjectClass *) parent_class)->build)
 124                 ((SPObjectClass *) parent_class)->build (object, document, repr);
 125 }
 126
 127 static void
 128 sp_marker_release (SPObject *object)
 129 {
 130         SPMarker *marker;
 131
 132         marker = (SPMarker *) object;
 133
 134         while (marker->views) {
 135                 /* Destroy all NRArenaitems etc. */
 136                 /* Parent class ::hide method */
 137                 ((SPItemClass *) parent_class)->hide ((SPItem *) marker, marker->views->key);
 138                 sp_marker_view_remove (marker, marker->views, TRUE);
 139         }
 140
 141         if (((SPObjectClass *) parent_class)->release)
 142                 ((SPObjectClass *) parent_class)->release (object);
 143 }
 144
 145 static void
 146 sp_marker_set (SPObject *object, unsigned int key, const gchar *value)
 147 {
 148         SPItem *item;
 149         SPMarker *marker;
 150
 151         item = SP_ITEM (object);
 152         marker = SP_MARKER (object);
 153
 154         switch (key) {
 155         case SP_ATTR_MARKERUNITS:
 156                 marker->markerUnits_set = FALSE;
 157                 marker->markerUnits = SP_MARKER_UNITS_STROKEWIDTH;
 158                 if (value) {
 159                         if (!strcmp (value, "strokeWidth")) {
 160                                 marker->markerUnits_set = TRUE;
 161                         } else if (!strcmp (value, "userSpaceOnUse")) {
 162                                 marker->markerUnits = SP_MARKER_UNITS_USERSPACEONUSE;
 163                                 marker->markerUnits_set = TRUE;
 164                         }
 165                 }
 166                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
 167                 break;
 168         case SP_ATTR_REFX:
 169                 marker->refX.readOrUnset(value);
 170                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 171                 break;
 172         case SP_ATTR_REFY:
 173                 marker->refY.readOrUnset(value);
 174                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 175                 break;
 176         case SP_ATTR_MARKERWIDTH:
 177                 marker->markerWidth.readOrUnset(value, SVGLength::NONE, 3.0, 3.0);
 178                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 179                 break;
 180         case SP_ATTR_MARKERHEIGHT:
 181                 marker->markerHeight.readOrUnset(value, SVGLength::NONE, 3.0, 3.0);
 182                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 183                 break;
 184         case SP_ATTR_ORIENT:
 185                 marker->orient_set = FALSE;
 186                 marker->orient_auto = FALSE;
 187                 marker->orient = 0.0;
 188                 if (value) {
 189                         if (!strcmp (value, "auto")) {
 190                                 marker->orient_auto = TRUE;
 191                                 marker->orient_set = TRUE;
 192                         } else if (sp_svg_number_read_f (value, &marker->orient)) {
 193                                 marker->orient_set = TRUE;
 194                         }
 195                 }
 196                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 197                 break;
 198         case SP_ATTR_VIEWBOX:
 199                 marker->viewBox_set = FALSE;
 200                 if (value) {
 201                         double x, y, width, height;
 202                         char *eptr;
 203                         /* fixme: We have to take original item affine into account */
 204                         /* fixme: Think (Lauris) */
 205                         eptr = (gchar *) value;
 206                         x = g_ascii_strtod (eptr, &eptr);
 207                         while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
 208                         y = g_ascii_strtod (eptr, &eptr);
 209                         while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
 210                         width = g_ascii_strtod (eptr, &eptr);
 211                         while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
 212                         height = g_ascii_strtod (eptr, &eptr);
 213                         while (*eptr && ((*eptr == ',') || (*eptr == ' '))) eptr++;
 214                         if ((width > 0) && (height > 0)) {
 215                                 /* Set viewbox */
 216                                 marker->viewBox.x0 = x;
 217                                 marker->viewBox.y0 = y;
 218                                 marker->viewBox.x1 = x + width;
 219                                 marker->viewBox.y1 = y + height;
 220                                 marker->viewBox_set = TRUE;
 221                         }
 222                 }
 223                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
 224                 break;
 225         case SP_ATTR_PRESERVEASPECTRATIO:
 226                 /* Do setup before, so we can use break to escape */
 227                 marker->aspect_set = FALSE;
 228                 marker->aspect_align = SP_ASPECT_NONE;
 229                 marker->aspect_clip = SP_ASPECT_MEET;
 230                 object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
 231                 if (value) {
 232                         int len;
 233                         gchar c[256];
 234                         const gchar *p, *e;
 235                         unsigned int align, clip;
 236                         p = value;
 237                         while (*p && *p == 32) p += 1;
 238                         if (!*p) break;
 239                         e = p;
 240                         while (*e && *e != 32) e += 1;
 241                         len = e - p;
 242                         if (len > 8) break;
 243                         memcpy (c, value, len);
 244                         c[len] = 0;
 245                         /* Now the actual part */
 246                         if (!strcmp (c, "none")) {
 247                                 align = SP_ASPECT_NONE;
 248                         } else if (!strcmp (c, "xMinYMin")) {
 249                                 align = SP_ASPECT_XMIN_YMIN;
 250                         } else if (!strcmp (c, "xMidYMin")) {
 251                                 align = SP_ASPECT_XMID_YMIN;
 252                         } else if (!strcmp (c, "xMaxYMin")) {
 253                                 align = SP_ASPECT_XMAX_YMIN;
 254                         } else if (!strcmp (c, "xMinYMid")) {
 255                                 align = SP_ASPECT_XMIN_YMID;
 256                         } else if (!strcmp (c, "xMidYMid")) {
 257                                 align = SP_ASPECT_XMID_YMID;
 258                         } else if (!strcmp (c, "xMaxYMin")) {
 259                                 align = SP_ASPECT_XMAX_YMID;
 260                         } else if (!strcmp (c, "xMinYMax")) {
 261                                 align = SP_ASPECT_XMIN_YMAX;
 262                         } else if (!strcmp (c, "xMidYMax")) {
 263                                 align = SP_ASPECT_XMID_YMAX;
 264                         } else if (!strcmp (c, "xMaxYMax")) {
 265                                 align = SP_ASPECT_XMAX_YMAX;
 266                         } else {
 267                                 break;
 268                         }
 269                         clip = SP_ASPECT_MEET;
 270                         while (*e && *e == 32) e += 1;
 271                         if (e) {
 272                                 if (!strcmp (e, "meet")) {
 273                                         clip = SP_ASPECT_MEET;
 274                                 } else if (!strcmp (e, "slice")) {
 275                                         clip = SP_ASPECT_SLICE;
 276                                 } else {
 277                                         break;
 278                                 }
 279                         }
 280                         marker->aspect_set = TRUE;
 281                         marker->aspect_align = align;
 282                         marker->aspect_clip = clip;
 283                 }
 284                 break;
 285         default:
 286                 if (((SPObjectClass *) parent_class)->set)
 287                         ((SPObjectClass *) parent_class)->set (object, key, value);
 288                 break;
 289         }
 290 }
 291
 292 /*
 293  * Updating <marker> - we are not renderable anyways, so
 294  * we as well cascade with identity transforms
 295  */
 296
 297 static void
 298 sp_marker_update (SPObject *object, SPCtx *ctx, guint flags)
 299 {
 300         SPItem *item;
 301         SPMarker *marker;
 302         SPItemCtx rctx;
 303         NRRect *vb;
 304         double x, y, width, height;
 305         NRMatrix q;
 306         SPMarkerView *v;
 307
 308         item = SP_ITEM (object);
 309         marker = SP_MARKER (object);
 310
 311         /* fixme: We have to set up clip here too */
 312
 313         /* Copy parent context */
 314         rctx.ctx = *ctx;
 315         /* Initialize tranformations */
 316         rctx.i2doc = NR::identity();
 317         rctx.i2vp = NR::identity();
 318         /* Set up viewport */
 319         rctx.vp.x0 = 0.0;
 320         rctx.vp.y0 = 0.0;
 321         rctx.vp.x1 = marker->markerWidth.computed;
 322         rctx.vp.y1 = marker->markerHeight.computed;
 323
 324         /* Start with identity transform */
 325         nr_matrix_set_identity (&marker->c2p);
 326
 327         /* Viewbox is always present, either implicitly or explicitly */
 328         if (marker->viewBox_set) {
 329                 vb = &marker->viewBox;
 330         } else {
 331                 vb = &rctx.vp;
 332         }
 333         /* Now set up viewbox transformation */
 334         /* Determine actual viewbox in viewport coordinates */
 335         if (marker->aspect_align == SP_ASPECT_NONE) {
 336                 x = 0.0;
 337                 y = 0.0;
 338                 width = rctx.vp.x1 - rctx.vp.x0;
 339                 height = rctx.vp.y1 - rctx.vp.y0;
 340         } else {
 341                 double scalex, scaley, scale;
 342                 /* Things are getting interesting */
 343                 scalex = (rctx.vp.x1 - rctx.vp.x0) / (vb->x1 - vb->x0);
 344                 scaley = (rctx.vp.y1 - rctx.vp.y0) / (vb->y1 - vb->y0);
 345                 scale = (marker->aspect_clip == SP_ASPECT_MEET) ? MIN (scalex, scaley) : MAX (scalex, scaley);
 346                 width = (vb->x1 - vb->x0) * scale;
 347                 height = (vb->y1 - vb->y0) * scale;
 348                 /* Now place viewbox to requested position */
 349                 switch (marker->aspect_align) {
 350                 case SP_ASPECT_XMIN_YMIN:
 351                         x = 0.0;
 352                         y = 0.0;
 353                         break;
 354                 case SP_ASPECT_XMID_YMIN:
 355                         x = 0.5 * ((rctx.vp.x1 - rctx.vp.x0) - width);
 356                         y = 0.0;
 357                         break;
 358                 case SP_ASPECT_XMAX_YMIN:
 359                         x = 1.0 * ((rctx.vp.x1 - rctx.vp.x0) - width);
 360                         y = 0.0;
 361                         break;
 362                 case SP_ASPECT_XMIN_YMID:
 363                         x = 0.0;
 364                         y = 0.5 * ((rctx.vp.y1 - rctx.vp.y0) - height);
 365                         break;
 366                 case SP_ASPECT_XMID_YMID:
 367                         x = 0.5 * ((rctx.vp.x1 - rctx.vp.x0) - width);
 368                         y = 0.5 * ((rctx.vp.y1 - rctx.vp.y0) - height);
 369                         break;
 370                 case SP_ASPECT_XMAX_YMID:
 371                         x = 1.0 * ((rctx.vp.x1 - rctx.vp.x0) - width);
 372                         y = 0.5 * ((rctx.vp.y1 - rctx.vp.y0) - height);
 373                         break;
 374                 case SP_ASPECT_XMIN_YMAX:
 375                         x = 0.0;
 376                         y = 1.0 * ((rctx.vp.y1 - rctx.vp.y0) - height);
 377                         break;
 378                 case SP_ASPECT_XMID_YMAX:
 379                         x = 0.5 * ((rctx.vp.x1 - rctx.vp.x0) - width);
 380                         y = 1.0 * ((rctx.vp.y1 - rctx.vp.y0) - height);
 381                         break;
 382                 case SP_ASPECT_XMAX_YMAX:
 383                         x = 1.0 * ((rctx.vp.x1 - rctx.vp.x0) - width);
 384                         y = 1.0 * ((rctx.vp.y1 - rctx.vp.y0) - height);
 385                         break;
 386                 default:
 387                         x = 0.0;
 388                         y = 0.0;
 389                         break;
 390                 }
 391         }
 392         /* Compose additional transformation from scale and position */
 393         q.c[0] = width / (vb->x1 - vb->x0);
 394         q.c[1] = 0.0;
 395         q.c[2] = 0.0;
 396         q.c[3] = height / (vb->y1 - vb->y0);
 397         q.c[4] = -vb->x0 * q.c[0] + x;
 398         q.c[5] = -vb->y0 * q.c[3] + y;
 399         /* Append viewbox transformation */
 400         nr_matrix_multiply (&marker->c2p, &q, &marker->c2p);
 401
 402
 403         /* Append reference translation */
 404         /* fixme: lala (Lauris) */
 405         nr_matrix_set_translate (&q, -marker->refX.computed, -marker->refY.computed);
 406         nr_matrix_multiply (&marker->c2p, &q, &marker->c2p);
 407
 408         rctx.i2doc = marker->c2p * rctx.i2doc;
 409
 410         /* If viewBox is set reinitialize child viewport */
 411         /* Otherwise it already correct */
 412         if (marker->viewBox_set) {
 413                 rctx.vp.x0 = marker->viewBox.x0;
 414                 rctx.vp.y0 = marker->viewBox.y0;
 415                 rctx.vp.x1 = marker->viewBox.x1;
 416                 rctx.vp.y1 = marker->viewBox.y1;
 417                 rctx.i2vp = NR::identity();
 418         }
 419
 420         /* And invoke parent method */
 421         if (((SPObjectClass *) (parent_class))->update)
 422                 ((SPObjectClass *) (parent_class))->update (object, (SPCtx *) &rctx, flags);
 423
 424         /* As last step set additional transform of arena group */
 425         for (v = marker->views; v != NULL; v = v->next) {
 426                 for (unsigned i = 0 ; i < v->size ; i++) {
 427                         if (v->items[i]) {
 428                                 nr_arena_group_set_child_transform(NR_ARENA_GROUP(v->items[i]), &marker->c2p);
 429                         }
 430                 }
 431         }
 432 }
 433
 434 static Inkscape::XML::Node *
 435 sp_marker_write (SPObject *object, Inkscape::XML::Node *repr, guint flags)
 436 {
 437         SPMarker *marker;
 438
 439         marker = SP_MARKER (object);
 440
 441         if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
 442                 repr = sp_repr_new ("svg:marker");
 443         }
 444
 445         if (marker->markerUnits_set) {
 446                 if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
 447                         repr->setAttribute("markerUnits", "strokeWidth");
 448                 } else {
 449                         repr->setAttribute("markerUnits", "userSpaceOnUse");
 450                 }
 451         } else {
 452                 repr->setAttribute("markerUnits", NULL);
 453         }
 454         if (marker->refX._set) {
 455                 sp_repr_set_svg_double(repr, "refX", marker->refX.computed);
 456         } else {
 457                 repr->setAttribute("refX", NULL);
 458         }
 459         if (marker->refY._set) {
 460                 sp_repr_set_svg_double (repr, "refY", marker->refY.computed);
 461         } else {
 462                 repr->setAttribute("refY", NULL);
 463         }
 464         if (marker->markerWidth._set) {
 465                 sp_repr_set_svg_double (repr, "markerWidth", marker->markerWidth.computed);
 466         } else {
 467                 repr->setAttribute("markerWidth", NULL);
 468         }
 469         if (marker->markerHeight._set) {
 470                 sp_repr_set_svg_double (repr, "markerHeight", marker->markerHeight.computed);
 471         } else {
 472                 repr->setAttribute("markerHeight", NULL);
 473         }
 474         if (marker->orient_set) {
 475                 if (marker->orient_auto) {
 476                         repr->setAttribute("orient", "auto");
 477                 } else {
 478                         sp_repr_set_css_double(repr, "orient", marker->orient);
 479                 }
 480         } else {
 481                 repr->setAttribute("orient", NULL);
 482         }
 483         /* fixme: */
 484         repr->setAttribute("viewBox", object->repr->attribute("viewBox"));
 485         repr->setAttribute("preserveAspectRatio", object->repr->attribute("preserveAspectRatio"));
 486
 487         if (((SPObjectClass *) (parent_class))->write)
 488                 ((SPObjectClass *) (parent_class))->write (object, repr, flags);
 489
 490         return repr;
 491 }
 492
 493 static NRArenaItem *
 494 sp_marker_private_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags)
 495 {
 496         /* Break propagation */
 497         return NULL;
 498 }
 499
 500 static void
 501 sp_marker_private_hide (SPItem *item, unsigned int key)
 502 {
 503         /* Break propagation */
 504 }
 505
 506 static void
 507 sp_marker_bbox(SPItem const *, NRRect *, NR::Matrix const &, unsigned const)
 508 {
 509         /* Break propagation */
 510 }
 511
 512 static void
 513 sp_marker_print (SPItem *item, SPPrintContext *ctx)
 514 {
 515         /* Break propagation */
 516 }
 517
 518 /* fixme: Remove link if zero-sized (Lauris) */
 519
 520 /**
 521 * First of all, removes any SPMarkerViews that a marker has with a specific key.
 522 * Set up the NRArenaItem array's size in the specified SPMarker's SPMarkerView.
 523 * \param marker Marker to create views in.
 524 * \param key Key to give each SPMarkerView.
 525 * \param size Number of NRArenaItems to put in the SPMarkerView.
 526 */
 527 void
 528 sp_marker_show_dimension (SPMarker *marker, unsigned int key, unsigned int size)
 529 {
 530         SPMarkerView *view;
 531         unsigned int i;
 532
 533         for (view = marker->views; view != NULL; view = view->next) {
 534                 if (view->key == key) break;
 535         }
 536         if (view && (view->size != size)) {
 537                 /* Free old view and allocate new */
 538                 /* Parent class ::hide method */
 539                 ((SPItemClass *) parent_class)->hide ((SPItem *) marker, key);
 540                 sp_marker_view_remove (marker, view, TRUE);
 541                 view = NULL;
 542         }
 543         if (!view) {
 544                 view = (SPMarkerView *)malloc (sizeof (SPMarkerView) + (size) * sizeof (NRArenaItem *));
 545                 for (i = 0; i < size; i++) view->items[i] = NULL;
 546                 view->next = marker->views;
 547                 marker->views = view;
 548                 view->key = key;
 549                 view->size = size;
 550         }
 551 }
 552
 553 NRArenaItem *
 554 sp_marker_show_instance (SPMarker *marker, NRArenaItem *parent,
 555                          unsigned int key, unsigned int pos,
 556                          NR::Matrix const &base, float linewidth)
 557 {
 558         for (SPMarkerView *v = marker->views; v != NULL; v = v->next) {
 559                 if (v->key == key) {
 560                         if (pos >= v->size) {
 561                           return NULL;
 562                         }
 563                         if (!v->items[pos]) {
 564                                 /* Parent class ::show method */
 565                                 v->items[pos] = ((SPItemClass *) parent_class)->show ((SPItem *) marker,
 566                                                                                       parent->arena, key,
 567                                                                                       SP_ITEM_REFERENCE_FLAGS);
 568                                 if (v->items[pos]) {
 569                                         /* fixme: Position (Lauris) */
 570                                         nr_arena_item_add_child (parent, v->items[pos], NULL);
 571                                         /* nr_arena_item_unref (v->items[pos]); */
 572                                         nr_arena_group_set_child_transform((NRArenaGroup *) v->items[pos], &marker->c2p);
 573                                 }
 574                         }
 575                         if (v->items[pos]) {
 576                                 NR::Matrix m;
 577                                 if (marker->orient_auto) {
 578                                         m = base;
 579                                 } else {
 580                                         /* fixme: Orient units (Lauris) */
 581                                         m = NR::Matrix(rotate_degrees(marker->orient));
 582                                         m *= get_translation(base);
 583                                 }
 584                                 if (marker->markerUnits == SP_MARKER_UNITS_STROKEWIDTH) {
 585                                         m = NR::scale(linewidth) * m;
 586                                 }
 587
 588                                 nr_arena_item_set_transform(v->items[pos], m);
 589                         }
 590                         return v->items[pos];
 591                 }
 592         }
 593
 594         return NULL;
 595 }
 596
 597 /* This replaces SPItem implementation because we have own views */
 598
 599 /**
 600 * \param key SPMarkerView key to hide.
 601 */
 602 void
 603 sp_marker_hide (SPMarker *marker, unsigned int key)
 604 {
 605         SPMarkerView *v;
 606
 607         v = marker->views;
 608         while (v != NULL) {
 609                 SPMarkerView *next;
 610                 next = v->next;
 611                 if (v->key == key) {
 612                         /* Parent class ::hide method */
 613                         ((SPItemClass *) parent_class)->hide ((SPItem *) marker, key);
 614                         sp_marker_view_remove (marker, v, TRUE);
 615                         return;
 616                 }
 617                 v = next;
 618         }
 619 }
 620
 621 static void
 622 sp_marker_view_remove (SPMarker *marker, SPMarkerView *view, unsigned int destroyitems)
 623 {
 624         unsigned int i;
 625         if (view == marker->views) {
 626                 marker->views = view->next;
 627         } else {
 628                 SPMarkerView *v;
 629                 for (v = marker->views; v->next != view; v = v->next) if (!v->next) return;
 630                 v->next = view->next;
 631         }
 632         if (destroyitems) {
 633                 for (i = 0; i < view->size; i++) {
 634                         /* We have to walk through the whole array because there may be hidden items */
 635                         if (view->items[i]) nr_arena_item_unref (view->items[i]);
 636                 }
 637         }
 638         g_free (view);
 639 }