src/display/canvas-arena.cpp

   1 #define __SP_CANVAS_ARENA_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 #include <libnr/nr-blit.h>
  16 #include <gtk/gtksignal.h>
  17
  18 #include <display/display-forward.h>
  19 #include <display/sp-canvas-util.h>
  20 #include <helper/sp-marshal.h>
  21 #include <display/nr-arena.h>
  22 #include <display/nr-arena-group.h>
  23 #include <display/canvas-arena.h>
  24
  25 enum {
  26         ARENA_EVENT,
  27         LAST_SIGNAL
  28 };
  29
  30 static void sp_canvas_arena_class_init(SPCanvasArenaClass *klass);
  31 static void sp_canvas_arena_init(SPCanvasArena *group);
  32 static void sp_canvas_arena_destroy(GtkObject *object);
  33
  34 static void sp_canvas_arena_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags);
  35 static void sp_canvas_arena_render (SPCanvasItem *item, SPCanvasBuf *buf);
  36 static double sp_canvas_arena_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item);
  37 static gint sp_canvas_arena_event (SPCanvasItem *item, GdkEvent *event);
  38
  39 static gint sp_canvas_arena_send_event (SPCanvasArena *arena, GdkEvent *event);
  40
  41 static void sp_canvas_arena_request_update (NRArena *arena, NRArenaItem *item, void *data);
  42 static void sp_canvas_arena_request_render (NRArena *arena, NRRectL *area, void *data);
  43
  44 NRArenaEventVector carenaev = {
  45         {NULL},
  46         sp_canvas_arena_request_update,
  47         sp_canvas_arena_request_render
  48 };
  49
  50 static SPCanvasItemClass *parent_class;
  51 static guint signals[LAST_SIGNAL] = {0};
  52
  53 GtkType
  54 sp_canvas_arena_get_type (void)
  55 {
  56         static GtkType type = 0;
  57         if (!type) {
  58                 GtkTypeInfo info = {
  59                         "SPCanvasArena",
  60                         sizeof (SPCanvasArena),
  61                         sizeof (SPCanvasArenaClass),
  62                         (GtkClassInitFunc) sp_canvas_arena_class_init,
  63                         (GtkObjectInitFunc) sp_canvas_arena_init,
  64                         NULL, NULL, NULL
  65                 };
  66                 type = gtk_type_unique (SP_TYPE_CANVAS_ITEM, &info);
  67         }
  68         return type;
  69 }
  70
  71 static void
  72 sp_canvas_arena_class_init (SPCanvasArenaClass *klass)
  73 {
  74         GtkObjectClass *object_class;
  75         SPCanvasItemClass *item_class;
  76
  77         object_class = (GtkObjectClass *) klass;
  78         item_class = (SPCanvasItemClass *) klass;
  79
  80         parent_class = (SPCanvasItemClass*)gtk_type_class (SP_TYPE_CANVAS_ITEM);
  81
  82         signals[ARENA_EVENT] = gtk_signal_new ("arena_event",
  83                                                GTK_RUN_LAST,
  84                                                GTK_CLASS_TYPE(object_class),
  85                                                GTK_SIGNAL_OFFSET (SPCanvasArenaClass, arena_event),
  86                                                sp_marshal_INT__POINTER_POINTER,
  87                                                GTK_TYPE_INT, 2, GTK_TYPE_POINTER, GTK_TYPE_POINTER);
  88
  89         object_class->destroy = sp_canvas_arena_destroy;
  90
  91         item_class->update = sp_canvas_arena_update;
  92         item_class->render = sp_canvas_arena_render;
  93         item_class->point = sp_canvas_arena_point;
  94         item_class->event = sp_canvas_arena_event;
  95 }
  96
  97 static void
  98 sp_canvas_arena_init (SPCanvasArena *arena)
  99 {
 100         arena->sticky = FALSE;
 101
 102         arena->arena = NRArena::create();
 103         arena->root = NRArenaGroup::create(arena->arena);
 104         nr_arena_group_set_transparent (NR_ARENA_GROUP (arena->root), TRUE);
 105
 106 #ifdef arena_item_tile_cache
 107   arena->root->skipCaching=true;
 108 #endif
 109
 110         arena->active = NULL;
 111
 112         nr_active_object_add_listener ((NRActiveObject *) arena->arena, (NRObjectEventVector *) &carenaev, sizeof (carenaev), arena);
 113 }
 114
 115 static void
 116 sp_canvas_arena_destroy (GtkObject *object)
 117 {
 118         SPCanvasArena *arena = SP_CANVAS_ARENA (object);
 119
 120         if (arena->active) {
 121                 nr_object_unref ((NRObject *) arena->active);
 122                 arena->active = NULL;
 123         }
 124
 125         if (arena->root) {
 126                 nr_arena_item_unref (arena->root);
 127                 arena->root = NULL;
 128         }
 129
 130         if (arena->arena) {
 131                 nr_active_object_remove_listener_by_data ((NRActiveObject *) arena->arena, arena);
 132
 133                 nr_object_unref ((NRObject *) arena->arena);
 134                 arena->arena = NULL;
 135         }
 136
 137         if (GTK_OBJECT_CLASS (parent_class)->destroy)
 138                 (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 139 }
 140
 141 static void
 142 sp_canvas_arena_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
 143 {
 144         SPCanvasArena *arena = SP_CANVAS_ARENA (item);
 145
 146         if (((SPCanvasItemClass *) parent_class)->update)
 147                 (* ((SPCanvasItemClass *) parent_class)->update) (item, affine, flags);
 148
 149         arena->gc.transform = affine;
 150
 151         guint reset;
 152         reset = (flags & SP_CANVAS_UPDATE_AFFINE)? NR_ARENA_ITEM_STATE_ALL : NR_ARENA_ITEM_STATE_NONE;
 153
 154         nr_arena_item_invoke_update (arena->root, NULL, &arena->gc, NR_ARENA_ITEM_STATE_ALL, reset);
 155
 156         item->x1 = arena->root->bbox.x0 - 1;
 157         item->y1 = arena->root->bbox.y0 - 1;
 158         item->x2 = arena->root->bbox.x1 + 1;
 159         item->y2 = arena->root->bbox.y1 + 1;
 160
 161         if (arena->cursor) {
 162                 /* Mess with enter/leave notifiers */
 163                 NRArenaItem *new_arena = nr_arena_item_invoke_pick (arena->root, arena->c, arena->arena->delta, arena->sticky);
 164                 if (new_arena != arena->active) {
 165                         GdkEventCrossing ec;
 166                         ec.window = GTK_WIDGET (item->canvas)->window;
 167                         ec.send_event = TRUE;
 168                         ec.subwindow = ec.window;
 169                         ec.time = GDK_CURRENT_TIME;
 170                         ec.x = arena->c[NR::X];
 171                         ec.y = arena->c[NR::Y];
 172                         /* fixme: */
 173                         if (arena->active) {
 174                                 ec.type = GDK_LEAVE_NOTIFY;
 175                                 sp_canvas_arena_send_event (arena, (GdkEvent *) &ec);
 176                         }
 177                         /* fixme: This is not optimal - better track ::destroy (Lauris) */
 178                         if (arena->active) nr_object_unref ((NRObject *) arena->active);
 179                         arena->active = new_arena;
 180                         if (arena->active) nr_object_ref ((NRObject *) arena->active);
 181                         if (arena->active) {
 182                                 ec.type = GDK_ENTER_NOTIFY;
 183                                 sp_canvas_arena_send_event (arena, (GdkEvent *) &ec);
 184                         }
 185                 }
 186         }
 187 }
 188
 189 #ifdef arena_item_tile_cache
 190 extern void age_cache(void);
 191 #endif
 192
 193 static void
 194 sp_canvas_arena_render (SPCanvasItem *item, SPCanvasBuf *buf)
 195 {
 196         gint bw, bh, sw, sh;
 197         gint x, y;
 198
 199         SPCanvasArena *arena = SP_CANVAS_ARENA (item);
 200
 201         nr_arena_item_invoke_update (arena->root, NULL, &arena->gc,
 202                                      NR_ARENA_ITEM_STATE_BBOX | NR_ARENA_ITEM_STATE_RENDER,
 203                                      NR_ARENA_ITEM_STATE_NONE);
 204
 205         sp_canvas_prepare_buffer(buf);
 206
 207 #ifdef arena_item_tile_cache
 208   age_cache();
 209 #endif
 210         bw = buf->rect.x1 - buf->rect.x0;
 211         bh = buf->rect.y1 - buf->rect.y0;
 212         if ((bw < 1) || (bh < 1)) return;
 213
 214         if (arena->arena->rendermode != RENDERMODE_OUTLINE) { // use 256K as a compromise to not slow down gradients
 215                 /* 256K is the cached buffer and we need 4 channels */
 216                 if (bw * bh < 65536) { // 256K/4
 217                         /* We can go with single buffer */
 218                         sw = bw;
 219                         sh = bh;
 220                 } else if (bw <= 4096) {
 221                         /* Go with row buffer */
 222                         sw = bw;
 223                         sh = 65536 / bw;
 224                 } else if (bh <= 4096) {
 225                         /* Go with column buffer */
 226                         sw = 65536 / bh;
 227                         sh = bh;
 228                 } else {
 229                         sw = 256;
 230                         sh = 256;
 231                 }
 232         } else { // paths only, so 1M works faster
 233                 /* 1M is the cached buffer and we need 4 channels */
 234                 if (bw * bh < 262144) { // 1M/4
 235                         /* We can go with single buffer */
 236                         sw = bw;
 237                         sh = bh;
 238                 } else if (bw <= 8192) {
 239                         /* Go with row buffer */
 240                         sw = bw;
 241                         sh = 262144 / bw;
 242                 } else if (bh <= 8192) {
 243                         /* Go with column buffer */
 244                         sw = 262144 / bh;
 245                         sh = bh;
 246                 } else {
 247                         sw = 512;
 248                         sh = 512;
 249                 }
 250         }
 251
 252 /* fixme: RGB transformed bitmap blit is not implemented (Lauris) */
 253 /* And even if it would be, unless it uses MMX there is little reason to go RGB */
 254 #define STRICT_RGBA
 255
 256         for (y = buf->rect.y0; y < buf->rect.y1; y += sh) {
 257                 for (x = buf->rect.x0; x < buf->rect.x1; x += sw) {
 258                         NRRectL area;
 259 #ifdef STRICT_RGBA
 260                         NRPixBlock pb;
 261 #endif
 262                         NRPixBlock cb;
 263
 264                         area.x0 = x;
 265                         area.y0 = y;
 266                         area.x1 = MIN (x + sw, buf->rect.x1);
 267                         area.y1 = MIN (y + sh, buf->rect.y1);
 268
 269 #ifdef STRICT_RGBA
 270                         nr_pixblock_setup_fast (&pb, NR_PIXBLOCK_MODE_R8G8B8A8P, area.x0, area.y0, area.x1, area.y1, TRUE);
 271                         /* fixme: */
 272                         pb.empty = FALSE;
 273 #endif
 274
 275                         nr_pixblock_setup_extern (&cb, NR_PIXBLOCK_MODE_R8G8B8, area.x0, area.y0, area.x1, area.y1,
 276                                                   buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + 3 * (x - buf->rect.x0),
 277                                                   buf->buf_rowstride,
 278                                                   FALSE, FALSE);
 279
 280 #ifdef STRICT_RGBA
 281             pb.visible_area = buf->visible_rect;
 282                         if (pb.data.px != NULL) {
 283                             nr_arena_item_invoke_render (arena->root, &area, &pb, 0);
 284                             nr_blit_pixblock_pixblock (&cb, &pb);
 285                         }
 286                         nr_pixblock_release (&pb);
 287 #else
 288             cb.visible_area = buf->visible_rect;
 289                         nr_arena_item_invoke_render (arena->root, &area, &cb, 0);
 290 #endif
 291
 292                         nr_pixblock_release (&cb);
 293                 }
 294         }
 295 }
 296
 297 static double
 298 sp_canvas_arena_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item)
 299 {
 300         SPCanvasArena *arena = SP_CANVAS_ARENA (item);
 301
 302         nr_arena_item_invoke_update (arena->root, NULL, &arena->gc,
 303                                      NR_ARENA_ITEM_STATE_BBOX | NR_ARENA_ITEM_STATE_PICK,
 304                                      NR_ARENA_ITEM_STATE_NONE);
 305
 306         NRArenaItem *picked = nr_arena_item_invoke_pick (arena->root, p, arena->arena->delta, arena->sticky);
 307
 308         arena->picked = picked;
 309
 310         if (picked) {
 311                 *actual_item = item;
 312                 return 0.0;
 313         }
 314
 315         return 1e18;
 316 }
 317
 318 static gint
 319 sp_canvas_arena_event (SPCanvasItem *item, GdkEvent *event)
 320 {
 321         NRArenaItem *new_arena;
 322         /* fixme: This sucks, we have to handle enter/leave notifiers */
 323
 324         SPCanvasArena *arena = SP_CANVAS_ARENA (item);
 325
 326         gint ret = FALSE;
 327
 328         switch (event->type) {
 329         case GDK_ENTER_NOTIFY:
 330                 if (!arena->cursor) {
 331                         if (arena->active) {
 332                                 //g_warning ("Cursor entered to arena with already active item");
 333                                 nr_object_unref ((NRObject *) arena->active);
 334                         }
 335                         arena->cursor = TRUE;
 336
 337                         /* TODO ... event -> arena transform? */
 338                         arena->c = NR::Point(event->crossing.x, event->crossing.y);
 339
 340                         /* fixme: Not sure abut this, but seems the right thing (Lauris) */
 341                         nr_arena_item_invoke_update (arena->root, NULL, &arena->gc, NR_ARENA_ITEM_STATE_PICK, NR_ARENA_ITEM_STATE_NONE);
 342                         arena->active = nr_arena_item_invoke_pick (arena->root, arena->c, arena->arena->delta, arena->sticky);
 343                         if (arena->active) nr_object_ref ((NRObject *) arena->active);
 344                         ret = sp_canvas_arena_send_event (arena, event);
 345                 }
 346                 break;
 347         case GDK_LEAVE_NOTIFY:
 348                 if (arena->cursor) {
 349                         ret = sp_canvas_arena_send_event (arena, event);
 350                         if (arena->active) nr_object_unref ((NRObject *) arena->active);
 351                         arena->active = NULL;
 352                         arena->cursor = FALSE;
 353                 }
 354                 break;
 355         case GDK_MOTION_NOTIFY:
 356                 /* TODO ... event -> arena transform? */
 357                 arena->c = NR::Point(event->motion.x, event->motion.y);
 358
 359                 /* fixme: Not sure abut this, but seems the right thing (Lauris) */
 360                 nr_arena_item_invoke_update (arena->root, NULL, &arena->gc, NR_ARENA_ITEM_STATE_PICK, NR_ARENA_ITEM_STATE_NONE);
 361                 new_arena = nr_arena_item_invoke_pick (arena->root, arena->c, arena->arena->delta, arena->sticky);
 362                 if (new_arena != arena->active) {
 363                         GdkEventCrossing ec;
 364                         ec.window = event->motion.window;
 365                         ec.send_event = event->motion.send_event;
 366                         ec.subwindow = event->motion.window;
 367                         ec.time = event->motion.time;
 368                         ec.x = event->motion.x;
 369                         ec.y = event->motion.y;
 370                         /* fixme: */
 371                         if (arena->active) {
 372                                 ec.type = GDK_LEAVE_NOTIFY;
 373                                 ret = sp_canvas_arena_send_event (arena, (GdkEvent *) &ec);
 374                         }
 375                         if (arena->active) nr_object_unref ((NRObject *) arena->active);
 376                         arena->active = new_arena;
 377                         if (arena->active) nr_object_ref ((NRObject *) arena->active);
 378                         if (arena->active) {
 379                                 ec.type = GDK_ENTER_NOTIFY;
 380                                 ret = sp_canvas_arena_send_event (arena, (GdkEvent *) &ec);
 381                         }
 382                 }
 383                 ret = sp_canvas_arena_send_event (arena, event);
 384                 break;
 385         default:
 386                 /* Just send event */
 387                 ret = sp_canvas_arena_send_event (arena, event);
 388                 break;
 389         }
 390
 391         return ret;
 392 }
 393
 394 static gint
 395 sp_canvas_arena_send_event (SPCanvasArena *arena, GdkEvent *event)
 396 {
 397         gint ret = FALSE;
 398
 399         /* Send event to arena */
 400         gtk_signal_emit (GTK_OBJECT (arena), signals[ARENA_EVENT], arena->active, event, &ret);
 401
 402         return ret;
 403 }
 404
 405 static void
 406 sp_canvas_arena_request_update (NRArena *arena, NRArenaItem *item, void *data)
 407 {
 408         sp_canvas_item_request_update (SP_CANVAS_ITEM (data));
 409 }
 410
 411 static void
 412 sp_canvas_arena_request_render (NRArena *arena, NRRectL *area, void *data)
 413 {
 414         sp_canvas_request_redraw (SP_CANVAS_ITEM (data)->canvas, area->x0, area->y0, area->x1, area->y1);
 415 }
 416
 417 void
 418 sp_canvas_arena_set_pick_delta (SPCanvasArena *ca, gdouble delta)
 419 {
 420         g_return_if_fail (ca != NULL);
 421         g_return_if_fail (SP_IS_CANVAS_ARENA (ca));
 422
 423         /* fixme: repick? */
 424         ca->delta = delta;
 425 }
 426
 427 void
 428 sp_canvas_arena_set_sticky (SPCanvasArena *ca, gboolean sticky)
 429 {
 430         g_return_if_fail (ca != NULL);
 431         g_return_if_fail (SP_IS_CANVAS_ARENA (ca));
 432
 433         /* fixme: repick? */
 434         ca->sticky = sticky;
 435 }
 436
 437 void
 438 sp_canvas_arena_render_pixblock (SPCanvasArena *ca, NRPixBlock *pb)
 439 {
 440         NRRectL area;
 441
 442         g_return_if_fail (ca != NULL);
 443         g_return_if_fail (SP_IS_CANVAS_ARENA (ca));
 444
 445         /* fixme: */
 446         pb->empty = FALSE;
 447
 448         area.x0 = pb->area.x0;
 449         area.y0 = pb->area.y0;
 450         area.x1 = pb->area.x1;
 451         area.y1 = pb->area.y1;
 452
 453         nr_arena_item_invoke_render (ca->root, &area, pb, 0);
 454 }
 455