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 render %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         return item->state;
 688 }
 689
 690 NRArenaItem *
 691 nr_arena_item_invoke_pick (NRArenaItem *item, NR::Point p, double delta, unsigned int sticky)
 692 {
 693         nr_return_val_if_fail (item != NULL, NULL);
 694         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 695
 696         // Sometimes there's no BBOX in item->state, reason unknown (bug 992817); I made this not an assert to remove the warning
 697         if (!(item->state & NR_ARENA_ITEM_STATE_BBOX) || !(item->state & NR_ARENA_ITEM_STATE_PICK))
 698                 return NULL;
 699
 700         if (!sticky && !(item->visible && item->sensitive)) return NULL;
 701
 702         // TODO: rewrite using NR::Rect
 703         const double x = p[NR::X];
 704         const double y = p[NR::Y];
 705
 706         if (((x + delta) >= item->bbox.x0) &&
 707             ((x - delta) <  item->bbox.x1) &&
 708             ((y + delta) >= item->bbox.y0) &&
 709             ((y - delta) <  item->bbox.y1)) {
 710                 if (((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick)
 711                         return ((NRArenaItemClass *) NR_OBJECT_GET_CLASS (item))->pick (item, p, delta, sticky);
 712         }
 713
 714         return NULL;
 715 }
 716
 717 void
 718 nr_arena_item_request_update (NRArenaItem *item, unsigned int reset, unsigned int propagate)
 719 {
 720         nr_return_if_fail (item != NULL);
 721         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 722         nr_return_if_fail (!(reset & NR_ARENA_ITEM_STATE_INVALID));
 723
 724         if (propagate && !item->propagate) item->propagate = TRUE;
 725
 726         if (item->state & reset) {
 727                 item->state &= ~reset;
 728                 if (item->parent) {
 729                         nr_arena_item_request_update (item->parent, reset, FALSE);
 730                 } else {
 731                         nr_arena_request_update (item->arena, item);
 732                 }
 733         }
 734 }
 735
 736 void
 737 nr_arena_item_request_render (NRArenaItem *item)
 738 {
 739         nr_return_if_fail (item != NULL);
 740         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 741
 742         nr_arena_request_render_rect (item->arena, &item->bbox);
 743 }
 744
 745 /* Public */
 746
 747 NRArenaItem *
 748 nr_arena_item_unparent (NRArenaItem *item)
 749 {
 750         nr_return_val_if_fail (item != NULL, NULL);
 751         nr_return_val_if_fail (NR_IS_ARENA_ITEM (item), NULL);
 752
 753         nr_arena_item_request_render (item);
 754
 755         if (item->parent) {
 756                 nr_arena_item_remove_child (item->parent, item);
 757         }
 758
 759         return NULL;
 760 }
 761
 762 void
 763 nr_arena_item_append_child (NRArenaItem *parent, NRArenaItem *child)
 764 {
 765         nr_return_if_fail (parent != NULL);
 766         nr_return_if_fail (NR_IS_ARENA_ITEM (parent));
 767         nr_return_if_fail (child != NULL);
 768         nr_return_if_fail (NR_IS_ARENA_ITEM (child));
 769         nr_return_if_fail (parent->arena == child->arena);
 770         nr_return_if_fail (child->parent == NULL);
 771         nr_return_if_fail (child->prev == NULL);
 772         nr_return_if_fail (child->next == NULL);
 773
 774         nr_arena_item_add_child (parent, child, nr_arena_item_last_child (parent));
 775 }
 776
 777 void
 778 nr_arena_item_set_transform(NRArenaItem *item, NR::Matrix const &transform)
 779 {
 780         NRMatrix const t(transform);
 781         nr_arena_item_set_transform(item, &t);
 782 }
 783
 784 void
 785 nr_arena_item_set_transform(NRArenaItem *item, NRMatrix const *transform)
 786 {
 787         const NRMatrix *ms, *md;
 788
 789         nr_return_if_fail (item != NULL);
 790         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 791
 792         if (!transform && !item->transform) return;
 793
 794         md = (item->transform) ? item->transform : &NR_MATRIX_IDENTITY;
 795         ms = (transform) ? transform : &NR_MATRIX_IDENTITY;
 796
 797         if (!NR_MATRIX_DF_TEST_CLOSE (md, ms, NR_EPSILON)) {
 798                 nr_arena_item_request_render (item);
 799                 if (!transform || nr_matrix_test_identity (transform, NR_EPSILON)) {
 800                         /* Set to identity affine */
 801                         if (item->transform) nr_free (item->transform);
 802                         item->transform = NULL;
 803                 } else {
 804                         if (!item->transform) item->transform = nr_new (NRMatrix, 1);
 805                         *item->transform = *transform;
 806                 }
 807                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 808         }
 809 }
 810
 811 void
 812 nr_arena_item_set_opacity (NRArenaItem *item, double opacity)
 813 {
 814         nr_return_if_fail (item != NULL);
 815         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 816
 817         nr_arena_item_request_render (item);
 818
 819         item->opacity = (unsigned int) (opacity * 255.9999);
 820 }
 821
 822 void
 823 nr_arena_item_set_sensitive (NRArenaItem *item, unsigned int sensitive)
 824 {
 825         nr_return_if_fail (item != NULL);
 826         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 827
 828         /* fixme: mess with pick/repick... */
 829
 830         item->sensitive = sensitive;
 831 }
 832
 833 void
 834 nr_arena_item_set_visible (NRArenaItem *item, unsigned int visible)
 835 {
 836         nr_return_if_fail (item != NULL);
 837         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 838
 839         item->visible = visible;
 840
 841         nr_arena_item_request_render (item);
 842 }
 843
 844 void
 845 nr_arena_item_set_clip (NRArenaItem *item, NRArenaItem *clip)
 846 {
 847         nr_return_if_fail (item != NULL);
 848         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 849         nr_return_if_fail (!clip || NR_IS_ARENA_ITEM (clip));
 850
 851         if (clip != item->clip) {
 852                 nr_arena_item_request_render (item);
 853                 if (item->clip) item->clip = nr_arena_item_detach_unref (item, item->clip);
 854                 if (clip) item->clip = nr_arena_item_attach_ref (item, clip, NULL, NULL);
 855                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 856         }
 857 }
 858
 859 void
 860 nr_arena_item_set_mask (NRArenaItem *item, NRArenaItem *mask)
 861 {
 862         nr_return_if_fail (item != NULL);
 863         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 864         nr_return_if_fail (!mask || NR_IS_ARENA_ITEM (mask));
 865
 866         if (mask != item->mask) {
 867                 nr_arena_item_request_render (item);
 868                 if (item->mask) item->mask = nr_arena_item_detach_unref (item, item->mask);
 869                 if (mask) item->mask = nr_arena_item_attach_ref (item, mask, NULL, NULL);
 870                 nr_arena_item_request_update (item, NR_ARENA_ITEM_STATE_ALL, TRUE);
 871         }
 872 }
 873
 874 void
 875 nr_arena_item_set_order (NRArenaItem *item, int order)
 876 {
 877         NRArenaItem *children, *child, *ref;
 878         int pos;
 879
 880         nr_return_if_fail (item != NULL);
 881         nr_return_if_fail (NR_IS_ARENA_ITEM (item));
 882
 883         if (!item->parent) return;
 884
 885         children = nr_arena_item_children (item->parent);
 886
 887         ref = NULL;
 888         pos = 0;
 889         for (child = children; child != NULL; child = child->next) {
 890                 if (pos >= order) break;
 891                 if (child != item) {
 892                         ref = child;
 893                         pos += 1;
 894                 }
 895         }
 896
 897         nr_arena_item_set_child_position (item->parent, item, ref);
 898 }
 899
 900 /* Helpers */
 901
 902 NRArenaItem *
 903 nr_arena_item_attach_ref (NRArenaItem *parent, NRArenaItem *child, NRArenaItem *prev, NRArenaItem *next)
 904 {
 905         nr_return_val_if_fail (parent != NULL, NULL);
 906         nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 907         nr_return_val_if_fail (child != NULL, NULL);
 908         nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 909         nr_return_val_if_fail (child->parent == NULL, NULL);
 910         nr_return_val_if_fail (child->prev == NULL, NULL);
 911         nr_return_val_if_fail (child->next == NULL, NULL);
 912         nr_return_val_if_fail (!prev || NR_IS_ARENA_ITEM (prev), NULL);
 913         nr_return_val_if_fail (!prev || (prev->parent == parent), NULL);
 914         nr_return_val_if_fail (!prev || (prev->next == next), NULL);
 915         nr_return_val_if_fail (!next || NR_IS_ARENA_ITEM (next), NULL);
 916         nr_return_val_if_fail (!next || (next->parent == parent), NULL);
 917         nr_return_val_if_fail (!next || (next->prev == prev), NULL);
 918
 919         child->parent = parent;
 920         child->prev = prev;
 921         child->next = next;
 922
 923         if (prev) prev->next = child;
 924         if (next) next->prev = child;
 925
 926         return child;
 927 }
 928
 929 NRArenaItem *
 930 nr_arena_item_detach_unref (NRArenaItem *parent, NRArenaItem *child)
 931 {
 932         NRArenaItem *prev, *next;
 933
 934         nr_return_val_if_fail (parent != NULL, NULL);
 935         nr_return_val_if_fail (NR_IS_ARENA_ITEM (parent), NULL);
 936         nr_return_val_if_fail (child != NULL, NULL);
 937         nr_return_val_if_fail (NR_IS_ARENA_ITEM (child), NULL);
 938         nr_return_val_if_fail (child->parent == parent, NULL);
 939
 940         prev = child->prev;
 941         next = child->next;
 942
 943         child->parent = NULL;
 944         child->prev = NULL;
 945         child->next = NULL;
 946
 947         if (prev) prev->next = next;
 948         if (next) next->prev = prev;
 949
 950         return next;
 951 }
 952
 953 /*
 954  *
 955  * caches
 956  *
 957  */
 958
 959 #ifdef arena_item_tile_cache
 960 typedef struct cache_entry {
 961   int             key;
 962   double          score;
 963   NRArenaItem*    owner;
 964   int             th,tv;
 965   int             prev,next;
 966   NRPixBlock      ipb;
 967   bool            hasMask;
 968   NRPixBlock      mpb;
 969 } cache_entry;
 970
 971 int hash_max=2048,hash_fill=1024;
 972
 973 int            *keys=NULL;
 974 int            nbCch=0;
 975
 976 int            nbEnt=0,maxEnt=0;
 977 cache_entry*   entries=NULL;
 978
 979 //#define tile_cache_stats
 980 #ifdef tile_cache_stats
 981 double         hits=0,misses=0;
 982 int            hitMissCount=0;
 983 #endif
 984
 985 int hash_that(NRArenaItem* owner,int th,int tv)
 986 {
 987   int res=GPOINTER_TO_INT(owner);
 988   res*=17;
 989   res+=th;
 990   res*=59;
 991   res+=tv;
 992   res*=217;
 993   if ( res < 0 ) res=-res;
 994   res%=hash_max;
 995   return res;
 996 }
 997
 998 bool  test_cache(NRArenaItem* owner,int th,int tv,NRPixBlock &ipb,NRPixBlock &mpb,bool &hasMask)
 999 {
1000   if ( keys == NULL ) {
1001     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1002     hash_fill=(hash_max*3)/4;
1003     keys=(int*)malloc(hash_max*sizeof(int));
1004     for (int i=0;i<hash_max;i++) keys[i]=-1;
1005   }
1006   int key=hash_that(owner,th,tv);
1007   if ( keys[key] < 0 ) {
1008 #ifdef tile_cache_stats
1009     misses+=1.0;
1010 #endif
1011     return false;
1012   }
1013   int cur=keys[key];
1014   while ( cur >= 0 && cur < nbEnt ) {
1015     if ( entries[cur].owner == owner && entries[cur].th == th && entries[cur].tv == tv ) {
1016       hasMask=entries[cur].hasMask;
1017       ipb=entries[cur].ipb;
1018       mpb=entries[cur].mpb;
1019 #ifdef tile_cache_stats
1020       hits+=1.0;
1021 #endif
1022       return true;
1023     }
1024     cur=entries[cur].next;
1025   }
1026 #ifdef tile_cache_stats
1027   misses+=1.0;
1028 #endif
1029   return false;
1030 }
1031 void  remove_one_cache(int no)
1032 {
1033   if ( no < 0 || no >= nbEnt ) return;
1034
1035   nr_pixblock_release(&entries[no].ipb);
1036   if ( entries[no].hasMask ) nr_pixblock_release(&entries[no].mpb);
1037
1038   if ( entries[no].prev >= 0 ) entries[entries[no].prev].next=entries[no].next;
1039   if ( entries[no].next >= 0 ) entries[entries[no].next].prev=entries[no].prev;
1040   if ( entries[no].prev < 0 ) keys[entries[no].key]=entries[no].next;
1041   entries[no].prev=entries[no].next=entries[no].key=-1;
1042
1043   if ( no == nbEnt-1 ) {
1044     nbEnt--;
1045     return;
1046   }
1047   entries[no]=entries[--nbEnt];
1048   if ( entries[no].prev >= 0 ) entries[entries[no].prev].next=no;
1049   if ( entries[no].next >= 0 ) entries[entries[no].next].prev=no;
1050   if ( entries[no].prev < 0 ) keys[entries[no].key]=no;
1051 }
1052 void  remove_caches(NRArenaItem* owner)
1053 {
1054   if ( keys == NULL ) {
1055     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1056     hash_fill=(hash_max*3)/4;
1057     keys=(int*)malloc(hash_max*sizeof(int));
1058     for (int i=0;i<hash_max;i++) keys[i]=-1;
1059   }
1060   for (int i=nbEnt-1;i>=0;i--) {
1061     if ( entries[i].owner == owner ) {
1062       remove_one_cache(i);
1063     }
1064   }
1065 }
1066 void  age_cache(void)
1067 {
1068   for (int i=0;i<nbEnt;i++) entries[i].score*=0.95;
1069 }
1070 bool  insert_cache(NRArenaItem* owner,int th,int tv,NRPixBlock *ipb,NRPixBlock *mpb,double activity,double duration)
1071 {
1072   if ( keys == NULL ) {
1073     hash_max = prefs_get_int_attribute ("options.arenatilescachesize", "value", 2048);
1074     hash_fill=(hash_max*3)/4;
1075     keys=(int*)malloc(hash_max*sizeof(int));
1076     for (int i=0;i<hash_max;i++) keys[i]=-1;
1077   }
1078   for (int i=0;i<nbEnt;i++) entries[i].score*=0.95;
1079 #ifdef tile_cache_stats
1080   hits*=0.95;
1081   misses*=0.95;
1082   hitMissCount++;
1083   if ( hitMissCount > 100 ) {
1084     hitMissCount=0;
1085     printf("hit/miss = %f  used/total=%i/%i\n",(misses>0.001)?hits/misses:100000.0,nbEnt,hash_max); // localizing ok
1086   }
1087 #endif
1088   int    key=hash_that(owner,th,tv);
1089   double nScore=/*activity**/duration;
1090
1091   if ( keys[key] >= 0 ) {
1092     int cur=keys[key];
1093     while ( cur >= 0 && cur < nbEnt ) {
1094       if ( entries[cur].owner == owner && entries[cur].th == th && entries[cur].tv == tv ) {
1095         remove_one_cache(cur);
1096         break;
1097       }
1098       cur=entries[cur].next;
1099     }
1100   }
1101
1102   bool doAdd=false;
1103   if ( nbEnt < hash_fill ) {
1104     doAdd=true;
1105   } else {
1106     double    worstS=entries[0].score;
1107     int       worstE=0;
1108     for (int i=1;i<nbEnt;i++) {
1109       if ( entries[i].score < worstS ) {
1110         worstS=entries[i].score;
1111         worstE=i;
1112       }
1113     }
1114     if ( worstS < nScore ) {
1115       doAdd=true;
1116       remove_one_cache(worstE);
1117     }
1118   }
1119   if ( doAdd == false ) return false;
1120   if ( nbEnt >= maxEnt ) {
1121     maxEnt=2*nbEnt+1;
1122     entries=(cache_entry*)realloc(entries,maxEnt*sizeof(cache_entry));
1123   }
1124   entries[nbEnt].key=key;
1125   entries[nbEnt].score=nScore;
1126   entries[nbEnt].owner=owner;
1127   entries[nbEnt].th=th;
1128   entries[nbEnt].tv=tv;
1129   entries[nbEnt].prev=entries[nbEnt].next=-1;
1130   entries[nbEnt].ipb=*ipb;
1131   if ( mpb ) {
1132     entries[nbEnt].hasMask=true;
1133     entries[nbEnt].mpb=*mpb;
1134   } else {
1135     entries[nbEnt].hasMask=false;
1136   }
1137   entries[nbEnt].next=keys[key];
1138   if ( entries[nbEnt].next >= 0 ) entries[entries[nbEnt].next].prev=nbEnt;
1139   keys[key]=nbEnt;
1140
1141   nbEnt++;
1142   return true;
1143 }
1144 #endif
1145
1146
1147
1148