d944b4228aa6f14509bd00f4cdcf3807ae5ca548
1 #define __NR_ARENA_ITEM_C__
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 */
15 #define noNR_ARENA_ITEM_VERBOSE
16 #define noNR_ARENA_ITEM_DEBUG_CASCADE
18 #include <cstring>
19 #include <string>
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"
30 #include "nr-filter.h"
31 #include "libnr/nr-rect.h"
32 #include "nr-arena-group.h"
33 #include "preferences.h"
35 namespace GC = Inkscape::GC;
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);
41 static NRObjectClass *parent_class;
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 }
60 static void
61 nr_arena_item_class_init (NRArenaItemClass *klass)
62 {
63 NRObjectClass *object_class;
65 object_class = (NRObjectClass *) klass;
67 parent_class = ((NRObjectClass *) klass)->parent;
69 object_class->finalize = nr_arena_item_private_finalize;
70 object_class->cpp_ctor = NRObject::invoke_ctor < NRArenaItem >;
71 }
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;
80 item->key = 0;
82 item->state = 0;
83 item->sensitive = TRUE;
84 item->visible = TRUE;
86 memset (&item->bbox, 0, sizeof (item->bbox));
87 item->transform = NULL;
88 item->opacity = 255;
89 item->render_opacity = FALSE;
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 }
101 static void
102 nr_arena_item_private_finalize (NRObject *object)
103 {
104 NRArenaItem *item = static_cast < NRArenaItem * >(object);
106 item->px = NULL;
107 item->transform = NULL;
109 ((NRObjectClass *) (parent_class))->finalize (object);
110 }
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);
118 if (NR_ARENA_ITEM_VIRTUAL (item, children))
119 return NR_ARENA_ITEM_VIRTUAL (item, children) (item);
121 return NULL;
122 }
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);
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 }
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));
157 if (NR_ARENA_ITEM_VIRTUAL (item, add_child))
158 NR_ARENA_ITEM_VIRTUAL (item, add_child) (item, child, ref);
159 }
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);
170 if (NR_ARENA_ITEM_VIRTUAL (item, remove_child))
171 NR_ARENA_ITEM_VIRTUAL (item, remove_child) (item, child);
172 }
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));
186 if (NR_ARENA_ITEM_VIRTUAL (item, set_child_position))
187 NR_ARENA_ITEM_VIRTUAL (item, set_child_position) (item, child, ref);
188 }
190 NRArenaItem *
191 nr_arena_item_ref (NRArenaItem *item)
192 {
193 nr_object_ref ((NRObject *) item);
195 return item;
196 }
198 NRArenaItem *
199 nr_arena_item_unref (NRArenaItem *item)
200 {
201 nr_object_unref ((NRObject *) item);
203 return NULL;
204 }
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);
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);
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
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 }
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 }
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;
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)
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 }
292 return item->state;
293 }
295 /**
296 * Render item to pixblock.
297 *
298 * \return Has NR_ARENA_ITEM_STATE_RENDER set on success.
299 */
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);
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);
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
319 /* If we are outside bbox just return successfully */
320 if (!item->visible)
321 return item->state | NR_ARENA_ITEM_STATE_RENDER;
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 }
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 }
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
358 return item->state | NR_ARENA_ITEM_STATE_RENDER;
359 }
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 }
379 NRPixBlock *dpb = pb;
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 }
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)) {
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);
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 }
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 }
429 ipb.visible_area = pb->visible_area;
430 if (item->filter && filter) {
431 item->filter->area_enlarge (ipb.visible_area, item->ctm);
432 }
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;
445 /* Run filtering, if a filter is set for this object */
446 if (item->filter && filter) {
447 item->filter->render (item, &ipb);
448 }
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);
456 if (mpb.data.px != NULL) { // if memory allocation was successful
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);
481 if (tpb.data.px != NULL) { // if memory allocation was successful
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 }
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 }
586 return item->state | NR_ARENA_ITEM_STATE_RENDER;
587 }
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);
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
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 }
620 return item->state;
621 }
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);
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;
635 if (!sticky && !(item->visible && item->sensitive))
636 return NULL;
638 // TODO: rewrite using Geom::Rect
639 const double x = p[Geom::X];
640 const double y = p[Geom::Y];
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 }
650 return NULL;
651 }
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));
661 if (propagate && !item->propagate)
662 item->propagate = TRUE;
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 }
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));
680 nr_arena_request_render_rect (item->arena, &item->bbox);
681 }
683 /* Public */
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);
691 nr_arena_item_request_render (item);
693 if (item->parent) {
694 nr_arena_item_remove_child (item->parent, item);
695 }
697 return NULL;
698 }
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);
712 nr_arena_item_add_child (parent, child, nr_arena_item_last_child (parent));
713 }
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 }
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));
728 if (!transform && !item->transform)
729 return;
731 const Geom::Matrix *md = (item->transform) ? item->transform : &GEOM_MATRIX_IDENTITY;
732 const Geom::Matrix *ms = (transform) ? transform : &GEOM_MATRIX_IDENTITY;
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 }
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));
754 nr_arena_item_request_render (item);
756 item->opacity = (unsigned int) (opacity * 255.9999);
757 }
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));
765 /* fixme: mess with pick/repick... */
767 item->sensitive = sensitive;
768 }
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));
776 item->visible = visible;
778 nr_arena_item_request_render (item);
779 }
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));
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 }
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));
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 }
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));
821 if (!item->parent)
822 return;
824 NRArenaItem *children = nr_arena_item_children (item->parent);
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 }
837 nr_arena_item_set_child_position (item->parent, item, ref);
838 }
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));
846 if(bbox) item->item_bbox = *bbox;
847 }
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;
870 if (depth > 0)
871 nr_blit_pixblock_pixblock (pb, item->background_pb);
873 return pb;
874 }
876 /* Helpers */
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);
896 child->parent = parent;
897 child->prev = prev;
898 child->next = next;
900 if (prev)
901 prev->next = child;
902 if (next)
903 next->prev = child;
905 return child;
906 }
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);
917 NRArenaItem *prev = child->prev;
918 NRArenaItem *next = child->next;
920 child->parent = NULL;
921 child->prev = NULL;
922 child->next = NULL;
924 if (prev)
925 prev->next = next;
926 if (next)
927 next->prev = prev;
929 return next;
930 }
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 :