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                 dpb = &cpb;
 344                 // Set nocache flag for downstream rendering
 345                 flags |= NR_ARENA_ITEM_RENDER_NO_CACHE;
 346         } else {
 347 #ifdef arena_item_tile_cache
 348     if ( item->skipCaching ) {
 349     } else {
 350       int tl=area->x0&(~127);
 351       int tt=area->y0&(~127);
 352       if ( area->x1 <= tl+128 && area->y1 <= tt+128 ) {
 353         checkCache=true;
 354         tile_h=tl/128;
 355         tile_v=tt/128;
 356         int surf=(area->x1-area->x0)*(area->y1-area->y0);
 357         if ( surf >= 4096 ) {
 358           canCache=true;
 359           carea.x0=tl;
 360           carea.y0=tt;
 361           carea.x1=tl+128;
 362           carea.y1=tt+128;
 363         }
 364       }
 365     }
 366 #endif
 367   }
 368
 369 #ifdef arena_item_tile_cache
 370   item->activity+=1.0;
 371 #endif
 372
 373 #ifdef arena_item_tile_cache
 374   if ( checkCache ) {
 375     NRPixBlock ipb, mpb;
 376     bool       hasMask;
 377     if ( test_cache(item,tile_h,tile_v,ipb,mpb,hasMask) ) {
 378       // youpi! c'etait deja cache
 379       if ( hasMask ) {
 380         nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
 381       } else if ( ((item->opacity != 255) && !item->render_opacity) ) {
 382         nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
 383       } else {
 384         nr_blit_pixblock_pixblock (pb, &ipb);
 385       }
 386       pb->empty = FALSE;
 387       return item->state | NR_ARENA_ITEM_STATE_RENDER;
 388     }
 389   }
 390 #endif
 391   if ( canCache ) {
 392 #ifdef arena_item_tile_cache
 393     // nota: exclusif de dpb != pb, donc pas de cas particulier a la fin
 394     NRPixBlock ipb, mpb;
 395
 396     // struct timeval start_time,end_time;
 397     // gettimeofday(&start_time,NULL);
 398     GTimeVal start_time,end_time;
 399     g_get_current_time (&start_time);
 400     int    duration=0;
 401
 402     /* Setup and render item buffer */
 403     nr_pixblock_setup_fast (&ipb, NR_PIXBLOCK_MODE_R8G8B8A8P, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 404     state = NR_ARENA_ITEM_VIRTUAL (item, render) (item, &carea, &ipb, flags);
 405     if (state & NR_ARENA_ITEM_STATE_INVALID) {
 406       /* Clean up and return error */
 407       nr_pixblock_release (&ipb);
 408       if (dpb != pb) nr_pixblock_release (dpb);
 409       item->state |= NR_ARENA_ITEM_STATE_INVALID;
 410       return item->state;
 411     }
 412     ipb.empty = FALSE;
 413
 414     if (item->clip || item->mask) {
 415       /* Setup mask pixblock */
 416       nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 417       /* Do clip if needed */
 418       if (item->clip) {
 419         state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
 420         if (state & NR_ARENA_ITEM_STATE_INVALID) {
 421           /* Clean up and return error */
 422           nr_pixblock_release (&mpb);
 423           nr_pixblock_release (&ipb);
 424           if (dpb != pb) nr_pixblock_release (dpb);
 425           item->state |= NR_ARENA_ITEM_STATE_INVALID;
 426           return item->state;
 427         }
 428         mpb.empty = FALSE;
 429       }
 430       /* Do mask if needed */
 431       if (item->mask) {
 432         NRPixBlock tpb;
 433         /* Set up yet another temporary pixblock */
 434         nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 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       state = NR_ARENA_ITEM_VIRTUAL (item, render) (item, &carea, &ipb, flags);
 546       if (state & NR_ARENA_ITEM_STATE_INVALID) {
 547         /* Clean up and return error */
 548         nr_pixblock_release (&ipb);
 549         if (dpb != pb) nr_pixblock_release (dpb);
 550         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 551         return item->state;
 552       }
 553       ipb.empty = FALSE;
 554
 555       if (item->clip || item->mask) {
 556         /* Setup mask pixblock */
 557         nr_pixblock_setup_fast (&mpb, NR_PIXBLOCK_MODE_A8, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 558         /* Do clip if needed */
 559         if (item->clip) {
 560           state = nr_arena_item_invoke_clip (item->clip, &carea, &mpb);
 561           if (state & NR_ARENA_ITEM_STATE_INVALID) {
 562             /* Clean up and return error */
 563             nr_pixblock_release (&mpb);
 564             nr_pixblock_release (&ipb);
 565             if (dpb != pb) nr_pixblock_release (dpb);
 566             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 567             return item->state;
 568           }
 569           mpb.empty = FALSE;
 570         }
 571         /* Do mask if needed */
 572         if (item->mask) {
 573           NRPixBlock tpb;
 574           /* Set up yet another temporary pixblock */
 575           nr_pixblock_setup_fast (&tpb, NR_PIXBLOCK_MODE_R8G8B8A8N, carea.x0, carea.y0, carea.x1, carea.y1, TRUE);
 576           state = NR_ARENA_ITEM_VIRTUAL (item->mask, render) (item->mask, &carea, &tpb, flags);
 577           if (state & NR_ARENA_ITEM_STATE_INVALID) {
 578             /* Clean up and return error */
 579             nr_pixblock_release (&tpb);
 580             nr_pixblock_release (&mpb);
 581             nr_pixblock_release (&ipb);
 582             if (dpb != pb) nr_pixblock_release (dpb);
 583             item->state |= NR_ARENA_ITEM_STATE_INVALID;
 584             return item->state;
 585           }
 586           /* Composite with clip */
 587           if (item->clip) {
 588             int x, y;
 589             for (y = carea.y0; y < carea.y1; y++) {
 590               unsigned char *s, *d;
 591               s = NR_PIXBLOCK_PX (&tpb) + (y - carea.y0) * tpb.rs;
 592               d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 593               for (x = carea.x0; x < carea.x1; x++) {
 594                 unsigned int m;
 595                 m = ((s[0] + s[1] + s[2]) * s[3] + 127) / (3 * 255);
 596                 d[0] = NR_PREMUL (d[0], m);
 597                 s += 4;
 598                 d += 1;
 599               }
 600             }
 601           } else {
 602             int x, y;
 603             for (y = carea.y0; y < carea.y1; y++) {
 604               unsigned char *s, *d;
 605               s = NR_PIXBLOCK_PX (&tpb) + (y - carea.y0) * tpb.rs;
 606               d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 607               for (x = carea.x0; x < carea.x1; x++) {
 608                 unsigned int m;
 609                 m = ((s[0] + s[1] + s[2]) * s[3] + 127) / (3 * 255);
 610                 d[0] = m;
 611                 s += 4;
 612                 d += 1;
 613               }
 614             }
 615             mpb.empty = FALSE;
 616           }
 617           nr_pixblock_release (&tpb);
 618         }
 619         /* Multiply with opacity if needed */
 620         if ((item->opacity != 255) && !item->render_opacity && item->arena->rendermode != RENDERMODE_OUTLINE) {
 621           int x, y;
 622           unsigned int a;
 623           a = item->opacity;
 624           for (y = carea.y0; y < carea.y1; y++) {
 625             unsigned char *d;
 626             d = NR_PIXBLOCK_PX (&mpb) + (y - carea.y0) * mpb.rs;
 627             for (x = carea.x0; x < carea.x1; x++) {
 628               d[0] = NR_PREMUL (d[0], a);
 629               d += 1;
 630             }
 631           }
 632         }
 633         /* Compose rendering pixblock int destination */
 634         nr_blit_pixblock_pixblock_mask (dpb, &ipb, &mpb);
 635         nr_pixblock_release (&mpb);
 636       } else {
 637         /* Opacity only */
 638         nr_blit_pixblock_pixblock_alpha (dpb, &ipb, item->opacity);
 639       }
 640       nr_pixblock_release (&ipb);
 641       dpb->empty = FALSE;
 642     } else {
 643       /* Just render */
 644       state = NR_ARENA_ITEM_VIRTUAL (item, render) (item, &carea, dpb, flags);
 645       if (state & NR_ARENA_ITEM_STATE_INVALID) {
 646         /* Clean up and return error */
 647         if (dpb != pb) nr_pixblock_release (dpb);
 648         item->state |= NR_ARENA_ITEM_STATE_INVALID;
 649         return item->state;
 650       }
 651       dpb->empty = FALSE;
 652     }
 653
 654     if (dpb != pb) {
 655       /* Have to blit from cache */
 656       nr_blit_pixblock_pixblock (pb, dpb);
 657       nr_pixblock_release (dpb);
 658       pb->empty = FALSE;
 659       item->state |= NR_ARENA_ITEM_STATE_IMAGE;
 660     }
 661   }
 662         return item->state | NR_ARENA_ITEM_STATE_RENDER;
 663 }
 664
 665 unsigned int
 666 nr_arena_item_invoke_clip (NRArenaItem *item, NRRectL *area, NRPixBlock *pb)
 667 {
 668         nr_return_val_if_fail (item != NULL, NR_ARENA_ITEM_STATE_INVALID);
 669         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NR_ARENA_ITEM_STATE_INVALID);
 670         /* we originally short-circuited if the object state included
 671          * NR_ARENA_ITEM_STATE_CLIP (and showed a warning on the console);
 672          * anyone know why we stopped doing so?
 673          */
 674         nr_return_val_if_fail ((pb->area.x1 - pb->area.x0) >= (area->x1 - area->x0), NR_ARENA_ITEM_STATE_INVALID);
 675         nr_return_val_if_fail ((pb->area.y1 - pb->area.y0) >= (area->y1 - area->y0), NR_ARENA_ITEM_STATE_INVALID);
 676
 677 #ifdef NR_ARENA_ITEM_VERBOSE
 678         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);
 679 #endif
 680
 681         if (item->visible && nr_rect_l_test_intersect (area, &item->bbox)) {
 682                 /* Need render that item */
 683                 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->clip) {
 684                         return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS(item))->clip (item, area, pb);
 685                 }
 686         }
 687
 688         return item->state;
 689 }
 690
 691 NRArenaItem *
 692 nr_arena_item_invoke_pick (NRArenaItem *item, NR::Point p, double delta, unsigned int sticky)
 693 {
 694         nr_return_val_if_fail (item != NULL, NULL);
 695         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 696
 697         // Sometimes there's no BBOX in item->state, reason unknown (bug 992817); I made this not an assert to remove the warning
 698         if (!(item->state & NR_ARENA_ITEM_STATE_BBOX) || !(item->state & NR_ARENA_ITEM_STATE_PICK))
 699                 return NULL;
 700
 701         if (!sticky && !(item->visible && item->sensitive)) return NULL;
 702
 703         // TODO: rewrite using NR::Rect
 704         const double x = p[NR::X];
 705         const double y = p[NR::Y];
 706
 707         if (((x + delta) >= item->bbox.x0) &&
 708             ((x - delta) <  item->bbox.x1) &&
 709             ((y + delta) >= item->bbox.y0) &&
 710             ((y - delta) <  item->bbox.y1)) {
 711                 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick)
 712                         return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick (item, p, delta, sticky);
 713         }
 714
 715         return NULL;
 716 }
 717
 718 void
 719 nr_arena_item_request_update (NRArenaItem *item, unsigned int reset, unsigned int propagate)
 720 {
 721         nr_return_if_fail (item != NULL);
 722         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 723         nr_return_if_fail (!(reset & NR_ARENA_ITEM_STATE_INVALID));
 724
 725         if (propagate && !item->propagate) item->propagate = TRUE;
 726
 727         if (item->state & reset) {
 728                 item->state &= ~reset;
 729                 if (item->parent) {
 730                         nr_arena_item_request_update (item->parent, reset, FALSE);
 731                 } else {
 732                         nr_arena_request_update (item->arena, item);
 733                 }
 734         }
 735 }
 736
 737 void
 738 nr_arena_item_request_render (NRArenaItem *item)
 739 {
 740         nr_return_if_fail (item != NULL);
 741         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 742
 743         nr_arena_request_render_rect (item->arena, &item->bbox);
 744 }
 745
 746 /* Public */
 747
 748 NRArenaItem *
 749 nr_arena_item_unparent (NRArenaItem *item)
 750 {
 751         nr_return_val_if_fail (item != NULL, NULL);
 752         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 753
 754         nr_arena_item_request_render (item);
 755
 756         if (item->parent) {
 757                 nr_arena_item_remove_child (item->parent, item);
 758         }
 759
 760         return NULL;
 761 }
 762
 763 void
 764 nr_arena_item_append_child (NRArenaItem *parent, NRArenaItem *child)
 765 {
 766         nr_return_if_fail (parent != NULL);
 767         nr_return_if_fail (NR_IS_ARENA_ITEM (parent));
 768         nr_return_if_fail (child != NULL);
 769         nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 770         nr_return_if_fail (parent->arena == child->arena);
 771         nr_return_if_fail (child->parent == NULL);
 772         nr_return_if_fail (child->prev == NULL);
 773         nr_return_if_fail (child->next == NULL);
 774
 775         nr_arena_item_add_child (parent, child, nr_arena_item_last_child (parent));
 776 }
 777
 778 void
 779 nr_arena_item_set_transform(NRArenaItem *item, NR::Matrix const &transform)
 780 {
 781         NRMatrix const t(transform);
 782         nr_arena_item_set_transform(item, &t);
 783 }
 784
 785 void
 786 nr_arena_item_set_transform(NRArenaItem *item, NRMatrix const *transform)
 787 {
 788         const NRMatrix *ms, *md;
 789
 790         nr_return_if_fail (item != NULL);
 791         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 792
 793         if (!transform && !item->transform) return;
 794
 795         md = (item->transform) ? item->transform : &NR_MATRIX_IDENTITY;
 796         ms = (transform) ? transform : &NR_MATRIX_IDENTITY;
 797
 798         if (!NR_MATRIX_DF_TEST_CLOSE (md, ms, NR_EPSILON)) {
 799                 nr_arena_item_request_render (item);
 800                 if (!transform || nr_matrix_test_identity (transform, NR_EPSILON)) {
 801                         /* Set to identity affine */
 802                         if (item->transform) nr_free (item->transform);
 803                         item->transform = NULL;
 804                 } else {
 805                         if (!item->transform) item->transform = nr_new (NRMatrix, 1);
 806                         *item->transform = *transform;
 807                 }
 808                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 809         }
 810 }
 811
 812 void
 813 nr_arena_item_set_opacity (NRArenaItem *item, double opacity)
 814 {
 815         nr_return_if_fail (item != NULL);
 816         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 817
 818         nr_arena_item_request_render (item);
 819
 820         item->opacity = (unsigned int) (opacity * 255.9999);
 821 }
 822
 823 void
 824 nr_arena_item_set_sensitive (NRArenaItem *item, unsigned int sensitive)
 825 {
 826         nr_return_if_fail (item != NULL);
 827         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 828
 829         /* fixme: mess with pick/repick... */
 830
 831         item->sensitive = sensitive;
 832 }
 833
 834 void
 835 nr_arena_item_set_visible (NRArenaItem *item, unsigned int visible)
 836 {
 837         nr_return_if_fail (item != NULL);
 838         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 839
 840         item->visible = visible;
 841
 842         nr_arena_item_request_render (item);
 843 }
 844
 845 void
 846 nr_arena_item_set_clip (NRArenaItem *item, NRArenaItem *clip)
 847 {
 848         nr_return_if_fail (item != NULL);
 849         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 850         nr_return_if_fail (!clip || NR_IS_ARENA_ITEM (clip));
 851
 852         if (clip != item->clip) {
 853                 nr_arena_item_request_render (item);
 854                 if (item->clip) item->clip = nr_arena_item_detach_unref (item, item->clip);
 855                 if (clip) item->clip = nr_arena_item_attach_ref (item, clip, NULL, NULL);
 856                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 857         }
 858 }
 859
 860 void
 861 nr_arena_item_set_mask (NRArenaItem *item, NRArenaItem *mask)
 862 {
 863         nr_return_if_fail (item != NULL);
 864         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 865         nr_return_if_fail (!mask || NR_IS_ARENA_ITEM (mask));
 866
 867         if (mask != item->mask) {
 868                 nr_arena_item_request_render (item);
 869                 if (item->mask) item->mask = nr_arena_item_detach_unref (item, item->mask);
 870                 if (mask) item->mask = nr_arena_item_attach_ref (item, mask, NULL, NULL);
 871                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 872         }
 873 }
 874
 875 void
 876 nr_arena_item_set_order (NRArenaItem *item, int order)
 877 {
 878         NRArenaItem *children, *child, *ref;
 879         int pos;
 880
 881         nr_return_if_fail (item != NULL);
 882         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 883
 884         if (!item->parent) return;
 885
 886         children = nr_arena_item_children (item->parent);
 887
 888         ref = NULL;
 889         pos = 0;
 890         for (child = children; child != NULL; child = child->next) {
 891                 if (pos >= order) break;
 892                 if (child != item) {
 893                         ref = child;
 894                         pos += 1;
 895                 }
 896         }
 897
 898         nr_arena_item_set_child_position (item->parent, item, ref);
 899 }
 900
 901 /* Helpers */
 902
 903 NRArenaItem *
 904 nr_arena_item_attach_ref (NRArenaItem *parent, NRArenaItem *child, NRArenaItem *prev, NRArenaItem *next)
 905 {
 906         nr_return_val_if_fail (parent != NULL, NULL);
 907         nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 908         nr_return_val_if_fail (child != NULL, NULL);
 909         nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 910         nr_return_val_if_fail (child->parent == NULL, NULL);
 911         nr_return_val_if_fail (child->prev == NULL, NULL);
 912         nr_return_val_if_fail (child->next == NULL, NULL);
 913         nr_return_val_if_fail (!prev || NR_IS_ARENA_ITEM (prev), NULL);
 914         nr_return_val_if_fail (!prev || (prev->parent == parent), NULL);
 915         nr_return_val_if_fail (!prev || (prev->next == next), NULL);
 916         nr_return_val_if_fail (!next || NR_IS_ARENA_ITEM (next), NULL);
 917         nr_return_val_if_fail (!next || (next->parent == parent), NULL);
 918         nr_return_val_if_fail (!next || (next->prev == prev), NULL);
 919
 920         child->parent = parent;
 921         child->prev = prev;
 922         child->next = next;
 923
 924         if (prev) prev->next = child;
 925         if (next) next->prev = child;
 926
 927         return child;
 928 }
 929
 930 NRArenaItem *
 931 nr_arena_item_detach_unref (NRArenaItem *parent, NRArenaItem *child)
 932 {
 933         NRArenaItem *prev, *next;
 934
 935         nr_return_val_if_fail (parent != NULL, NULL);
 936         nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 937         nr_return_val_if_fail (child != NULL, NULL);
 938         nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 939         nr_return_val_if_fail (child->parent == parent, NULL);
 940
 941         prev = child->prev;
 942         next = child->next;
 943
 944         child->parent = NULL;
 945         child->prev = NULL;
 946         child->next = NULL;
 947
 948         if (prev) prev->next = next;
 949         if (next) next->prev = prev;
 950
 951         return next;
 952 }
 953
 954 /*
 955  *
 956  * caches
 957  *
 958  */
 959
 960 #ifdef arena_item_tile_cache
 961 typedef struct cache_entry {
 962   int             key;
 963   double          score;
 964   NRArenaItem*    owner;
 965   int             th,tv;
 966   int             prev,next;
 967   NRPixBlock      ipb;
 968   bool            hasMask;
 969   NRPixBlock      mpb;
 970 } cache_entry;
 971
 972 int hash_max=2048,hash_fill=1024;
 973
 974 int            *keys=NULL;
 975 int            nbCch=0;
 976
 977 int            nbEnt=0,maxEnt=0;
 978 cache_entry*   entries=NULL;
 979
 980 //#define tile_cache_stats
 981 #ifdef tile_cache_stats
 982 double         hits=0,misses=0;
 983 int            hitMissCount=0;
 984 #endif
 985
 986 int hash_that(NRArenaItem* owner,int th,int tv)
 987 {
 988   int res=GPOINTER_TO_INT(owner);
 989   res*=17;
 990   res+=th;
 991   res*=59;
 992   res+=tv;
 993   res*=217;
 994   if ( res < 0 ) res=-res;
 995   res%=hash_max;
 996   return res;
 997 }
 998
 999 bool  test_cache(NRArenaItem* owner,int th,int tv,NRPixBlock &ipb,NRPixBlock &mpb,bool &hasMask)
1000 {
1001   if ( keys == NULL ) {
1002     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1003     hash_fill=(hash_max*3)/4;
1004     keys=(int*)malloc(hash_max*sizeof(int));
1005     for (int i=0;i<hash_max;i++) keys[i]=-1;
1006   }
1007   int key=hash_that(owner,th,tv);
1008   if ( keys[key] < 0 ) {
1009 #ifdef tile_cache_stats
1010     misses+=1.0;
1011 #endif
1012     return false;
1013   }
1014   int cur=keys[key];
1015   while ( cur >= 0 && cur < nbEnt ) {
1016     if ( entries[cur].owner == owner && entries[cur].th == th && entries[cur].tv == tv ) {
1017       hasMask=entries[cur].hasMask;
1018       ipb=entries[cur].ipb;
1019       mpb=entries[cur].mpb;
1020 #ifdef tile_cache_stats
1021       hits+=1.0;
1022 #endif
1023       return true;
1024     }
1025     cur=entries[cur].next;
1026   }
1027 #ifdef tile_cache_stats
1028   misses+=1.0;
1029 #endif
1030   return false;
1031 }
1032 void  remove_one_cache(int no)
1033 {
1034   if ( no < 0 || no >= nbEnt ) return;
1035
1036   nr_pixblock_release(&entries[no].ipb);
1037   if ( entries[no].hasMask ) nr_pixblock_release(&entries[no].mpb);
1038
1039   if ( entries[no].prev >= 0 ) entries[entries[no].prev].next=entries[no].next;
1040   if ( entries[no].next >= 0 ) entries[entries[no].next].prev=entries[no].prev;
1041   if ( entries[no].prev < 0 ) keys[entries[no].key]=entries[no].next;
1042   entries[no].prev=entries[no].next=entries[no].key=-1;
1043
1044   if ( no == nbEnt-1 ) {
1045     nbEnt--;
1046     return;
1047   }
1048   entries[no]=entries[--nbEnt];
1049   if ( entries[no].prev >= 0 ) entries[entries[no].prev].next=no;
1050   if ( entries[no].next >= 0 ) entries[entries[no].next].prev=no;
1051   if ( entries[no].prev < 0 ) keys[entries[no].key]=no;
1052 }
1053 void  remove_caches(NRArenaItem* owner)
1054 {
1055   if ( keys == NULL ) {
1056     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1057     hash_fill=(hash_max*3)/4;
1058     keys=(int*)malloc(hash_max*sizeof(int));
1059     for (int i=0;i<hash_max;i++) keys[i]=-1;
1060   }
1061   for (int i=nbEnt-1;i>=0;i--) {
1062     if ( entries[i].owner == owner ) {
1063       remove_one_cache(i);
1064     }
1065   }
1066 }
1067 void  age_cache(void)
1068 {
1069   for (int i=0;i<nbEnt;i++) entries[i].score*=0.95;
1070 }
1071 bool  insert_cache(NRArenaItem* owner,int th,int tv,NRPixBlock *ipb,NRPixBlock *mpb,double activity,double duration)
1072 {
1073   if ( keys == NULL ) {
1074     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1075     hash_fill=(hash_max*3)/4;
1076     keys=(int*)malloc(hash_max*sizeof(int));
1077     for (int i=0;i<hash_max;i++) keys[i]=-1;
1078   }
1079   for (int i=0;i<nbEnt;i++) entries[i].score*=0.95;
1080 #ifdef tile_cache_stats
1081   hits*=0.95;
1082   misses*=0.95;
1083   hitMissCount++;
1084   if ( hitMissCount > 100 ) {
1085     hitMissCount=0;
1086     printf("hit/miss = %f  used/total=%i/%i\n",(misses>0.001)?hits/misses:100000.0,nbEnt,hash_max); // localizing ok
1087   }
1088 #endif
1089   int    key=hash_that(owner,th,tv);
1090   double nScore=/*activity**/duration;
1091
1092   if ( keys[key] >= 0 ) {
1093     int cur=keys[key];
1094     while ( cur >= 0 && cur < nbEnt ) {
1095       if ( entries[cur].owner == owner && entries[cur].th == th && entries[cur].tv == tv ) {
1096         remove_one_cache(cur);
1097         break;
1098       }
1099       cur=entries[cur].next;
1100     }
1101   }
1102
1103   bool doAdd=false;
1104   if ( nbEnt < hash_fill ) {
1105     doAdd=true;
1106   } else {
1107     double    worstS=entries[0].score;
1108     int       worstE=0;
1109     for (int i=1;i<nbEnt;i++) {
1110       if ( entries[i].score < worstS ) {
1111         worstS=entries[i].score;
1112         worstE=i;
1113       }
1114     }
1115     if ( worstS < nScore ) {
1116       doAdd=true;
1117       remove_one_cache(worstE);
1118     }
1119   }
1120   if ( doAdd == false ) return false;
1121   if ( nbEnt >= maxEnt ) {
1122     maxEnt=2*nbEnt+1;
1123     entries=(cache_entry*)realloc(entries,maxEnt*sizeof(cache_entry));
1124   }
1125   entries[nbEnt].key=key;
1126   entries[nbEnt].score=nScore;
1127   entries[nbEnt].owner=owner;
1128   entries[nbEnt].th=th;
1129   entries[nbEnt].tv=tv;
1130   entries[nbEnt].prev=entries[nbEnt].next=-1;
1131   entries[nbEnt].ipb=*ipb;
1132   if ( mpb ) {
1133     entries[nbEnt].hasMask=true;
1134     entries[nbEnt].mpb=*mpb;
1135   } else {
1136     entries[nbEnt].hasMask=false;
1137   }
1138   entries[nbEnt].next=keys[key];
1139   if ( entries[nbEnt].next >= 0 ) entries[entries[nbEnt].next].prev=nbEnt;
1140   keys[key]=nbEnt;
1141
1142   nbEnt++;
1143   return true;
1144 }
1145 #endif
1146
1147
1148
1149