b80df727340113407243f4f3424d698645115135
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 "nr-arena.h"
24 #include "nr-arena-item.h"
25 #include "gc-core.h"
26 #include "helper/geom.h"
28 #include "nr-filter.h"
29 #include "nr-arena-group.h"
30 #include "preferences.h"
32 namespace GC = Inkscape::GC;
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);
38 static NRObjectClass *parent_class;
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 }
57 static void
58 nr_arena_item_class_init (NRArenaItemClass *klass)
59 {
60 NRObjectClass *object_class;
62 object_class = (NRObjectClass *) klass;
64 parent_class = ((NRObjectClass *) klass)->parent;
66 object_class->finalize = nr_arena_item_private_finalize;
67 object_class->cpp_ctor = NRObject::invoke_ctor < NRArenaItem >;
68 }
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;
77 item->key = 0;
79 item->state = 0;
80 item->sensitive = TRUE;
81 item->visible = TRUE;
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;
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 }
99 static void
100 nr_arena_item_private_finalize (NRObject *object)
101 {
102 NRArenaItem *item = static_cast < NRArenaItem * >(object);
104 item->px = NULL;
105 item->transform = NULL;
107 ((NRObjectClass *) (parent_class))->finalize (object);
108 }
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);
116 if (NR_ARENA_ITEM_VIRTUAL (item, children))
117 return NR_ARENA_ITEM_VIRTUAL (item, children) (item);
119 return NULL;
120 }
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);
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 }
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));
155 if (NR_ARENA_ITEM_VIRTUAL (item, add_child))
156 NR_ARENA_ITEM_VIRTUAL (item, add_child) (item, child, ref);
157 }
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);
168 if (NR_ARENA_ITEM_VIRTUAL (item, remove_child))
169 NR_ARENA_ITEM_VIRTUAL (item, remove_child) (item, child);
170 }
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));
184 if (NR_ARENA_ITEM_VIRTUAL (item, set_child_position))
185 NR_ARENA_ITEM_VIRTUAL (item, set_child_position) (item, child, ref);
186 }
188 NRArenaItem *
189 nr_arena_item_ref (NRArenaItem *item)
190 {
191 nr_object_ref ((NRObject *) item);
193 return item;
194 }
196 NRArenaItem *
197 nr_arena_item_unref (NRArenaItem *item)
198 {
199 nr_object_unref ((NRObject *) item);
201 return NULL;
202 }
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);
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);
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
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 }
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 }
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;
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;
261 // get a copy of bbox
262 memcpy(&item->drawbox, &item->bbox, sizeof(item->bbox));
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)
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 }
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 }
301 return item->state;
302 }
304 /**
305 * Render item to pixblock.
306 *
307 * \return Has NR_ARENA_ITEM_STATE_RENDER set on success.
308 */
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);
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);
325 #ifdef NR_ARENA_ITEM_VERBOSE
326 printf ("Invoke render %p: %d %d - %d %d\n", item, area->x0, area->y0,
327 area->x1, area->y1);
328 #endif
330 /* If we are invisible, just return successfully */
331 if (!item->visible)
332 return item->state | NR_ARENA_ITEM_STATE_RENDER;
334 NRRectL carea;
335 nr_rect_l_intersect (&carea, area, &item->drawbox);
336 if (nr_rect_l_test_empty(carea))
337 return item->state | NR_ARENA_ITEM_STATE_RENDER;
338 if (item->filter && filter) {
339 item->filter->area_enlarge (carea, item);
340 nr_rect_l_intersect (&carea, &carea, &item->drawbox);
341 }
343 if (outline) {
344 // No caching in outline mode for now; investigate if it really gives any advantage with cairo.
345 // Also no attempts to clip anything; just render everything: item, clip, mask
346 // First, render the object itself
347 unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, pb, flags);
348 if (state & NR_ARENA_ITEM_STATE_INVALID) {
349 /* Clean up and return error */
350 item->state |= NR_ARENA_ITEM_STATE_INVALID;
351 return item->state;
352 }
354 // render clip and mask, if any
355 guint32 saved_rgba = item->arena->outlinecolor; // save current outline color
356 // render clippath as an object, using a different color
357 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
358 if (item->clip) {
359 item->arena->outlinecolor = prefs->getInt("/options/wireframecolors/clips", 0x00ff00ff); // green clips
360 NR_ARENA_ITEM_VIRTUAL (item->clip, render) (ct, item->clip, &carea, pb, flags);
361 }
362 // render mask as an object, using a different color
363 if (item->mask) {
364 item->arena->outlinecolor = prefs->getInt("/options/wireframecolors/masks", 0x0000ffff); // blue masks
365 NR_ARENA_ITEM_VIRTUAL (item->mask, render) (ct, item->mask, &carea, pb, flags);
366 }
367 item->arena->outlinecolor = saved_rgba; // restore outline color
369 return item->state | NR_ARENA_ITEM_STATE_RENDER;
370 }
372 NRPixBlock cpb;
373 if (item->px) {
374 /* Has cache pixblock, render this and return */
375 nr_pixblock_setup_extern (&cpb, NR_PIXBLOCK_MODE_R8G8B8A8P,
376 /* fixme: This probably cannot overflow, because we render only if visible */
377 /* fixme: and pixel cache is there only for small items */
378 /* fixme: But this still needs extra check (Lauris) */
379 item->drawbox.x0, item->drawbox.y0,
380 item->drawbox.x1, item->drawbox.y1,
381 item->px,
382 4 * (item->drawbox.x1 - item->drawbox.x0), FALSE,
383 FALSE);
384 nr_blit_pixblock_pixblock (pb, &cpb);
385 nr_pixblock_release (&cpb);
386 pb->empty = FALSE;
387 return item->state | NR_ARENA_ITEM_STATE_RENDER;
388 }
390 NRPixBlock *dpb = pb;
392 /* Setup cache if we can */
393 if ((!(flags & NR_ARENA_ITEM_RENDER_NO_CACHE)) &&
394 (carea.x0 <= item->drawbox.x0) && (carea.y0 <= item->drawbox.y0) &&
395 (carea.x1 >= item->drawbox.x1) && (carea.y1 >= item->drawbox.y1) &&
396 (((item->drawbox.x1 - item->drawbox.x0) * (item->drawbox.y1 -
397 item->drawbox.y0)) <= 4096)) {
398 // Item drawbox is fully in renderable area and size is acceptable
399 carea.x0 = item->drawbox.x0;
400 carea.y0 = item->drawbox.y0;
401 carea.x1 = item->drawbox.x1;
402 carea.y1 = item->drawbox.y1;
403 item->px =
404 new (GC::ATOMIC) unsigned char[4 * (carea.x1 - carea.x0) *
405 (carea.y1 - carea.y0)];
406 nr_pixblock_setup_extern (&cpb, NR_PIXBLOCK_MODE_R8G8B8A8P, carea.x0,
407 carea.y0, carea.x1, carea.y1, item->px,
408 4 * (carea.x1 - carea.x0), TRUE, TRUE);
409 cpb.visible_area = pb->visible_area;
410 dpb = &cpb;
411 // Set nocache flag for downstream rendering
412 flags |= NR_ARENA_ITEM_RENDER_NO_CACHE;
413 }
415 /* Determine, whether we need temporary buffer */
416 if (item->clip || item->mask
417 || ((item->opacity != 255) && !item->render_opacity)
418 || (item->filter && filter) || item->background_new
419 || (item->parent && item->parent->background_pb)) {
421 /* Setup and render item buffer */
422 NRPixBlock ipb;
423 nr_pixblock_setup_fast (&ipb, NR_PIXBLOCK_MODE_R8G8B8A8P,
424 carea.x0, carea.y0, carea.x1, carea.y1,
425 TRUE);
427 // if memory allocation failed, abort render
428 if (ipb.size != NR_PIXBLOCK_SIZE_TINY && ipb.data.px == NULL) {
429 nr_pixblock_release (&ipb);
430 return (item->state);
431 }
433 /* If background access is used, save the pixblock address.
434 * This address is set to NULL at the end of this block */
435 if (item->background_new ||
436 (item->parent && item->parent->background_pb)) {
437 item->background_pb = &ipb;
438 }
440 ipb.visible_area = pb->visible_area;
441 if (item->filter && filter) {
442 item->filter->area_enlarge (ipb.visible_area, item);
443 }
445 unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, &ipb, flags);
446 if (state & NR_ARENA_ITEM_STATE_INVALID) {
447 /* Clean up and return error */
448 nr_pixblock_release (&ipb);
449 if (dpb != pb)
450 nr_pixblock_release (dpb);
451 item->state |= NR_ARENA_ITEM_STATE_INVALID;
452 return item->state;
453 }
454 ipb.empty = FALSE;
456 /* Run filtering, if a filter is set for this object */
457 if (item->filter && filter) {
458 item->filter->render (item, &ipb);
459 }
461 if (item->clip || item->mask) {
462 /* Setup mask pixblock */
463 NRPixBlock mpb;
464 nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0,
465 carea.y0, carea.x1, carea.y1, TRUE);
467 if (mpb.data.px != NULL) { // if memory allocation was successful
469 mpb.visible_area = pb->visible_area;
470 /* Do clip if needed */
471 if (item->clip) {
472 state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
473 if (state & NR_ARENA_ITEM_STATE_INVALID) {
474 /* Clean up and return error */
475 nr_pixblock_release (&mpb);
476 nr_pixblock_release (&ipb);
477 if (dpb != pb)
478 nr_pixblock_release (dpb);
479 item->state |= NR_ARENA_ITEM_STATE_INVALID;
480 return item->state;
481 }
482 mpb.empty = FALSE;
483 }
484 /* Do mask if needed */
485 if (item->mask) {
486 NRPixBlock tpb;
487 /* Set up yet another temporary pixblock */
488 nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N,
489 carea.x0, carea.y0, carea.x1,
490 carea.y1, TRUE);
492 if (tpb.data.px != NULL) { // if memory allocation was successful
494 tpb.visible_area = pb->visible_area;
495 unsigned int state = NR_ARENA_ITEM_VIRTUAL (item->mask, render) (ct, item->mask, &carea, &tpb, flags);
496 if (state & NR_ARENA_ITEM_STATE_INVALID) {
497 /* Clean up and return error */
498 nr_pixblock_release (&tpb);
499 nr_pixblock_release (&mpb);
500 nr_pixblock_release (&ipb);
501 if (dpb != pb)
502 nr_pixblock_release (dpb);
503 item->state |= NR_ARENA_ITEM_STATE_INVALID;
504 return item->state;
505 }
506 /* Composite with clip */
507 if (item->clip) {
508 int x, y;
509 for (y = carea.y0; y < carea.y1; y++) {
510 unsigned char *s, *d;
511 s = NR_PIXBLOCK_PX (&tpb) + (y -
512 carea.y0) * tpb.rs;
513 d = NR_PIXBLOCK_PX (&mpb) + (y -
514 carea.y0) * mpb.rs;
515 for (x = carea.x0; x < carea.x1; x++) {
516 unsigned int m;
517 m = NR_PREMUL_112 (s[0] + s[1] + s[2], s[3]);
518 d[0] =
519 FAST_DIV_ROUND < 3 * 255 * 255 >
520 (NR_PREMUL_123 (d[0], m));
521 s += 4;
522 d += 1;
523 }
524 }
525 } else {
526 int x, y;
527 for (y = carea.y0; y < carea.y1; y++) {
528 unsigned char *s, *d;
529 s = NR_PIXBLOCK_PX (&tpb) + (y -
530 carea.y0) * tpb.rs;
531 d = NR_PIXBLOCK_PX (&mpb) + (y -
532 carea.y0) * mpb.rs;
533 for (x = carea.x0; x < carea.x1; x++) {
534 unsigned int m;
535 m = NR_PREMUL_112 (s[0] + s[1] + s[2], s[3]);
536 d[0] = FAST_DIV_ROUND < 3 * 255 > (m);
537 s += 4;
538 d += 1;
539 }
540 }
541 mpb.empty = FALSE;
542 }
543 }
544 nr_pixblock_release (&tpb);
545 }
546 /* Multiply with opacity if needed */
547 if ((item->opacity != 255) && !item->render_opacity
548 ) {
549 int x, y;
550 unsigned int a;
551 a = item->opacity;
552 for (y = carea.y0; y < carea.y1; y++) {
553 unsigned char *d;
554 d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
555 for (x = carea.x0; x < carea.x1; x++) {
556 d[0] = NR_PREMUL_111 (d[0], a);
557 d += 1;
558 }
559 }
560 }
561 /* Compose rendering pixblock int destination */
562 nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
563 }
564 nr_pixblock_release (&mpb);
565 } else {
566 if (item->render_opacity) { // opacity was already rendered in, just copy to dpb here
567 nr_blit_pixblock_pixblock(dpb, &ipb);
568 } else { // copy while multiplying by opacity
569 nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
570 }
571 }
572 nr_pixblock_release (&ipb);
573 dpb->empty = FALSE;
574 /* This pointer wouldn't be valid outside this block, so clear it */
575 item->background_pb = NULL;
576 } else {
577 /* Just render */
578 unsigned int state = NR_ARENA_ITEM_VIRTUAL (item, render) (ct, item, &carea, dpb, flags);
579 if (state & NR_ARENA_ITEM_STATE_INVALID) {
580 /* Clean up and return error */
581 if (dpb != pb)
582 nr_pixblock_release (dpb);
583 item->state |= NR_ARENA_ITEM_STATE_INVALID;
584 return item->state;
585 }
586 dpb->empty = FALSE;
587 }
589 if (dpb != pb) {
590 /* Have to blit from cache */
591 nr_blit_pixblock_pixblock (pb, dpb);
592 nr_pixblock_release (dpb);
593 pb->empty = FALSE;
594 item->state |= NR_ARENA_ITEM_STATE_IMAGE;
595 }
597 return item->state | NR_ARENA_ITEM_STATE_RENDER;
598 }
600 unsigned int
601 nr_arena_item_invoke_clip (NRArenaItem *item, NRRectL *area, NRPixBlock *pb)
602 {
603 nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
604 nr_return_val_if_fail (NR_IS_ARENA_ITEM (item),
605 NR_ARENA_ITEM_STATE_INVALID);
606 /* we originally short-circuited if the object state included
607 * NR_ARENA_ITEM_STATE_CLIP (and showed a warning on the console);
608 * anyone know why we stopped doing so?
609 */
610 nr_return_val_if_fail ((pb->area.x1 - pb->area.x0) >=
611 (area->x1 - area->x0),
612 NR_ARENA_ITEM_STATE_INVALID);
613 nr_return_val_if_fail ((pb->area.y1 - pb->area.y0) >=
614 (area->y1 - area->y0),
615 NR_ARENA_ITEM_STATE_INVALID);
617 #ifdef NR_ARENA_ITEM_VERBOSE
618 printf ("Invoke clip by %p: %d %d - %d %d, item bbox %d %d - %d %d\n",
619 item, area->x0, area->y0, area->x1, area->y1, (&item->bbox)->x0,
620 (&item->bbox)->y0, (&item->bbox)->x1, (&item->bbox)->y1);
621 #endif
623 if (item->visible && nr_rect_l_test_intersect_ptr(area, &item->bbox)) {
624 /* Need render that item */
625 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->clip) {
626 return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->
627 clip (item, area, pb);
628 }
629 }
631 return item->state;
632 }
634 NRArenaItem *
635 nr_arena_item_invoke_pick (NRArenaItem *item, Geom::Point p, double delta,
636 unsigned int sticky)
637 {
638 nr_return_val_if_fail (item != NULL, NULL);
639 nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
641 // Sometimes there's no BBOX in item->state, reason unknown (bug 992817); I made this not an assert to remove the warning
642 if (!(item->state & NR_ARENA_ITEM_STATE_BBOX)
643 || !(item->state & NR_ARENA_ITEM_STATE_PICK))
644 return NULL;
646 if (!sticky && !(item->visible && item->sensitive))
647 return NULL;
649 // TODO: rewrite using Geom::Rect
650 const double x = p[Geom::X];
651 const double y = p[Geom::Y];
653 if (((x + delta) >= item->bbox.x0) &&
654 ((x - delta) < item->bbox.x1) &&
655 ((y + delta) >= item->bbox.y0) && ((y - delta) < item->bbox.y1)) {
656 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick)
657 return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->
658 pick (item, p, delta, sticky);
659 }
661 return NULL;
662 }
664 void
665 nr_arena_item_request_update (NRArenaItem *item, unsigned int reset,
666 unsigned int propagate)
667 {
668 nr_return_if_fail (item != NULL);
669 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
670 nr_return_if_fail (!(reset & NR_ARENA_ITEM_STATE_INVALID));
672 if (propagate && !item->propagate)
673 item->propagate = TRUE;
675 if (item->state & reset) {
676 item->state &= ~reset;
677 if (item->parent) {
678 nr_arena_item_request_update (item->parent, reset, FALSE);
679 } else {
680 nr_arena_request_update (item->arena, item);
681 }
682 }
683 }
685 void
686 nr_arena_item_request_render (NRArenaItem *item)
687 {
688 nr_return_if_fail (item != NULL);
689 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
691 nr_arena_request_render_rect (item->arena, &item->drawbox);
692 }
694 /* Public */
696 NRArenaItem *
697 nr_arena_item_unparent (NRArenaItem *item)
698 {
699 nr_return_val_if_fail (item != NULL, NULL);
700 nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
702 nr_arena_item_request_render (item);
704 if (item->parent) {
705 nr_arena_item_remove_child (item->parent, item);
706 }
708 return NULL;
709 }
711 void
712 nr_arena_item_append_child (NRArenaItem *parent, NRArenaItem *child)
713 {
714 nr_return_if_fail (parent != NULL);
715 nr_return_if_fail (NR_IS_ARENA_ITEM (parent));
716 nr_return_if_fail (child != NULL);
717 nr_return_if_fail (NR_IS_ARENA_ITEM (child));
718 nr_return_if_fail (parent->arena == child->arena);
719 nr_return_if_fail (child->parent == NULL);
720 nr_return_if_fail (child->prev == NULL);
721 nr_return_if_fail (child->next == NULL);
723 nr_arena_item_add_child (parent, child, nr_arena_item_last_child (parent));
724 }
726 void
727 nr_arena_item_set_transform (NRArenaItem *item, Geom::Matrix const &transform)
728 {
729 Geom::Matrix const t (transform);
730 nr_arena_item_set_transform (item, &t);
731 }
733 void
734 nr_arena_item_set_transform (NRArenaItem *item, Geom::Matrix const *transform)
735 {
736 nr_return_if_fail (item != NULL);
737 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
739 if (!transform && !item->transform)
740 return;
742 const Geom::Matrix *md = (item->transform) ? item->transform : &GEOM_MATRIX_IDENTITY;
743 const Geom::Matrix *ms = (transform) ? transform : &GEOM_MATRIX_IDENTITY;
745 if (!Geom::matrix_equalp(*md, *ms, NR_EPSILON)) {
746 nr_arena_item_request_render (item);
747 if (!transform || transform->isIdentity()) {
748 /* Set to identity affine */
749 item->transform = NULL;
750 } else {
751 if (!item->transform)
752 item->transform = new (GC::ATOMIC) Geom::Matrix ();
753 *item->transform = *transform;
754 }
755 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
756 }
757 }
759 void
760 nr_arena_item_set_opacity (NRArenaItem *item, double opacity)
761 {
762 nr_return_if_fail (item != NULL);
763 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
765 nr_arena_item_request_render (item);
767 item->opacity = (unsigned int) (opacity * 255.9999);
768 }
770 void
771 nr_arena_item_set_sensitive (NRArenaItem *item, unsigned int sensitive)
772 {
773 nr_return_if_fail (item != NULL);
774 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
776 /* fixme: mess with pick/repick... */
778 item->sensitive = sensitive;
779 }
781 void
782 nr_arena_item_set_visible (NRArenaItem *item, unsigned int visible)
783 {
784 nr_return_if_fail (item != NULL);
785 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
787 item->visible = visible;
789 nr_arena_item_request_render (item);
790 }
792 void
793 nr_arena_item_set_clip (NRArenaItem *item, NRArenaItem *clip)
794 {
795 nr_return_if_fail (item != NULL);
796 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
797 nr_return_if_fail (!clip || NR_IS_ARENA_ITEM (clip));
799 if (clip != item->clip) {
800 nr_arena_item_request_render (item);
801 if (item->clip)
802 item->clip = nr_arena_item_detach (item, item->clip);
803 if (clip)
804 item->clip = nr_arena_item_attach (item, clip, NULL, NULL);
805 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
806 }
807 }
809 void
810 nr_arena_item_set_mask (NRArenaItem *item, NRArenaItem *mask)
811 {
812 nr_return_if_fail (item != NULL);
813 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
814 nr_return_if_fail (!mask || NR_IS_ARENA_ITEM (mask));
816 if (mask != item->mask) {
817 nr_arena_item_request_render (item);
818 if (item->mask)
819 item->mask = nr_arena_item_detach (item, item->mask);
820 if (mask)
821 item->mask = nr_arena_item_attach (item, mask, NULL, NULL);
822 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
823 }
824 }
826 void
827 nr_arena_item_set_order (NRArenaItem *item, int order)
828 {
829 nr_return_if_fail (item != NULL);
830 nr_return_if_fail (NR_IS_ARENA_ITEM (item));
832 if (!item->parent)
833 return;
835 NRArenaItem *children = nr_arena_item_children (item->parent);
837 NRArenaItem *ref = NULL;
838 int pos = 0;
839 for (NRArenaItem *child = children; child != NULL; child = child->next) {
840 if (pos >= order)
841 break;
842 if (child != item) {
843 ref = child;
844 pos += 1;
845 }
846 }
848 nr_arena_item_set_child_position (item->parent, item, ref);
849 }
851 void
852 nr_arena_item_set_item_bbox (NRArenaItem *item, Geom::OptRect &bbox)
853 {
854 nr_return_if_fail(item != NULL);
855 nr_return_if_fail(NR_IS_ARENA_ITEM(item));
857 item->item_bbox = bbox;
858 }
860 /** Returns a background image for use with filter effects. */
861 NRPixBlock *
862 nr_arena_item_get_background (NRArenaItem const *item, int depth)
863 {
864 NRPixBlock *pb;
865 if (!item->background_pb)
866 return NULL;
867 if (item->background_new) {
868 pb = new NRPixBlock ();
869 nr_pixblock_setup_fast (pb, item->background_pb->mode,
870 item->background_pb->area.x0,
871 item->background_pb->area.y0,
872 item->background_pb->area.x1,
873 item->background_pb->area.y1, true);
874 if (pb->size != NR_PIXBLOCK_SIZE_TINY && pb->data.px == NULL) // allocation failed
875 return NULL;
876 } else if (item->parent) {
877 pb = nr_arena_item_get_background (item->parent, depth + 1);
878 } else
879 return NULL;
881 if (depth > 0)
882 nr_blit_pixblock_pixblock (pb, item->background_pb);
884 return pb;
885 }
887 /* Helpers */
889 NRArenaItem *
890 nr_arena_item_attach (NRArenaItem *parent, NRArenaItem *child,
891 NRArenaItem *prev, NRArenaItem *next)
892 {
893 nr_return_val_if_fail (parent != NULL, NULL);
894 nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
895 nr_return_val_if_fail (child != NULL, NULL);
896 nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
897 nr_return_val_if_fail (child->parent == NULL, NULL);
898 nr_return_val_if_fail (child->prev == NULL, NULL);
899 nr_return_val_if_fail (child->next == NULL, NULL);
900 nr_return_val_if_fail (!prev || NR_IS_ARENA_ITEM (prev), NULL);
901 nr_return_val_if_fail (!prev || (prev->parent == parent), NULL);
902 nr_return_val_if_fail (!prev || (prev->next == next), NULL);
903 nr_return_val_if_fail (!next || NR_IS_ARENA_ITEM (next), NULL);
904 nr_return_val_if_fail (!next || (next->parent == parent), NULL);
905 nr_return_val_if_fail (!next || (next->prev == prev), NULL);
907 child->parent = parent;
908 child->prev = prev;
909 child->next = next;
911 if (prev)
912 prev->next = child;
913 if (next)
914 next->prev = child;
916 return child;
917 }
919 NRArenaItem *
920 nr_arena_item_detach (NRArenaItem *parent, NRArenaItem *child)
921 {
922 nr_return_val_if_fail (parent != NULL, NULL);
923 nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
924 nr_return_val_if_fail (child != NULL, NULL);
925 nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
926 nr_return_val_if_fail (child->parent == parent, NULL);
928 NRArenaItem *prev = child->prev;
929 NRArenaItem *next = child->next;
931 child->parent = NULL;
932 child->prev = NULL;
933 child->next = NULL;
935 if (prev)
936 prev->next = next;
937 if (next)
938 next->prev = prev;
940 return next;
941 }
943 /*
944 Local Variables:
945 mode:c++
946 c-file-style:"stroustrup"
947 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
948 indent-tabs-mode:nil
949 fill-column:99
950 End:
951 */
952 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :