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