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