src/display/nr-arena-item.cpp

   1 #define __NR_ARENA_ITEM_C__
   2
   3 /*
   4  * RGBA display list system for inkscape
   5  *
   6  * Author:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *
   9  * Copyright (C) 2001-2002 Lauris Kaplinski
  10  * Copyright (C) 2001 Ximian, Inc.
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 #define noNR_ARENA_ITEM_VERBOSE
  16 #define noNR_ARENA_ITEM_DEBUG_CASCADE
  17
  18 #include <cstring>
  19 #include <string>
  20
  21 #include <libnr/nr-blit.h>
  22 #include <libnr/nr-pixops.h>
  23 #include <libnr/nr-matrix-ops.h>
  24 #include <libnr/nr-matrix-fns.h>
  25 #include "nr-arena.h"
  26 #include "nr-arena-item.h"
  27 #include "gc-core.h"
  28 #include "helper/geom.h"
  29
  30 #include "nr-filter.h"
  31 #include "libnr/nr-rect.h"
  32 #include "nr-arena-group.h"
  33 #include "preferences.h"
  34
  35 namespace GC = Inkscape::GC;
  36
  37 static void nr_arena_item_class_init (NRArenaItemClass *klass);
  38 static void nr_arena_item_init (NRArenaItem *item);
  39 static void nr_arena_item_private_finalize (NRObject *object);
  40
  41 static NRObjectClass *parent_class;
  42
  43 NRType
  44 nr_arena_item_get_type (void)
  45 {
  46     static NRType type = 0;
  47     if (!type) {
  48         type = nr_object_register_type (NR_TYPE_OBJECT,
  49                                         "NRArenaItem",
  50                                         sizeof (NRArenaItemClass),
  51                                         sizeof (NRArenaItem),
  52                                         (void (*)(NRObjectClass *))
  53                                         nr_arena_item_class_init,
  54                                         (void (*)(NRObject *))
  55                                         nr_arena_item_init);
  56     }
  57     return type;
  58 }
  59
  60 static void
  61 nr_arena_item_class_init (NRArenaItemClass *klass)
  62 {
  63     NRObjectClass *object_class;
  64
  65     object_class = (NRObjectClass *) klass;
  66
  67     parent_class = ((NRObjectClass *) klass)->parent;
  68
  69     object_class->finalize = nr_arena_item_private_finalize;
  70     object_class->cpp_ctor = NRObject::invoke_ctor < NRArenaItem >;
  71 }
  72
  73 static void
  74 nr_arena_item_init (NRArenaItem *item)
  75 {
  76     item->arena = NULL;
  77     item->parent = NULL;
  78     item->next = item->prev = NULL;
  79
  80     item->key = 0;
  81
  82     item->state = 0;
  83     item->sensitive = TRUE;
  84     item->visible = TRUE;
  85
  86     memset (&item->bbox, 0, sizeof (item->bbox));
  87     item->transform = NULL;
  88     item->opacity = 255;
  89     item->render_opacity = FALSE;
  90
  91     item->transform = NULL;
  92     item->clip = NULL;
  93     item->mask = NULL;
  94     item->px = NULL;
  95     item->data = NULL;
  96     item->filter = NULL;
  97     item->background_pb = NULL;
  98     item->background_new = false;
  99 }
 100
 101 static void
 102 nr_arena_item_private_finalize (NRObject *object)
 103 {
 104     NRArenaItem *item = static_cast < NRArenaItem * >(object);
 105
 106     item->px = NULL;
 107     item->transform = NULL;
 108
 109     ((NRObjectClass *) (parent_class))->finalize (object);
 110 }
 111
 112 NRArenaItem *
 113 nr_arena_item_children (NRArenaItem *item)
 114 {
 115     nr_return_val_if_fail (item != NULL, NULL);
 116     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 117
 118     if (NR_ARENA_ITEM_VIRTUAL (item, children))
 119         return NR_ARENA_ITEM_VIRTUAL (item, children) (item);
 120
 121     return NULL;
 122 }
 123
 124 NRArenaItem *
 125 nr_arena_item_last_child (NRArenaItem *item)
 126 {
 127     nr_return_val_if_fail (item != NULL, NULL);
 128     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 129
 130     if (NR_ARENA_ITEM_VIRTUAL (item, last_child)) {
 131         return NR_ARENA_ITEM_VIRTUAL (item, last_child) (item);
 132     } else {
 133         NRArenaItem *ref = nr_arena_item_children (item);
 134         if (ref)
 135             while (ref->next)
 136                 ref = ref->next;
 137         return ref;
 138     }
 139 }
 140
 141 void
 142 nr_arena_item_add_child (NRArenaItem *item, NRArenaItem *child,
 143                          NRArenaItem *ref)
 144 {
 145     nr_return_if_fail (item != NULL);
 146     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 147     nr_return_if_fail (child != NULL);
 148     nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 149     nr_return_if_fail (child->parent == NULL);
 150     nr_return_if_fail (child->prev == NULL);
 151     nr_return_if_fail (child->next == NULL);
 152     nr_return_if_fail (child->arena == item->arena);
 153     nr_return_if_fail (child != ref);
 154     nr_return_if_fail (!ref || NR_IS_ARENA_ITEM (ref));
 155     nr_return_if_fail (!ref || (ref->parent == item));
 156
 157     if (NR_ARENA_ITEM_VIRTUAL (item, add_child))
 158         NR_ARENA_ITEM_VIRTUAL (item, add_child) (item, child, ref);
 159 }
 160
 161 void
 162 nr_arena_item_remove_child (NRArenaItem *item, NRArenaItem *child)
 163 {
 164     nr_return_if_fail (item != NULL);
 165     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 166     nr_return_if_fail (child != NULL);
 167     nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 168     nr_return_if_fail (child->parent == item);
 169
 170     if (NR_ARENA_ITEM_VIRTUAL (item, remove_child))
 171         NR_ARENA_ITEM_VIRTUAL (item, remove_child) (item, child);
 172 }
 173
 174 void
 175 nr_arena_item_set_child_position (NRArenaItem *item, NRArenaItem *child,
 176                                   NRArenaItem *ref)
 177 {
 178     nr_return_if_fail (item != NULL);
 179     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 180     nr_return_if_fail (child != NULL);
 181     nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 182     nr_return_if_fail (child->parent == item);
 183     nr_return_if_fail (!ref || NR_IS_ARENA_ITEM (ref));
 184     nr_return_if_fail (!ref || (ref->parent == item));
 185
 186     if (NR_ARENA_ITEM_VIRTUAL (item, set_child_position))
 187         NR_ARENA_ITEM_VIRTUAL (item, set_child_position) (item, child, ref);
 188 }
 189
 190 NRArenaItem *
 191 nr_arena_item_ref (NRArenaItem *item)
 192 {
 193     nr_object_ref ((NRObject *) item);
 194
 195     return item;
 196 }
 197
 198 NRArenaItem *
 199 nr_arena_item_unref (NRArenaItem *item)
 200 {
 201     nr_object_unref ((NRObject *) item);
 202
 203     return NULL;
 204 }
 205
 206 unsigned int
 207 nr_arena_item_invoke_update (NRArenaItem *item, NRRectL *area, NRGC *gc,
 208                              unsigned int state, unsigned int reset)
 209 {
 210     NRGC childgc (gc);
 211     bool filter = (item->arena->rendermode == Inkscape::RENDERMODE_NORMAL);
 212
 213     nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 214     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item),
 215                            NR_ARENA_ITEM_STATE_INVALID);
 216     nr_return_val_if_fail (!(state & NR_ARENA_ITEM_STATE_INVALID),
 217                            NR_ARENA_ITEM_STATE_INVALID);
 218
 219 #ifdef NR_ARENA_ITEM_DEBUG_CASCADE
 220     printf ("Update %s:%p %x %x %x\n",
 221             nr_type_name_from_instance ((GTypeInstance *) item), item, state,
 222             item->state, reset);
 223 #endif
 224
 225     /* return if in error */
 226     if (item->state & NR_ARENA_ITEM_STATE_INVALID)
 227         return item->state;
 228     /* Set reset flags according to propagation status */
 229     if (item->propagate) {
 230         reset |= ~item->state;
 231         item->propagate = FALSE;
 232     }
 233     /* Reset our state */
 234     item->state &= ~reset;
 235     /* Return if NOP */
 236     if (!(~item->state & state))
 237         return item->state;
 238     /* Test whether to return immediately */
 239     if (area && (item->state & NR_ARENA_ITEM_STATE_BBOX)) {
 240         if (!nr_rect_l_test_intersect_ptr(area, &item->bbox))
 241             return item->state;
 242     }
 243
 244     /* Reset image cache, if not to be kept */
 245     if (!(item->state & NR_ARENA_ITEM_STATE_IMAGE) && (item->px)) {
 246         item->px = NULL;
 247     }
 248
 249     /* Set up local gc */
 250     childgc = *gc;
 251     if (item->transform) {
 252         childgc.transform = (*item->transform) * childgc.transform;
 253     }
 254     /* Remember the transformation matrix */
 255     item->ctm = childgc.transform;
 256
 257     /* Invoke the real method */
 258     item->state =
 259         NR_ARENA_ITEM_VIRTUAL (item, update) (item, area, &childgc, state,
 260                                               reset);
 261     if (item->state & NR_ARENA_ITEM_STATE_INVALID)
 262         return item->state;
 263     /* Enlarge the bounding box to contain filter effects */
 264     if (item->filter && filter) {
 265         item->filter->bbox_enlarge (item->bbox);
 266     }
 267     // fixme: to fix the display glitches, in outline mode bbox must be a combination of
 268     // full item bbox and its clip and mask (after we have the API to get these)
 269
 270     /* Clipping */
 271     if (item->clip) {
 272         // FIXME: since here we only need bbox, consider passing
 273         // ((state & !(NR_ARENA_ITEM_STATE_RENDER)) | NR_ARENA_ITEM_STATE_BBOX)
 274         // instead of state, so it does not have to create rendering structures in nr_arena_shape_update
 275         unsigned int newstate = nr_arena_item_invoke_update (item->clip, area, &childgc, state, reset);
 276         if (newstate & NR_ARENA_ITEM_STATE_INVALID) {
 277             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 278             return item->state;
 279         }
 280         nr_rect_l_intersect (&item->bbox, &item->bbox, &item->clip->bbox);
 281     }
 282     /* Masking */
 283     if (item->mask) {
 284         unsigned int newstate = nr_arena_item_invoke_update (item->mask, area, &childgc, state, reset);
 285         if (newstate & NR_ARENA_ITEM_STATE_INVALID) {
 286             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 287             return item->state;
 288         }
 289         nr_rect_l_intersect (&item->bbox, &item->bbox, &item->mask->bbox);
 290     }
 291
 292     return item->state;
 293 }
 294
 295 /**
 296  *    Render item to pixblock.
 297  *
 298  *    \return Has NR_ARENA_ITEM_STATE_RENDER set on success.
 299  */
 300
 301 unsigned int
 302 nr_arena_item_invoke_render (cairo_t *ct, NRArenaItem *item, NRRectL const *area,
 303                              NRPixBlock *pb, unsigned int flags)
 304 {
 305    bool outline = (item->arena->rendermode == Inkscape::RENDERMODE_OUTLINE);
 306     bool filter = (item->arena->rendermode == Inkscape::RENDERMODE_NORMAL);
 307
 308     nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 309     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item),
 310                            NR_ARENA_ITEM_STATE_INVALID);
 311     nr_return_val_if_fail (item->state & NR_ARENA_ITEM_STATE_BBOX,
 312                            item->state);
 313
 314 #ifdef NR_ARENA_ITEM_VERBOSE
 315     printf ("Invoke render %p: %d %d - %d %d\n", item, area->x0, area->y0,
 316             area->x1, area->y1);
 317 #endif
 318
 319     /* If we are outside bbox just return successfully */
 320     if (!item->visible)
 321         return item->state | NR_ARENA_ITEM_STATE_RENDER;
 322
 323     NRRectL carea;
 324     nr_rect_l_intersect (&carea, area, &item->bbox);
 325     if (nr_rect_l_test_empty(carea))
 326         return item->state | NR_ARENA_ITEM_STATE_RENDER;
 327     if (item->filter && filter) {
 328         item->filter->area_enlarge (carea, item->ctm);
 329         nr_rect_l_intersect (&carea, &carea, &item->bbox);
 330     }
 331
 332     if (outline) {
 333     // No caching in outline mode for now; investigate if it really gives any advantage with cairo.
 334     // Also no attempts to clip anything; just render everything: item, clip, mask
 335             // First, render the object itself
 336             unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, pb, flags);
 337             if (state & NR_ARENA_ITEM_STATE_INVALID) {
 338                 /* Clean up and return error */
 339                 item->state |= NR_ARENA_ITEM_STATE_INVALID;
 340                 return item->state;
 341             }
 342
 343             // render clip and mask, if any
 344             guint32 saved_rgba = item->arena->outlinecolor; // save current outline color
 345             // render clippath as an object, using a different color
 346             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 347             if (item->clip) {
 348                 item->arena->outlinecolor = prefs->getInt("/options/wireframecolors/clips", 0x00ff00ff); // green clips
 349                 NR_ARENA_ITEM_VIRTUAL (item->clip, render) (ct, item->clip, &carea, pb, flags);
 350             }
 351             // render mask as an object, using a different color
 352             if (item->mask) {
 353                 item->arena->outlinecolor = prefs->getInt("/options/wireframecolors/masks", 0x0000ffff); // blue masks
 354                 NR_ARENA_ITEM_VIRTUAL (item->mask, render) (ct, item->mask, &carea, pb, flags);
 355             }
 356             item->arena->outlinecolor = saved_rgba; // restore outline color
 357
 358             return item->state | NR_ARENA_ITEM_STATE_RENDER;
 359     }
 360
 361     NRPixBlock cpb;
 362     if (item->px) {
 363         /* Has cache pixblock, render this and return */
 364         nr_pixblock_setup_extern (&cpb, NR_PIXBLOCK_MODE_R8G8B8A8P,
 365                                   /* fixme: This probably cannot overflow, because we render only if visible */
 366                                   /* fixme: and pixel cache is there only for small items */
 367                                   /* fixme: But this still needs extra check (Lauris) */
 368                                   item->bbox.x0, item->bbox.y0,
 369                                   item->bbox.x1, item->bbox.y1,
 370                                   item->px,
 371                                   4 * (item->bbox.x1 - item->bbox.x0), FALSE,
 372                                   FALSE);
 373         nr_blit_pixblock_pixblock (pb, &cpb);
 374         nr_pixblock_release (&cpb);
 375         pb->empty = FALSE;
 376         return item->state | NR_ARENA_ITEM_STATE_RENDER;
 377     }
 378
 379     NRPixBlock *dpb = pb;
 380
 381     /* Setup cache if we can */
 382     if ((!(flags & NR_ARENA_ITEM_RENDER_NO_CACHE)) &&
 383         (carea.x0 <= item->bbox.x0) && (carea.y0 <= item->bbox.y0) &&
 384         (carea.x1 >= item->bbox.x1) && (carea.y1 >= item->bbox.y1) &&
 385         (((item->bbox.x1 - item->bbox.x0) * (item->bbox.y1 -
 386                                              item->bbox.y0)) <= 4096)) {
 387         // Item bbox is fully in renderable area and size is acceptable
 388         carea.x0 = item->bbox.x0;
 389         carea.y0 = item->bbox.y0;
 390         carea.x1 = item->bbox.x1;
 391         carea.y1 = item->bbox.y1;
 392         item->px =
 393             new (GC::ATOMIC) unsigned char[4 * (carea.x1 - carea.x0) *
 394                                            (carea.y1 - carea.y0)];
 395         nr_pixblock_setup_extern (&cpb, NR_PIXBLOCK_MODE_R8G8B8A8P, carea.x0,
 396                                   carea.y0, carea.x1, carea.y1, item->px,
 397                                   4 * (carea.x1 - carea.x0), TRUE, TRUE);
 398         cpb.visible_area = pb->visible_area;
 399         dpb = &cpb;
 400         // Set nocache flag for downstream rendering
 401         flags |= NR_ARENA_ITEM_RENDER_NO_CACHE;
 402     }
 403
 404     /* Determine, whether we need temporary buffer */
 405     if (item->clip || item->mask
 406         || ((item->opacity != 255) && !item->render_opacity)
 407         || (item->filter && filter) || item->background_new
 408         || (item->parent && item->parent->background_pb)) {
 409
 410         /* Setup and render item buffer */
 411         NRPixBlock ipb;
 412         nr_pixblock_setup_fast (&ipb, NR_PIXBLOCK_MODE_R8G8B8A8P,
 413                                 carea.x0, carea.y0, carea.x1, carea.y1,
 414                                 TRUE);
 415
 416         //  if memory allocation failed, abort render
 417         if (ipb.size != NR_PIXBLOCK_SIZE_TINY && ipb.data.px == NULL) {
 418             nr_pixblock_release (&ipb);
 419             return (item->state);
 420         }
 421
 422         /* If background access is used, save the pixblock address.
 423          * This address is set to NULL at the end of this block */
 424         if (item->background_new ||
 425             (item->parent && item->parent->background_pb)) {
 426             item->background_pb = &ipb;
 427         }
 428
 429         ipb.visible_area = pb->visible_area;
 430         if (item->filter && filter) {
 431               item->filter->area_enlarge (ipb.visible_area, item->ctm);
 432         }
 433
 434         unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, &ipb, flags);
 435         if (state & NR_ARENA_ITEM_STATE_INVALID) {
 436             /* Clean up and return error */
 437             nr_pixblock_release (&ipb);
 438             if (dpb != pb)
 439                 nr_pixblock_release (dpb);
 440             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 441             return item->state;
 442         }
 443         ipb.empty = FALSE;
 444
 445         /* Run filtering, if a filter is set for this object */
 446         if (item->filter && filter) {
 447             item->filter->render (item, &ipb);
 448         }
 449
 450         if (item->clip || item->mask) {
 451             /* Setup mask pixblock */
 452             NRPixBlock mpb;
 453             nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0,
 454                                     carea.y0, carea.x1, carea.y1, TRUE);
 455
 456             if (mpb.data.px != NULL) { // if memory allocation was successful
 457
 458                 mpb.visible_area = pb->visible_area;
 459                 /* Do clip if needed */
 460                 if (item->clip) {
 461                     state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
 462                     if (state & NR_ARENA_ITEM_STATE_INVALID) {
 463                         /* Clean up and return error */
 464                         nr_pixblock_release (&mpb);
 465                         nr_pixblock_release (&ipb);
 466                         if (dpb != pb)
 467                             nr_pixblock_release (dpb);
 468                         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 469                         return item->state;
 470                     }
 471                     mpb.empty = FALSE;
 472                 }
 473                 /* Do mask if needed */
 474                 if (item->mask) {
 475                     NRPixBlock tpb;
 476                     /* Set up yet another temporary pixblock */
 477                     nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N,
 478                                             carea.x0, carea.y0, carea.x1,
 479                                             carea.y1, TRUE);
 480
 481                     if (tpb.data.px != NULL) { // if memory allocation was successful
 482
 483                         tpb.visible_area = pb->visible_area;
 484                         unsigned int state = NR_ARENA_ITEM_VIRTUAL (item->mask, render) (ct, item->mask, &carea, &tpb, flags);
 485                         if (state & NR_ARENA_ITEM_STATE_INVALID) {
 486                             /* Clean up and return error */
 487                             nr_pixblock_release (&tpb);
 488                             nr_pixblock_release (&mpb);
 489                             nr_pixblock_release (&ipb);
 490                             if (dpb != pb)
 491                                 nr_pixblock_release (dpb);
 492                             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 493                             return item->state;
 494                         }
 495                         /* Composite with clip */
 496                         if (item->clip) {
 497                             int x, y;
 498                             for (y = carea.y0; y < carea.y1; y++) {
 499                                 unsigned char *s, *d;
 500                                 s = NR_PIXBLOCK_PX (&tpb) + (y -
 501                                                              carea.y0) * tpb.rs;
 502                                 d = NR_PIXBLOCK_PX (&mpb) + (y -
 503                                                              carea.y0) * mpb.rs;
 504                                 for (x = carea.x0; x < carea.x1; x++) {
 505                                     unsigned int m;
 506                                     m = NR_PREMUL_112 (s[0] + s[1] + s[2], s[3]);
 507                                     d[0] =
 508                                         FAST_DIV_ROUND < 3 * 255 * 255 >
 509                                         (NR_PREMUL_123 (d[0], m));
 510                                     s += 4;
 511                                     d += 1;
 512                                 }
 513                             }
 514                         } else {
 515                             int x, y;
 516                             for (y = carea.y0; y < carea.y1; y++) {
 517                                 unsigned char *s, *d;
 518                                 s = NR_PIXBLOCK_PX (&tpb) + (y -
 519                                                              carea.y0) * tpb.rs;
 520                                 d = NR_PIXBLOCK_PX (&mpb) + (y -
 521                                                              carea.y0) * mpb.rs;
 522                                 for (x = carea.x0; x < carea.x1; x++) {
 523                                     unsigned int m;
 524                                     m = NR_PREMUL_112 (s[0] + s[1] + s[2], s[3]);
 525                                     d[0] = FAST_DIV_ROUND < 3 * 255 > (m);
 526                                     s += 4;
 527                                     d += 1;
 528                                 }
 529                             }
 530                             mpb.empty = FALSE;
 531                         }
 532                     }
 533                     nr_pixblock_release (&tpb);
 534                 }
 535                 /* Multiply with opacity if needed */
 536                 if ((item->opacity != 255) && !item->render_opacity
 537                     ) {
 538                     int x, y;
 539                     unsigned int a;
 540                     a = item->opacity;
 541                     for (y = carea.y0; y < carea.y1; y++) {
 542                         unsigned char *d;
 543                         d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 544                         for (x = carea.x0; x < carea.x1; x++) {
 545                             d[0] = NR_PREMUL_111 (d[0], a);
 546                             d += 1;
 547                         }
 548                     }
 549                 }
 550                 /* Compose rendering pixblock int destination */
 551                 nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
 552             }
 553             nr_pixblock_release (&mpb);
 554         } else {
 555             if (item->render_opacity) { // opacity was already rendered in, just copy to dpb here
 556                 nr_blit_pixblock_pixblock(dpb, &ipb);
 557             } else { // copy while multiplying by opacity
 558                 nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
 559             }
 560         }
 561         nr_pixblock_release (&ipb);
 562         dpb->empty = FALSE;
 563         /* This pointer wouldn't be valid outside this block, so clear it */
 564         item->background_pb = NULL;
 565     } else {
 566         /* Just render */
 567         unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, dpb, flags);
 568         if (state & NR_ARENA_ITEM_STATE_INVALID) {
 569             /* Clean up and return error */
 570             if (dpb != pb)
 571                 nr_pixblock_release (dpb);
 572             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 573             return item->state;
 574         }
 575         dpb->empty = FALSE;
 576     }
 577
 578     if (dpb != pb) {
 579         /* Have to blit from cache */
 580         nr_blit_pixblock_pixblock (pb, dpb);
 581         nr_pixblock_release (dpb);
 582         pb->empty = FALSE;
 583         item->state |= NR_ARENA_ITEM_STATE_IMAGE;
 584     }
 585
 586     return item->state | NR_ARENA_ITEM_STATE_RENDER;
 587 }
 588
 589 unsigned int
 590 nr_arena_item_invoke_clip (NRArenaItem *item, NRRectL *area, NRPixBlock *pb)
 591 {
 592     nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 593     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item),
 594                            NR_ARENA_ITEM_STATE_INVALID);
 595     /* we originally short-circuited if the object state included
 596      * NR_ARENA_ITEM_STATE_CLIP (and showed a warning on the console);
 597      * anyone know why we stopped doing so?
 598      */
 599     nr_return_val_if_fail ((pb->area.x1 - pb->area.x0) >=
 600                            (area->x1 - area->x0),
 601                            NR_ARENA_ITEM_STATE_INVALID);
 602     nr_return_val_if_fail ((pb->area.y1 - pb->area.y0) >=
 603                            (area->y1 - area->y0),
 604                            NR_ARENA_ITEM_STATE_INVALID);
 605
 606 #ifdef NR_ARENA_ITEM_VERBOSE
 607     printf ("Invoke clip by %p: %d %d - %d %d, item bbox %d %d - %d %d\n",
 608             item, area->x0, area->y0, area->x1, area->y1, (&item->bbox)->x0,
 609             (&item->bbox)->y0, (&item->bbox)->x1, (&item->bbox)->y1);
 610 #endif
 611
 612     if (item->visible && nr_rect_l_test_intersect_ptr(area, &item->bbox)) {
 613         /* Need render that item */
 614         if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->clip) {
 615             return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->
 616                 clip (item, area, pb);
 617         }
 618     }
 619
 620     return item->state;
 621 }
 622
 623 NRArenaItem *
 624 nr_arena_item_invoke_pick (NRArenaItem *item, Geom::Point p, double delta,
 625                            unsigned int sticky)
 626 {
 627     nr_return_val_if_fail (item != NULL, NULL);
 628     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 629
 630     // Sometimes there's no BBOX in item->state, reason unknown (bug 992817); I made this not an assert to remove the warning
 631     if (!(item->state & NR_ARENA_ITEM_STATE_BBOX)
 632         || !(item->state & NR_ARENA_ITEM_STATE_PICK))
 633         return NULL;
 634
 635     if (!sticky && !(item->visible && item->sensitive))
 636         return NULL;
 637
 638     // TODO: rewrite using Geom::Rect
 639     const double x = p[Geom::X];
 640     const double y = p[Geom::Y];
 641
 642     if (((x + delta) >= item->bbox.x0) &&
 643         ((x - delta) < item->bbox.x1) &&
 644         ((y + delta) >= item->bbox.y0) && ((y - delta) < item->bbox.y1)) {
 645         if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick)
 646             return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->
 647                 pick (item, p, delta, sticky);
 648     }
 649
 650     return NULL;
 651 }
 652
 653 void
 654 nr_arena_item_request_update (NRArenaItem *item, unsigned int reset,
 655                               unsigned int propagate)
 656 {
 657     nr_return_if_fail (item != NULL);
 658     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 659     nr_return_if_fail (!(reset & NR_ARENA_ITEM_STATE_INVALID));
 660
 661     if (propagate && !item->propagate)
 662         item->propagate = TRUE;
 663
 664     if (item->state & reset) {
 665         item->state &= ~reset;
 666         if (item->parent) {
 667             nr_arena_item_request_update (item->parent, reset, FALSE);
 668         } else {
 669             nr_arena_request_update (item->arena, item);
 670         }
 671     }
 672 }
 673
 674 void
 675 nr_arena_item_request_render (NRArenaItem *item)
 676 {
 677     nr_return_if_fail (item != NULL);
 678     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 679
 680     nr_arena_request_render_rect (item->arena, &item->bbox);
 681 }
 682
 683 /* Public */
 684
 685 NRArenaItem *
 686 nr_arena_item_unparent (NRArenaItem *item)
 687 {
 688     nr_return_val_if_fail (item != NULL, NULL);
 689     nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 690
 691     nr_arena_item_request_render (item);
 692
 693     if (item->parent) {
 694         nr_arena_item_remove_child (item->parent, item);
 695     }
 696
 697     return NULL;
 698 }
 699
 700 void
 701 nr_arena_item_append_child (NRArenaItem *parent, NRArenaItem *child)
 702 {
 703     nr_return_if_fail (parent != NULL);
 704     nr_return_if_fail (NR_IS_ARENA_ITEM (parent));
 705     nr_return_if_fail (child != NULL);
 706     nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 707     nr_return_if_fail (parent->arena == child->arena);
 708     nr_return_if_fail (child->parent == NULL);
 709     nr_return_if_fail (child->prev == NULL);
 710     nr_return_if_fail (child->next == NULL);
 711
 712     nr_arena_item_add_child (parent, child, nr_arena_item_last_child (parent));
 713 }
 714
 715 void
 716 nr_arena_item_set_transform (NRArenaItem *item, Geom::Matrix const &transform)
 717 {
 718     Geom::Matrix const t (transform);
 719     nr_arena_item_set_transform (item, &t);
 720 }
 721
 722 void
 723 nr_arena_item_set_transform (NRArenaItem *item, Geom::Matrix const *transform)
 724 {
 725     nr_return_if_fail (item != NULL);
 726     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 727
 728     if (!transform && !item->transform)
 729         return;
 730
 731     const Geom::Matrix *md = (item->transform) ? item->transform : &GEOM_MATRIX_IDENTITY;
 732     const Geom::Matrix *ms = (transform) ? transform : &GEOM_MATRIX_IDENTITY;
 733
 734     if (!Geom::matrix_equalp(*md, *ms, NR_EPSILON)) {
 735         nr_arena_item_request_render (item);
 736         if (!transform || transform->isIdentity()) {
 737             /* Set to identity affine */
 738             item->transform = NULL;
 739         } else {
 740             if (!item->transform)
 741                 item->transform = new (GC::ATOMIC) Geom::Matrix ();
 742             *item->transform = *transform;
 743         }
 744         nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 745     }
 746 }
 747
 748 void
 749 nr_arena_item_set_opacity (NRArenaItem *item, double opacity)
 750 {
 751     nr_return_if_fail (item != NULL);
 752     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 753
 754     nr_arena_item_request_render (item);
 755
 756     item->opacity = (unsigned int) (opacity * 255.9999);
 757 }
 758
 759 void
 760 nr_arena_item_set_sensitive (NRArenaItem *item, unsigned int sensitive)
 761 {
 762     nr_return_if_fail (item != NULL);
 763     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 764
 765     /* fixme: mess with pick/repick... */
 766
 767     item->sensitive = sensitive;
 768 }
 769
 770 void
 771 nr_arena_item_set_visible (NRArenaItem *item, unsigned int visible)
 772 {
 773     nr_return_if_fail (item != NULL);
 774     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 775
 776     item->visible = visible;
 777
 778     nr_arena_item_request_render (item);
 779 }
 780
 781 void
 782 nr_arena_item_set_clip (NRArenaItem *item, NRArenaItem *clip)
 783 {
 784     nr_return_if_fail (item != NULL);
 785     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 786     nr_return_if_fail (!clip || NR_IS_ARENA_ITEM (clip));
 787
 788     if (clip != item->clip) {
 789         nr_arena_item_request_render (item);
 790         if (item->clip)
 791             item->clip = nr_arena_item_detach (item, item->clip);
 792         if (clip)
 793             item->clip = nr_arena_item_attach (item, clip, NULL, NULL);
 794         nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 795     }
 796 }
 797
 798 void
 799 nr_arena_item_set_mask (NRArenaItem *item, NRArenaItem *mask)
 800 {
 801     nr_return_if_fail (item != NULL);
 802     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 803     nr_return_if_fail (!mask || NR_IS_ARENA_ITEM (mask));
 804
 805     if (mask != item->mask) {
 806         nr_arena_item_request_render (item);
 807         if (item->mask)
 808             item->mask = nr_arena_item_detach (item, item->mask);
 809         if (mask)
 810             item->mask = nr_arena_item_attach (item, mask, NULL, NULL);
 811         nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 812     }
 813 }
 814
 815 void
 816 nr_arena_item_set_order (NRArenaItem *item, int order)
 817 {
 818     nr_return_if_fail (item != NULL);
 819     nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 820
 821     if (!item->parent)
 822         return;
 823
 824     NRArenaItem *children = nr_arena_item_children (item->parent);
 825
 826     NRArenaItem *ref = NULL;
 827     int pos = 0;
 828     for (NRArenaItem *child = children; child != NULL; child = child->next) {
 829         if (pos >= order)
 830             break;
 831         if (child != item) {
 832             ref = child;
 833             pos += 1;
 834         }
 835     }
 836
 837     nr_arena_item_set_child_position (item->parent, item, ref);
 838 }
 839
 840 void
 841 nr_arena_item_set_item_bbox (NRArenaItem *item, boost::optional<Geom::Rect> &bbox)
 842 {
 843     nr_return_if_fail(item != NULL);
 844     nr_return_if_fail(NR_IS_ARENA_ITEM(item));
 845
 846     if(bbox)  item->item_bbox = *bbox;
 847 }
 848
 849 /** Returns a background image for use with filter effects. */
 850 NRPixBlock *
 851 nr_arena_item_get_background (NRArenaItem const *item, int depth)
 852 {
 853     NRPixBlock *pb;
 854     if (!item->background_pb)
 855         return NULL;
 856     if (item->background_new) {
 857         pb = new NRPixBlock ();
 858         nr_pixblock_setup_fast (pb, item->background_pb->mode,
 859                                 item->background_pb->area.x0,
 860                                 item->background_pb->area.y0,
 861                                 item->background_pb->area.x1,
 862                                 item->background_pb->area.y1, true);
 863         if (pb->size != NR_PIXBLOCK_SIZE_TINY && pb->data.px == NULL) // allocation failed
 864             return NULL;
 865     } else if (item->parent) {
 866         pb = nr_arena_item_get_background (item->parent, depth + 1);
 867     } else
 868         return NULL;
 869
 870     if (depth > 0)
 871         nr_blit_pixblock_pixblock (pb, item->background_pb);
 872
 873     return pb;
 874 }
 875
 876 /* Helpers */
 877
 878 NRArenaItem *
 879 nr_arena_item_attach (NRArenaItem *parent, NRArenaItem *child,
 880                       NRArenaItem *prev, NRArenaItem *next)
 881 {
 882     nr_return_val_if_fail (parent != NULL, NULL);
 883     nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 884     nr_return_val_if_fail (child != NULL, NULL);
 885     nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 886     nr_return_val_if_fail (child->parent == NULL, NULL);
 887     nr_return_val_if_fail (child->prev == NULL, NULL);
 888     nr_return_val_if_fail (child->next == NULL, NULL);
 889     nr_return_val_if_fail (!prev || NR_IS_ARENA_ITEM (prev), NULL);
 890     nr_return_val_if_fail (!prev || (prev->parent == parent), NULL);
 891     nr_return_val_if_fail (!prev || (prev->next == next), NULL);
 892     nr_return_val_if_fail (!next || NR_IS_ARENA_ITEM (next), NULL);
 893     nr_return_val_if_fail (!next || (next->parent == parent), NULL);
 894     nr_return_val_if_fail (!next || (next->prev == prev), NULL);
 895
 896     child->parent = parent;
 897     child->prev = prev;
 898     child->next = next;
 899
 900     if (prev)
 901         prev->next = child;
 902     if (next)
 903         next->prev = child;
 904
 905     return child;
 906 }
 907
 908 NRArenaItem *
 909 nr_arena_item_detach (NRArenaItem *parent, NRArenaItem *child)
 910 {
 911     nr_return_val_if_fail (parent != NULL, NULL);
 912     nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 913     nr_return_val_if_fail (child != NULL, NULL);
 914     nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 915     nr_return_val_if_fail (child->parent == parent, NULL);
 916
 917     NRArenaItem *prev = child->prev;
 918     NRArenaItem *next = child->next;
 919
 920     child->parent = NULL;
 921     child->prev = NULL;
 922     child->next = NULL;
 923
 924     if (prev)
 925         prev->next = next;
 926     if (next)
 927         next->prev = prev;
 928
 929     return next;
 930 }
 931
 932 /*
 933   Local Variables:
 934   mode:c++
 935   c-file-style:"stroustrup"
 936   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 937   indent-tabs-mode:nil
 938   fill-column:99
 939   End:
 940 */
 941 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :