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
  19 #include <libnr/nr-blit.h>
  20 #include <libnr/nr-pixops.h>
  21 #include "nr-arena.h"
  22 #include "nr-arena-item.h"
  23 //#include "nr-arena-group.h"
  24 #include "gc-core.h"
  25
  26 namespace GC = Inkscape::GC;
  27
  28 static void nr_arena_item_class_init (NRArenaItemClass *klass);
  29 static void nr_arena_item_init (NRArenaItem *item);
  30 static void nr_arena_item_private_finalize (NRObject *object);
  31
  32 #ifdef arena_item_tile_cache
  33 bool  insert_cache(NRArenaItem* owner,int th,int tv,NRPixBlock *ipb,NRPixBlock *mpb,double activity,double duration);
  34 void  remove_caches(NRArenaItem* owner);
  35 bool  test_cache(NRArenaItem* owner,int th,int tv,NRPixBlock &ipb,NRPixBlock &mpb,bool &hasMask);
  36 #endif
  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 *)) nr_arena_item_class_init,
  50                                                 (void (*) (NRObject *)) nr_arena_item_init);
  51         }
  52         return type;
  53 }
  54
  55 static void
  56 nr_arena_item_class_init (NRArenaItemClass *klass)
  57 {
  58         NRObjectClass *object_class;
  59
  60         object_class = (NRObjectClass *) klass;
  61
  62         parent_class = ((NRObjectClass *) klass)->parent;
  63
  64         object_class->finalize = nr_arena_item_private_finalize;
  65         object_class->cpp_ctor = NRObject::invoke_ctor<NRArenaItem>;
  66 }
  67
  68 static void
  69 nr_arena_item_init (NRArenaItem *item)
  70 {
  71         item->arena = NULL;
  72         item->parent = NULL;
  73         item->next = item->prev = NULL;
  74
  75         item->key = 0;
  76
  77         item->state = 0;
  78         item->sensitive = TRUE;
  79         item->visible = TRUE;
  80
  81         memset(&item->bbox, 0, sizeof(item->bbox));
  82         item->transform = NULL;
  83         item->opacity = 255;
  84         item->render_opacity = FALSE;
  85
  86 #ifdef arena_item_tile_cache
  87   item->activity=0.0;
  88   item->skipCaching=false;
  89 #endif
  90
  91         item->transform = NULL;
  92         item->clip = NULL;
  93         item->mask = NULL;
  94         item->px = NULL;
  95         item->data = NULL;
  96 }
  97
  98 static void
  99 nr_arena_item_private_finalize (NRObject *object)
 100 {
 101         NRArenaItem *item=static_cast<NRArenaItem *>(object);
 102
 103 #ifdef arena_item_tile_cache
 104   remove_caches(item);
 105 #endif
 106
 107         item->px = NULL;
 108         item->transform = NULL;
 109
 110         ((NRObjectClass *) (parent_class))->finalize (object);
 111 }
 112
 113 NRArenaItem *
 114 nr_arena_item_children (NRArenaItem *item)
 115 {
 116         nr_return_val_if_fail (item != NULL, NULL);
 117         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 118
 119         if (NR_ARENA_ITEM_VIRTUAL (item, children))
 120                 return NR_ARENA_ITEM_VIRTUAL (item, children) (item);
 121
 122         return NULL;
 123 }
 124
 125 NRArenaItem *
 126 nr_arena_item_last_child (NRArenaItem *item)
 127 {
 128         nr_return_val_if_fail (item != NULL, NULL);
 129         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 130
 131         if (NR_ARENA_ITEM_VIRTUAL (item, last_child)) {
 132                 return NR_ARENA_ITEM_VIRTUAL (item, last_child) (item);
 133         } else {
 134                 NRArenaItem *ref;
 135                 ref = nr_arena_item_children (item);
 136                 if (ref) while (ref->next) ref = ref->next;
 137                 return ref;
 138         }
 139 }
 140
 141 void
 142 nr_arena_item_add_child (NRArenaItem *item, NRArenaItem *child, NRArenaItem *ref)
 143 {
 144         nr_return_if_fail (item != NULL);
 145         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 146         nr_return_if_fail (child != NULL);
 147         nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 148         nr_return_if_fail (child->parent == NULL);
 149         nr_return_if_fail (child->prev == NULL);
 150         nr_return_if_fail (child->next == NULL);
 151         nr_return_if_fail (child->arena == item->arena);
 152         nr_return_if_fail (child != ref);
 153         nr_return_if_fail (!ref || NR_IS_ARENA_ITEM (ref));
 154         nr_return_if_fail (!ref || (ref->parent == item));
 155
 156         if (NR_ARENA_ITEM_VIRTUAL (item, add_child))
 157                 NR_ARENA_ITEM_VIRTUAL (item, add_child) (item, child, ref);
 158 }
 159
 160 void
 161 nr_arena_item_remove_child (NRArenaItem *item, NRArenaItem *child)
 162 {
 163         nr_return_if_fail (item != NULL);
 164         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 165         nr_return_if_fail (child != NULL);
 166         nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 167         nr_return_if_fail (child->parent == item);
 168
 169         if (NR_ARENA_ITEM_VIRTUAL (item, remove_child))
 170                 NR_ARENA_ITEM_VIRTUAL (item, remove_child) (item, child);
 171 }
 172
 173 void
 174 nr_arena_item_set_child_position (NRArenaItem *item, NRArenaItem *child, 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, unsigned int state, unsigned int reset)
 206 {
 207         NRGC childgc(gc);
 208
 209         nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 210         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NR_ARENA_ITEM_STATE_INVALID);
 211         nr_return_val_if_fail (!(state & NR_ARENA_ITEM_STATE_INVALID), NR_ARENA_ITEM_STATE_INVALID);
 212
 213 #ifdef NR_ARENA_ITEM_DEBUG_CASCADE
 214         printf ("Update %s:%p %x %x %x\n", nr_type_name_from_instance ((GTypeInstance *) item), item, state, item->state, reset);
 215 #endif
 216
 217         /* return if in error */
 218         if (item->state & NR_ARENA_ITEM_STATE_INVALID) return item->state;
 219         /* Set reset flags according to propagation status */
 220         if (item->propagate) {
 221                 reset |= ~item->state;
 222                 item->propagate = FALSE;
 223         }
 224         /* Reset our state */
 225         item->state &= ~reset;
 226         /* Return if NOP */
 227         if (!(~item->state & state)) return item->state;
 228         /* Test whether to return immediately */
 229         if (area && (item->state & NR_ARENA_ITEM_STATE_BBOX)) {
 230                 if (!nr_rect_l_test_intersect (area, &item->bbox)) return item->state;
 231         }
 232
 233         /* Reset image cache, if not to be kept */
 234         if (!(item->state & NR_ARENA_ITEM_STATE_IMAGE) && (item->px)) {
 235                 item->px = NULL;
 236         }
 237 #ifdef arena_item_tile_cache
 238   remove_caches(item);
 239 #endif
 240
 241         /* Set up local gc */
 242         childgc = *gc;
 243         if (item->transform) {
 244                 nr_matrix_multiply (&childgc.transform, item->transform, &childgc.transform);
 245         }
 246
 247         /* Invoke the real method */
 248         item->state = NR_ARENA_ITEM_VIRTUAL (item, update) (item, area, &childgc, state, reset);
 249         if (item->state & NR_ARENA_ITEM_STATE_INVALID) return item->state;
 250         /* Clipping */
 251         if (item->clip) {
 252                 unsigned int newstate;
 253                 newstate = nr_arena_item_invoke_update (item->clip, area, &childgc, state, reset);
 254                 if (newstate & NR_ARENA_ITEM_STATE_INVALID) {
 255                         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 256                         return item->state;
 257                 }
 258                 nr_rect_l_intersect (&item->bbox, &item->bbox, &item->clip->bbox);
 259         }
 260         /* Masking */
 261         if (item->mask) {
 262                 unsigned int newstate;
 263                 newstate = nr_arena_item_invoke_update (item->mask, area, &childgc, state, reset);
 264                 if (newstate & NR_ARENA_ITEM_STATE_INVALID) {
 265                         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 266                         return item->state;
 267                 }
 268                 nr_rect_l_intersect (&item->bbox, &item->bbox, &item->mask->bbox);
 269         }
 270
 271         return item->state;
 272 }
 273
 274 /**
 275  *    Render item to pixblock.
 276  *
 277  *    \return Has NR_ARENA_ITEM_STATE_RENDER set on success.
 278  */
 279
 280 unsigned int nr_arena_item_invoke_render(NRArenaItem *item, NRRectL const *area, NRPixBlock *pb, unsigned int flags)
 281 {
 282         NRRectL carea;
 283         NRPixBlock *dpb;
 284         NRPixBlock cpb;
 285         unsigned int state;
 286
 287         nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 288         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NR_ARENA_ITEM_STATE_INVALID);
 289         nr_return_val_if_fail (item->state & NR_ARENA_ITEM_STATE_BBOX, item->state);
 290
 291 #ifdef NR_ARENA_ITEM_VERBOSE
 292         printf ("Invoke render %p: %d %d - %d %d\n", item, area->x0, area->y0, area->x1, area->y1);
 293 #endif
 294
 295 #ifdef arena_item_tile_cache
 296   item->activity*=0.5;
 297 #endif
 298
 299         /* If we are outside bbox just return successfully */
 300         if (!item->visible) return item->state | NR_ARENA_ITEM_STATE_RENDER;
 301         nr_rect_l_intersect (&carea, area, &item->bbox);
 302         if (nr_rect_l_test_empty (&carea)) return item->state | NR_ARENA_ITEM_STATE_RENDER;
 303
 304         if (item->px) {
 305                 /* Has cache pixblock, render this and return */
 306                 nr_pixblock_setup_extern (&cpb, NR_PIXBLOCK_MODE_R8G8B8A8P,
 307                                           /* fixme: This probably cannot overflow, because we render only if visible */
 308                                           /* fixme: and pixel cache is there only for small items */
 309                                           /* fixme: But this still needs extra check (Lauris) */
 310                                           item->bbox.x0, item->bbox.y0,
 311                                           item->bbox.x1, item->bbox.y1,
 312                                           item->px, 4 * (item->bbox.x1 - item->bbox.x0), FALSE, FALSE);
 313                 nr_blit_pixblock_pixblock (pb, &cpb);
 314                 nr_pixblock_release (&cpb);
 315                 pb->empty = FALSE;
 316                 return item->state | NR_ARENA_ITEM_STATE_RENDER;
 317         }
 318
 319         dpb = pb;
 320   bool  canCache=false;
 321 #ifdef arena_item_tile_cache
 322   bool checkCache=false;
 323   int   tile_h=0,tile_v=0;
 324 #endif
 325         /* Setup cache if we can */
 326         if ((!(flags & NR_ARENA_ITEM_RENDER_NO_CACHE)) &&
 327             (carea.x0 <= item->bbox.x0) && (carea.y0 <= item->bbox.y0) &&
 328             (carea.x1 >= item->bbox.x1) && (carea.y1 >= item->bbox.y1) &&
 329             (((item->bbox.x1 - item->bbox.x0) * (item->bbox.y1 - item->bbox.y0)) <= 4096)) {
 330                 // Item bbox is fully in renderable area and size is acceptable
 331                 carea.x0 = item->bbox.x0;
 332                 carea.y0 = item->bbox.y0;
 333                 carea.x1 = item->bbox.x1;
 334                 carea.y1 = item->bbox.y1;
 335                 item->px = new (GC::ATOMIC) unsigned char[4 * (carea.x1 - carea.x0) * (carea.y1 - carea.y0)];
 336                 nr_pixblock_setup_extern (&cpb, NR_PIXBLOCK_MODE_R8G8B8A8P,
 337                               carea.x0, carea.y0, carea.x1, carea.y1,
 338                               item->px, 4 * (carea.x1 - carea.x0), TRUE, TRUE);
 339         cpb.visible_area = pb->visible_area;
 340                 dpb = &cpb;
 341                 // Set nocache flag for downstream rendering
 342                 flags |= NR_ARENA_ITEM_RENDER_NO_CACHE;
 343         } else {
 344 #ifdef arena_item_tile_cache
 345     if ( item->skipCaching ) {
 346     } else {
 347       int tl=area->x0&(~127);
 348       int tt=area->y0&(~127);
 349       if ( area->x1 <= tl+128 && area->y1 <= tt+128 ) {
 350         checkCache=true;
 351         tile_h=tl/128;
 352         tile_v=tt/128;
 353         int surf=(area->x1-area->x0)*(area->y1-area->y0);
 354         if ( surf >= 4096 ) {
 355           canCache=true;
 356           carea.x0=tl;
 357           carea.y0=tt;
 358           carea.x1=tl+128;
 359           carea.y1=tt+128;
 360         }
 361       }
 362     }
 363 #endif
 364   }
 365
 366 #ifdef arena_item_tile_cache
 367   item->activity+=1.0;
 368 #endif
 369
 370 #ifdef arena_item_tile_cache
 371   if ( checkCache ) {
 372     NRPixBlock ipb, mpb;
 373     bool       hasMask;
 374     if ( test_cache(item,tile_h,tile_v,ipb,mpb,hasMask) ) {
 375       // youpi! c'etait deja cache
 376       if ( hasMask ) {
 377         nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
 378       } else if ( ((item->opacity != 255) && !item->render_opacity) ) {
 379         nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
 380       } else {
 381         nr_blit_pixblock_pixblock (pb, &ipb);
 382       }
 383       pb->empty = FALSE;
 384       return item->state | NR_ARENA_ITEM_STATE_RENDER;
 385     }
 386   }
 387 #endif
 388   if ( canCache ) {
 389 #ifdef arena_item_tile_cache
 390     // nota: exclusif de dpb != pb, donc pas de cas particulier a la fin
 391     NRPixBlock ipb, mpb;
 392
 393     // struct timeval start_time,end_time;
 394     // gettimeofday(&start_time,NULL);
 395     GTimeVal start_time,end_time;
 396     g_get_current_time (&start_time);
 397     int    duration=0;
 398
 399     /* Setup and render item buffer */
 400     nr_pixblock_setup_fast (&ipb, NR_PIXBLOCK_MODE_R8G8B8A8P, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 401     ipb.visible_area = pb->visible_area;
 402     state = NR_ARENA_ITEM_VIRTUAL (item, render) (item, &carea, &ipb, flags);
 403     if (state & NR_ARENA_ITEM_STATE_INVALID) {
 404       /* Clean up and return error */
 405       nr_pixblock_release (&ipb);
 406       if (dpb != pb) nr_pixblock_release (dpb);
 407       item->state |= NR_ARENA_ITEM_STATE_INVALID;
 408       return item->state;
 409     }
 410     ipb.empty = FALSE;
 411
 412     if (item->clip || item->mask) {
 413       /* Setup mask pixblock */
 414       nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 415       mpb.visible_area = pb->visible_area;
 416       /* Do clip if needed */
 417       if (item->clip) {
 418         state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
 419         if (state & NR_ARENA_ITEM_STATE_INVALID) {
 420           /* Clean up and return error */
 421           nr_pixblock_release (&mpb);
 422           nr_pixblock_release (&ipb);
 423           if (dpb != pb) nr_pixblock_release (dpb);
 424           item->state |= NR_ARENA_ITEM_STATE_INVALID;
 425           return item->state;
 426         }
 427         mpb.empty = FALSE;
 428       }
 429       /* Do mask if needed */
 430       if (item->mask) {
 431         NRPixBlock tpb;
 432         /* Set up yet another temporary pixblock */
 433         nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 434         tpb.visible_area = pb->visible_area;
 435         state = NR_ARENA_ITEM_VIRTUAL (item->mask, render) (item->mask, &carea, &tpb, flags);
 436         if (state & NR_ARENA_ITEM_STATE_INVALID) {
 437           /* Clean up and return error */
 438           nr_pixblock_release (&tpb);
 439           nr_pixblock_release (&mpb);
 440           nr_pixblock_release (&ipb);
 441           if (dpb != pb) nr_pixblock_release (dpb);
 442           item->state |= NR_ARENA_ITEM_STATE_INVALID;
 443           return item->state;
 444         }
 445         /* Composite with clip */
 446         if (item->clip) {
 447           int x, y;
 448           for (y = carea.y0; y < carea.y1; y++) {
 449             unsigned char *s, *d;
 450             s = NR_PIXBLOCK_PX (&tpb) + (y - carea.y0) * tpb.rs;
 451             d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 452             for (x = carea.x0; x < carea.x1; x++) {
 453               unsigned int m;
 454               m = ((s[0] + s[1] + s[2]) * s[3] + 127) / (3 * 255);
 455               d[0] = NR_PREMUL (d[0], m);
 456               s += 4;
 457               d += 1;
 458             }
 459           }
 460         } else {
 461           int x, y;
 462           for (y = carea.y0; y < carea.y1; y++) {
 463             unsigned char *s, *d;
 464             s = NR_PIXBLOCK_PX (&tpb) + (y - carea.y0) * tpb.rs;
 465             d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 466             for (x = carea.x0; x < carea.x1; x++) {
 467               unsigned int m;
 468               m = ((s[0] + s[1] + s[2]) * s[3] + 127) / (3 * 255);
 469               d[0] = m;
 470               s += 4;
 471               d += 1;
 472             }
 473           }
 474           mpb.empty = FALSE;
 475         }
 476         nr_pixblock_release (&tpb);
 477       }
 478       /* Multiply with opacity if needed */
 479       if ((item->opacity != 255) && !item->render_opacity && item->arena->rendermode != RENDERMODE_OUTLINE) {
 480         int x, y;
 481         unsigned int a;
 482         a = item->opacity;
 483         for (y = carea.y0; y < carea.y1; y++) {
 484           unsigned char *d;
 485           d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 486           for (x = carea.x0; x < carea.x1; x++) {
 487             d[0] = NR_PREMUL (d[0], a);
 488             d += 1;
 489           }
 490         }
 491       }
 492       /* Compose rendering pixblock int destination */
 493       // gettimeofday(&end_time,NULL);
 494       g_get_current_time (&end_time);
 495       duration=(end_time.tv_sec-start_time.tv_sec)*1000+(end_time.tv_usec-start_time.tv_usec)/1000;
 496       if ( !(ipb.empty) ) {
 497         nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
 498         if ( insert_cache(item,tile_h,tile_v,&ipb,&mpb,item->activity,(double)duration) ) {
 499         } else {
 500           nr_pixblock_release (&mpb);
 501           nr_pixblock_release (&ipb);
 502         }
 503         dpb->empty = FALSE;
 504       } else {
 505         nr_pixblock_release (&ipb);
 506       }
 507     } else if ( ((item->opacity != 255) && !item->render_opacity && item->arena->rendermode != RENDERMODE_OUTLINE) ) {
 508       /* Opacity only */
 509       // gettimeofday(&end_time,NULL);
 510       g_get_current_time (&end_time);
 511       duration=(end_time.tv_sec-start_time.tv_sec)*1000+(end_time.tv_usec-start_time.tv_usec)/1000;
 512       if ( !(ipb.empty) ) {
 513         nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
 514         if ( insert_cache(item,tile_h,tile_v,&ipb,NULL,item->activity,(double)duration) ) {
 515         } else {
 516           nr_pixblock_release (&ipb);
 517         }
 518         dpb->empty = FALSE;
 519       } else {
 520         nr_pixblock_release (&ipb);
 521       }
 522     } else {
 523       // gettimeofday(&end_time,NULL);
 524       g_get_current_time (&end_time);
 525       duration=(end_time.tv_sec-start_time.tv_sec)*1000+(end_time.tv_usec-start_time.tv_usec)/1000;
 526       if ( !(ipb.empty) ) {
 527         nr_blit_pixblock_pixblock (dpb, &ipb);
 528         if ( insert_cache(item,tile_h,tile_v,&ipb,NULL,item->activity,(double)duration) ) {
 529         } else {
 530           nr_pixblock_release (&ipb);
 531         }
 532         dpb->empty = FALSE;
 533       } else {
 534         nr_pixblock_release (&ipb);
 535       }
 536     }
 537 #endif
 538   } else {
 539     /* Determine, whether we need temporary buffer */
 540     if (item->clip || item->mask || ((item->opacity != 255) && !item->render_opacity && item->arena->rendermode != RENDERMODE_OUTLINE)) {
 541       NRPixBlock ipb, mpb;
 542
 543       /* Setup and render item buffer */
 544       nr_pixblock_setup_fast (&ipb, NR_PIXBLOCK_MODE_R8G8B8A8P, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 545       ipb.visible_area = pb->visible_area;
 546       state = NR_ARENA_ITEM_VIRTUAL (item, render) (item, &carea, &ipb, flags);
 547       if (state & NR_ARENA_ITEM_STATE_INVALID) {
 548         /* Clean up and return error */
 549         nr_pixblock_release (&ipb);
 550         if (dpb != pb) nr_pixblock_release (dpb);
 551         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 552         return item->state;
 553       }
 554       ipb.empty = FALSE;
 555
 556       if (item->clip || item->mask) {
 557         /* Setup mask pixblock */
 558         nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 559         mpb.visible_area = pb->visible_area;
 560         /* Do clip if needed */
 561         if (item->clip) {
 562           state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
 563           if (state & NR_ARENA_ITEM_STATE_INVALID) {
 564             /* Clean up and return error */
 565             nr_pixblock_release (&mpb);
 566             nr_pixblock_release (&ipb);
 567             if (dpb != pb) nr_pixblock_release (dpb);
 568             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 569             return item->state;
 570           }
 571           mpb.empty = FALSE;
 572         }
 573         /* Do mask if needed */
 574         if (item->mask) {
 575           NRPixBlock tpb;
 576           /* Set up yet another temporary pixblock */
 577           nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 578           tpb.visible_area = pb->visible_area;
 579           state = NR_ARENA_ITEM_VIRTUAL (item->mask, render) (item->mask, &carea, &tpb, flags);
 580           if (state & NR_ARENA_ITEM_STATE_INVALID) {
 581             /* Clean up and return error */
 582             nr_pixblock_release (&tpb);
 583             nr_pixblock_release (&mpb);
 584             nr_pixblock_release (&ipb);
 585             if (dpb != pb) nr_pixblock_release (dpb);
 586             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 587             return item->state;
 588           }
 589           /* Composite with clip */
 590           if (item->clip) {
 591             int x, y;
 592             for (y = carea.y0; y < carea.y1; y++) {
 593               unsigned char *s, *d;
 594               s = NR_PIXBLOCK_PX (&tpb) + (y - carea.y0) * tpb.rs;
 595               d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 596               for (x = carea.x0; x < carea.x1; x++) {
 597                 unsigned int m;
 598                 m = ((s[0] + s[1] + s[2]) * s[3] + 127) / (3 * 255);
 599                 d[0] = NR_PREMUL (d[0], m);
 600                 s += 4;
 601                 d += 1;
 602               }
 603             }
 604           } else {
 605             int x, y;
 606             for (y = carea.y0; y < carea.y1; y++) {
 607               unsigned char *s, *d;
 608               s = NR_PIXBLOCK_PX (&tpb) + (y - carea.y0) * tpb.rs;
 609               d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 610               for (x = carea.x0; x < carea.x1; x++) {
 611                 unsigned int m;
 612                 m = ((s[0] + s[1] + s[2]) * s[3] + 127) / (3 * 255);
 613                 d[0] = m;
 614                 s += 4;
 615                 d += 1;
 616               }
 617             }
 618             mpb.empty = FALSE;
 619           }
 620           nr_pixblock_release (&tpb);
 621         }
 622         /* Multiply with opacity if needed */
 623         if ((item->opacity != 255) && !item->render_opacity && item->arena->rendermode != RENDERMODE_OUTLINE) {
 624           int x, y;
 625           unsigned int a;
 626           a = item->opacity;
 627           for (y = carea.y0; y < carea.y1; y++) {
 628             unsigned char *d;
 629             d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 630             for (x = carea.x0; x < carea.x1; x++) {
 631               d[0] = NR_PREMUL (d[0], a);
 632               d += 1;
 633             }
 634           }
 635         }
 636         /* Compose rendering pixblock int destination */
 637         nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
 638         nr_pixblock_release (&mpb);
 639       } else {
 640         /* Opacity only */
 641         nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
 642       }
 643       nr_pixblock_release (&ipb);
 644       dpb->empty = FALSE;
 645     } else {
 646       /* Just render */
 647       state = NR_ARENA_ITEM_VIRTUAL (item, render) (item, &carea, dpb, flags);
 648       if (state & NR_ARENA_ITEM_STATE_INVALID) {
 649         /* Clean up and return error */
 650         if (dpb != pb) nr_pixblock_release (dpb);
 651         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 652         return item->state;
 653       }
 654       dpb->empty = FALSE;
 655     }
 656
 657     if (dpb != pb) {
 658       /* Have to blit from cache */
 659       nr_blit_pixblock_pixblock (pb, dpb);
 660       nr_pixblock_release (dpb);
 661       pb->empty = FALSE;
 662       item->state |= NR_ARENA_ITEM_STATE_IMAGE;
 663     }
 664   }
 665         return item->state | NR_ARENA_ITEM_STATE_RENDER;
 666 }
 667
 668 unsigned int
 669 nr_arena_item_invoke_clip (NRArenaItem *item, NRRectL *area, NRPixBlock *pb)
 670 {
 671         nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 672         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NR_ARENA_ITEM_STATE_INVALID);
 673         /* we originally short-circuited if the object state included
 674          * NR_ARENA_ITEM_STATE_CLIP (and showed a warning on the console);
 675          * anyone know why we stopped doing so?
 676          */
 677         nr_return_val_if_fail ((pb->area.x1 - pb->area.x0) >= (area->x1 - area->x0), NR_ARENA_ITEM_STATE_INVALID);
 678         nr_return_val_if_fail ((pb->area.y1 - pb->area.y0) >= (area->y1 - area->y0), NR_ARENA_ITEM_STATE_INVALID);
 679
 680 #ifdef NR_ARENA_ITEM_VERBOSE
 681         printf ("Invoke clip by %p: %d %d - %d %d, item bbox %d %d - %d %d\n", item, area->x0, area->y0, area->x1, area->y1, (&item->bbox)->x0, (&item->bbox)->y0, (&item->bbox)->x1, (&item->bbox)->y1);
 682 #endif
 683
 684         if (item->visible && nr_rect_l_test_intersect (area, &item->bbox)) {
 685                 /* Need render that item */
 686                 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->clip) {
 687                         return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS(item))->clip (item, area, pb);
 688                 }
 689         }
 690
 691         return item->state;
 692 }
 693
 694 NRArenaItem *
 695 nr_arena_item_invoke_pick (NRArenaItem *item, NR::Point p, double delta, unsigned int sticky)
 696 {
 697         nr_return_val_if_fail (item != NULL, NULL);
 698         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 699
 700         // Sometimes there's no BBOX in item->state, reason unknown (bug 992817); I made this not an assert to remove the warning
 701         if (!(item->state & NR_ARENA_ITEM_STATE_BBOX) || !(item->state & NR_ARENA_ITEM_STATE_PICK))
 702                 return NULL;
 703
 704         if (!sticky && !(item->visible && item->sensitive)) return NULL;
 705
 706         // TODO: rewrite using NR::Rect
 707         const double x = p[NR::X];
 708         const double y = p[NR::Y];
 709
 710         if (((x + delta) >= item->bbox.x0) &&
 711             ((x - delta) <  item->bbox.x1) &&
 712             ((y + delta) >= item->bbox.y0) &&
 713             ((y - delta) <  item->bbox.y1)) {
 714                 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick)
 715                         return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick (item, p, delta, sticky);
 716         }
 717
 718         return NULL;
 719 }
 720
 721 void
 722 nr_arena_item_request_update (NRArenaItem *item, unsigned int reset, unsigned int propagate)
 723 {
 724         nr_return_if_fail (item != NULL);
 725         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 726         nr_return_if_fail (!(reset & NR_ARENA_ITEM_STATE_INVALID));
 727
 728         if (propagate && !item->propagate) item->propagate = TRUE;
 729
 730         if (item->state & reset) {
 731                 item->state &= ~reset;
 732                 if (item->parent) {
 733                         nr_arena_item_request_update (item->parent, reset, FALSE);
 734                 } else {
 735                         nr_arena_request_update (item->arena, item);
 736                 }
 737         }
 738 }
 739
 740 void
 741 nr_arena_item_request_render (NRArenaItem *item)
 742 {
 743         nr_return_if_fail (item != NULL);
 744         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 745
 746         nr_arena_request_render_rect (item->arena, &item->bbox);
 747 }
 748
 749 /* Public */
 750
 751 NRArenaItem *
 752 nr_arena_item_unparent (NRArenaItem *item)
 753 {
 754         nr_return_val_if_fail (item != NULL, NULL);
 755         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 756
 757         nr_arena_item_request_render (item);
 758
 759         if (item->parent) {
 760                 nr_arena_item_remove_child (item->parent, item);
 761         }
 762
 763         return NULL;
 764 }
 765
 766 void
 767 nr_arena_item_append_child (NRArenaItem *parent, NRArenaItem *child)
 768 {
 769         nr_return_if_fail (parent != NULL);
 770         nr_return_if_fail (NR_IS_ARENA_ITEM (parent));
 771         nr_return_if_fail (child != NULL);
 772         nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 773         nr_return_if_fail (parent->arena == child->arena);
 774         nr_return_if_fail (child->parent == NULL);
 775         nr_return_if_fail (child->prev == NULL);
 776         nr_return_if_fail (child->next == NULL);
 777
 778         nr_arena_item_add_child (parent, child, nr_arena_item_last_child (parent));
 779 }
 780
 781 void
 782 nr_arena_item_set_transform(NRArenaItem *item, NR::Matrix const &transform)
 783 {
 784         NRMatrix const t(transform);
 785         nr_arena_item_set_transform(item, &t);
 786 }
 787
 788 void
 789 nr_arena_item_set_transform(NRArenaItem *item, NRMatrix const *transform)
 790 {
 791         const NRMatrix *ms, *md;
 792
 793         nr_return_if_fail (item != NULL);
 794         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 795
 796         if (!transform && !item->transform) return;
 797
 798         md = (item->transform) ? item->transform : &NR_MATRIX_IDENTITY;
 799         ms = (transform) ? transform : &NR_MATRIX_IDENTITY;
 800
 801         if (!NR_MATRIX_DF_TEST_CLOSE (md, ms, NR_EPSILON)) {
 802                 nr_arena_item_request_render (item);
 803                 if (!transform || nr_matrix_test_identity (transform, NR_EPSILON)) {
 804                         /* Set to identity affine */
 805                         item->transform = NULL;
 806                 } else {
 807                         if (!item->transform) item->transform = new (GC::ATOMIC) NRMatrix();
 808                         *item->transform = *transform;
 809                 }
 810                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 811         }
 812 }
 813
 814 void
 815 nr_arena_item_set_opacity (NRArenaItem *item, double opacity)
 816 {
 817         nr_return_if_fail (item != NULL);
 818         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 819
 820         nr_arena_item_request_render (item);
 821
 822         item->opacity = (unsigned int) (opacity * 255.9999);
 823 }
 824
 825 void
 826 nr_arena_item_set_sensitive (NRArenaItem *item, unsigned int sensitive)
 827 {
 828         nr_return_if_fail (item != NULL);
 829         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 830
 831         /* fixme: mess with pick/repick... */
 832
 833         item->sensitive = sensitive;
 834 }
 835
 836 void
 837 nr_arena_item_set_visible (NRArenaItem *item, unsigned int visible)
 838 {
 839         nr_return_if_fail (item != NULL);
 840         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 841
 842         item->visible = visible;
 843
 844         nr_arena_item_request_render (item);
 845 }
 846
 847 void
 848 nr_arena_item_set_clip (NRArenaItem *item, NRArenaItem *clip)
 849 {
 850         nr_return_if_fail (item != NULL);
 851         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 852         nr_return_if_fail (!clip || NR_IS_ARENA_ITEM (clip));
 853
 854         if (clip != item->clip) {
 855                 nr_arena_item_request_render (item);
 856                 if (item->clip) item->clip = nr_arena_item_detach (item, item->clip);
 857                 if (clip) item->clip = nr_arena_item_attach (item, clip, NULL, NULL);
 858                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 859         }
 860 }
 861
 862 void
 863 nr_arena_item_set_mask (NRArenaItem *item, NRArenaItem *mask)
 864 {
 865         nr_return_if_fail (item != NULL);
 866         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 867         nr_return_if_fail (!mask || NR_IS_ARENA_ITEM (mask));
 868
 869         if (mask != item->mask) {
 870                 nr_arena_item_request_render (item);
 871                 if (item->mask) item->mask = nr_arena_item_detach (item, item->mask);
 872                 if (mask) item->mask = nr_arena_item_attach (item, mask, NULL, NULL);
 873                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 874         }
 875 }
 876
 877 void
 878 nr_arena_item_set_order (NRArenaItem *item, int order)
 879 {
 880         NRArenaItem *children, *child, *ref;
 881         int pos;
 882
 883         nr_return_if_fail (item != NULL);
 884         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 885
 886         if (!item->parent) return;
 887
 888         children = nr_arena_item_children (item->parent);
 889
 890         ref = NULL;
 891         pos = 0;
 892         for (child = children; child != NULL; child = child->next) {
 893                 if (pos >= order) break;
 894                 if (child != item) {
 895                         ref = child;
 896                         pos += 1;
 897                 }
 898         }
 899
 900         nr_arena_item_set_child_position (item->parent, item, ref);
 901 }
 902
 903 /* Helpers */
 904
 905 NRArenaItem *
 906 nr_arena_item_attach (NRArenaItem *parent, NRArenaItem *child, NRArenaItem *prev, NRArenaItem *next)
 907 {
 908         nr_return_val_if_fail (parent != NULL, NULL);
 909         nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 910         nr_return_val_if_fail (child != NULL, NULL);
 911         nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 912         nr_return_val_if_fail (child->parent == NULL, NULL);
 913         nr_return_val_if_fail (child->prev == NULL, NULL);
 914         nr_return_val_if_fail (child->next == NULL, NULL);
 915         nr_return_val_if_fail (!prev || NR_IS_ARENA_ITEM (prev), NULL);
 916         nr_return_val_if_fail (!prev || (prev->parent == parent), NULL);
 917         nr_return_val_if_fail (!prev || (prev->next == next), NULL);
 918         nr_return_val_if_fail (!next || NR_IS_ARENA_ITEM (next), NULL);
 919         nr_return_val_if_fail (!next || (next->parent == parent), NULL);
 920         nr_return_val_if_fail (!next || (next->prev == prev), NULL);
 921
 922         child->parent = parent;
 923         child->prev = prev;
 924         child->next = next;
 925
 926         if (prev) prev->next = child;
 927         if (next) next->prev = child;
 928
 929         return child;
 930 }
 931
 932 NRArenaItem *
 933 nr_arena_item_detach (NRArenaItem *parent, NRArenaItem *child)
 934 {
 935         NRArenaItem *prev, *next;
 936
 937         nr_return_val_if_fail (parent != NULL, NULL);
 938         nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 939         nr_return_val_if_fail (child != NULL, NULL);
 940         nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 941         nr_return_val_if_fail (child->parent == parent, NULL);
 942
 943         prev = child->prev;
 944         next = child->next;
 945
 946         child->parent = NULL;
 947         child->prev = NULL;
 948         child->next = NULL;
 949
 950         if (prev) prev->next = next;
 951         if (next) next->prev = prev;
 952
 953         return next;
 954 }
 955
 956 /*
 957  *
 958  * caches
 959  *
 960  */
 961
 962 #ifdef arena_item_tile_cache
 963 typedef struct cache_entry {
 964   int             key;
 965   double          score;
 966   NRArenaItem*    owner;
 967   int             th,tv;
 968   int             prev,next;
 969   NRPixBlock      ipb;
 970   bool            hasMask;
 971   NRPixBlock      mpb;
 972 } cache_entry;
 973
 974 int hash_max=2048,hash_fill=1024;
 975
 976 int            *keys=NULL;
 977 int            nbCch=0;
 978
 979 int            nbEnt=0,maxEnt=0;
 980 cache_entry*   entries=NULL;
 981
 982 //#define tile_cache_stats
 983 #ifdef tile_cache_stats
 984 double         hits=0,misses=0;
 985 int            hitMissCount=0;
 986 #endif
 987
 988 int hash_that(NRArenaItem* owner,int th,int tv)
 989 {
 990   int res=GPOINTER_TO_INT(owner);
 991   res*=17;
 992   res+=th;
 993   res*=59;
 994   res+=tv;
 995   res*=217;
 996   if ( res < 0 ) res=-res;
 997   res%=hash_max;
 998   return res;
 999 }
1000
1001 bool  test_cache(NRArenaItem* owner,int th,int tv,NRPixBlock &ipb,NRPixBlock &mpb,bool &hasMask)
1002 {
1003   if ( keys == NULL ) {
1004     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1005     hash_fill=(hash_max*3)/4;
1006     keys=(int*)malloc(hash_max*sizeof(int));
1007     for (int i=0;i<hash_max;i++) keys[i]=-1;
1008   }
1009   int key=hash_that(owner,th,tv);
1010   if ( keys[key] < 0 ) {
1011 #ifdef tile_cache_stats
1012     misses+=1.0;
1013 #endif
1014     return false;
1015   }
1016   int cur=keys[key];
1017   while ( cur >= 0 && cur < nbEnt ) {
1018     if ( entries[cur].owner == owner && entries[cur].th == th && entries[cur].tv == tv ) {
1019       hasMask=entries[cur].hasMask;
1020       ipb=entries[cur].ipb;
1021       mpb=entries[cur].mpb;
1022 #ifdef tile_cache_stats
1023       hits+=1.0;
1024 #endif
1025       return true;
1026     }
1027     cur=entries[cur].next;
1028   }
1029 #ifdef tile_cache_stats
1030   misses+=1.0;
1031 #endif
1032   return false;
1033 }
1034 void  remove_one_cache(int no)
1035 {
1036   if ( no < 0 || no >= nbEnt ) return;
1037
1038   nr_pixblock_release(&entries[no].ipb);
1039   if ( entries[no].hasMask ) nr_pixblock_release(&entries[no].mpb);
1040
1041   if ( entries[no].prev >= 0 ) entries[entries[no].prev].next=entries[no].next;
1042   if ( entries[no].next >= 0 ) entries[entries[no].next].prev=entries[no].prev;
1043   if ( entries[no].prev < 0 ) keys[entries[no].key]=entries[no].next;
1044   entries[no].prev=entries[no].next=entries[no].key=-1;
1045
1046   if ( no == nbEnt-1 ) {
1047     nbEnt--;
1048     return;
1049   }
1050   entries[no]=entries[--nbEnt];
1051   if ( entries[no].prev >= 0 ) entries[entries[no].prev].next=no;
1052   if ( entries[no].next >= 0 ) entries[entries[no].next].prev=no;
1053   if ( entries[no].prev < 0 ) keys[entries[no].key]=no;
1054 }
1055 void  remove_caches(NRArenaItem* owner)
1056 {
1057   if ( keys == NULL ) {
1058     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1059     hash_fill=(hash_max*3)/4;
1060     keys=(int*)malloc(hash_max*sizeof(int));
1061     for (int i=0;i<hash_max;i++) keys[i]=-1;
1062   }
1063   for (int i=nbEnt-1;i>=0;i--) {
1064     if ( entries[i].owner == owner ) {
1065       remove_one_cache(i);
1066     }
1067   }
1068 }
1069 void  age_cache(void)
1070 {
1071   for (int i=0;i<nbEnt;i++) entries[i].score*=0.95;
1072 }
1073 bool  insert_cache(NRArenaItem* owner,int th,int tv,NRPixBlock *ipb,NRPixBlock *mpb,double activity,double duration)
1074 {
1075   if ( keys == NULL ) {
1076     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1077     hash_fill=(hash_max*3)/4;
1078     keys=(int*)malloc(hash_max*sizeof(int));
1079     for (int i=0;i<hash_max;i++) keys[i]=-1;
1080   }
1081   for (int i=0;i<nbEnt;i++) entries[i].score*=0.95;
1082 #ifdef tile_cache_stats
1083   hits*=0.95;
1084   misses*=0.95;
1085   hitMissCount++;
1086   if ( hitMissCount > 100 ) {
1087     hitMissCount=0;
1088     printf("hit/miss = %f  used/total=%i/%i\n",(misses>0.001)?hits/misses:100000.0,nbEnt,hash_max); // localizing ok
1089   }
1090 #endif
1091   int    key=hash_that(owner,th,tv);
1092   double nScore=/*activity**/duration;
1093
1094   if ( keys[key] >= 0 ) {
1095     int cur=keys[key];
1096     while ( cur >= 0 && cur < nbEnt ) {
1097       if ( entries[cur].owner == owner && entries[cur].th == th && entries[cur].tv == tv ) {
1098         remove_one_cache(cur);
1099         break;
1100       }
1101       cur=entries[cur].next;
1102     }
1103   }
1104
1105   bool doAdd=false;
1106   if ( nbEnt < hash_fill ) {
1107     doAdd=true;
1108   } else {
1109     double    worstS=entries[0].score;
1110     int       worstE=0;
1111     for (int i=1;i<nbEnt;i++) {
1112       if ( entries[i].score < worstS ) {
1113         worstS=entries[i].score;
1114         worstE=i;
1115       }
1116     }
1117     if ( worstS < nScore ) {
1118       doAdd=true;
1119       remove_one_cache(worstE);
1120     }
1121   }
1122   if ( doAdd == false ) return false;
1123   if ( nbEnt >= maxEnt ) {
1124     maxEnt=2*nbEnt+1;
1125     entries=(cache_entry*)realloc(entries,maxEnt*sizeof(cache_entry));
1126   }
1127   entries[nbEnt].key=key;
1128   entries[nbEnt].score=nScore;
1129   entries[nbEnt].owner=owner;
1130   entries[nbEnt].th=th;
1131   entries[nbEnt].tv=tv;
1132   entries[nbEnt].prev=entries[nbEnt].next=-1;
1133   entries[nbEnt].ipb=*ipb;
1134   if ( mpb ) {
1135     entries[nbEnt].hasMask=true;
1136     entries[nbEnt].mpb=*mpb;
1137   } else {
1138     entries[nbEnt].hasMask=false;
1139   }
1140   entries[nbEnt].next=keys[key];
1141   if ( entries[nbEnt].next >= 0 ) entries[entries[nbEnt].next].prev=nbEnt;
1142   keys[key]=nbEnt;
1143
1144   nbEnt++;
1145   return true;
1146 }
1147 #endif
1148
1149
1150
1151