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