src/display/sodipodi-ctrl.cpp

   1 #define INKSCAPE_CTRL_C
   2
   3 /*
   4  * SPCtrl
   5  *
   6  * We render it by hand to reduce allocing/freeing svps & to get clean
   7  *    (non-aa) images
   8  *
   9  */
  10
  11 #include <2geom/transforms.h>
  12 #include "sp-canvas-util.h"
  13 #include "display-forward.h"
  14 #include "sodipodi-ctrl.h"
  15
  16 enum {
  17     ARG_0,
  18     ARG_SHAPE,
  19     ARG_MODE,
  20     ARG_ANCHOR,
  21     ARG_SIZE,
  22     ARG_FILLED,
  23     ARG_FILL_COLOR,
  24     ARG_STROKED,
  25     ARG_STROKE_COLOR,
  26     ARG_PIXBUF
  27 };
  28
  29
  30 static void sp_ctrl_class_init (SPCtrlClass *klass);
  31 static void sp_ctrl_init (SPCtrl *ctrl);
  32 static void sp_ctrl_destroy (GtkObject *object);
  33 static void sp_ctrl_set_arg (GtkObject *object, GtkArg *arg, guint arg_id);
  34
  35 static void sp_ctrl_update (SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags);
  36 static void sp_ctrl_render (SPCanvasItem *item, SPCanvasBuf *buf);
  37
  38 static double sp_ctrl_point (SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item);
  39
  40
  41 static SPCanvasItemClass *parent_class;
  42
  43 GtkType
  44 sp_ctrl_get_type (void)
  45 {
  46     static GtkType ctrl_type = 0;
  47     if (!ctrl_type) {
  48         static GTypeInfo const ctrl_info = {
  49             sizeof (SPCtrlClass),
  50             NULL,   /* base_init */
  51             NULL,   /* base_finalize */
  52             (GClassInitFunc) sp_ctrl_class_init,
  53             NULL,   /* class_finalize */
  54             NULL,   /* class_data */
  55             sizeof (SPCtrl),
  56             0,   /* n_preallocs */
  57             (GInstanceInitFunc) sp_ctrl_init,
  58             NULL
  59         };
  60         ctrl_type = g_type_register_static (SP_TYPE_CANVAS_ITEM, "SPCtrl", &ctrl_info, (GTypeFlags)0);
  61     }
  62     return ctrl_type;
  63 }
  64
  65 static void
  66 sp_ctrl_class_init (SPCtrlClass *klass)
  67 {
  68     GtkObjectClass *object_class;
  69     SPCanvasItemClass *item_class;
  70
  71     object_class = (GtkObjectClass *) klass;
  72     item_class = (SPCanvasItemClass *) klass;
  73
  74     parent_class = (SPCanvasItemClass *)gtk_type_class (sp_canvas_item_get_type ());
  75
  76     gtk_object_add_arg_type ("SPCtrl::shape", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_SHAPE);
  77     gtk_object_add_arg_type ("SPCtrl::mode", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_MODE);
  78     gtk_object_add_arg_type ("SPCtrl::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, ARG_ANCHOR);
  79     gtk_object_add_arg_type ("SPCtrl::size", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_SIZE);
  80     gtk_object_add_arg_type ("SPCtrl::pixbuf", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_PIXBUF);
  81     gtk_object_add_arg_type ("SPCtrl::filled", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_FILLED);
  82     gtk_object_add_arg_type ("SPCtrl::fill_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FILL_COLOR);
  83     gtk_object_add_arg_type ("SPCtrl::stroked", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_STROKED);
  84     gtk_object_add_arg_type ("SPCtrl::stroke_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_STROKE_COLOR);
  85
  86     object_class->destroy = sp_ctrl_destroy;
  87     object_class->set_arg = sp_ctrl_set_arg;
  88
  89     item_class->update = sp_ctrl_update;
  90     item_class->render = sp_ctrl_render;
  91     item_class->point = sp_ctrl_point;
  92 }
  93
  94 static void
  95 sp_ctrl_init (SPCtrl *ctrl)
  96 {
  97     ctrl->shape = SP_CTRL_SHAPE_SQUARE;
  98     ctrl->mode = SP_CTRL_MODE_COLOR;
  99     ctrl->anchor = GTK_ANCHOR_CENTER;
 100     ctrl->span = 3;
 101     ctrl->defined = TRUE;
 102     ctrl->shown = FALSE;
 103     ctrl->build = FALSE;
 104     ctrl->filled = 1;
 105     ctrl->stroked = 0;
 106     ctrl->fill_color = 0x000000ff;
 107     ctrl->stroke_color = 0x000000ff;
 108     ctrl->_moved = false;
 109
 110     ctrl->box.x0 = ctrl->box.y0 = ctrl->box.x1 = ctrl->box.y1 = 0;
 111     ctrl->cache = NULL;
 112     ctrl->pixbuf = NULL;
 113 }
 114
 115 static void
 116 sp_ctrl_destroy (GtkObject *object)
 117 {
 118     SPCtrl *ctrl;
 119
 120     g_return_if_fail (object != NULL);
 121     g_return_if_fail (SP_IS_CTRL (object));
 122
 123     ctrl = SP_CTRL (object);
 124
 125     if (GTK_OBJECT_CLASS (parent_class)->destroy)
 126         (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 127 }
 128
 129 static void
 130 sp_ctrl_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
 131 {
 132     SPCanvasItem *item;
 133     SPCtrl *ctrl;
 134     GdkPixbuf * pixbuf = NULL;
 135
 136     item = SP_CANVAS_ITEM (object);
 137     ctrl = SP_CTRL (object);
 138
 139     switch (arg_id) {
 140         case ARG_SHAPE:
 141             ctrl->shape = (SPCtrlShapeType)(GTK_VALUE_INT (*arg));
 142             ctrl->build = FALSE;
 143             sp_canvas_item_request_update (item);
 144             break;
 145
 146         case ARG_MODE:
 147             ctrl->mode = (SPCtrlModeType)(GTK_VALUE_INT (*arg));
 148             ctrl->build = FALSE;
 149             sp_canvas_item_request_update (item);
 150             break;
 151
 152         case ARG_ANCHOR:
 153             ctrl->anchor = (GtkAnchorType)(GTK_VALUE_INT (*arg));
 154             ctrl->build = FALSE;
 155             sp_canvas_item_request_update (item);
 156             break;
 157
 158         case ARG_SIZE:
 159             ctrl->span = (gint) ((GTK_VALUE_DOUBLE (*arg) - 1.0) / 2.0 + 0.5);
 160             ctrl->defined = (ctrl->span > 0);
 161             ctrl->build = FALSE;
 162             sp_canvas_item_request_update (item);
 163             break;
 164
 165         case ARG_FILLED:
 166             ctrl->filled = GTK_VALUE_BOOL (*arg);
 167             ctrl->build = FALSE;
 168             sp_canvas_item_request_update (item);
 169             break;
 170
 171         case ARG_FILL_COLOR:
 172             ctrl->fill_color = GTK_VALUE_INT (*arg);
 173             ctrl->build = FALSE;
 174             sp_canvas_item_request_update (item);
 175             break;
 176
 177         case ARG_STROKED:
 178             ctrl->stroked = GTK_VALUE_BOOL (*arg);
 179             ctrl->build = FALSE;
 180             sp_canvas_item_request_update (item);
 181             break;
 182
 183         case ARG_STROKE_COLOR:
 184             ctrl->stroke_color = GTK_VALUE_INT (*arg);
 185             ctrl->build = FALSE;
 186             sp_canvas_item_request_update (item);
 187             break;
 188
 189         case ARG_PIXBUF:
 190             pixbuf  = (GdkPixbuf*)(GTK_VALUE_POINTER (*arg));
 191             if (gdk_pixbuf_get_has_alpha (pixbuf)) {
 192                 ctrl->pixbuf = pixbuf;
 193             } else {
 194                 ctrl->pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
 195                 gdk_pixbuf_unref (pixbuf);
 196             }
 197             ctrl->build = FALSE;
 198             break;
 199
 200         default:
 201             break;
 202     }
 203 }
 204
 205 static void
 206 sp_ctrl_update (SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags)
 207 {
 208     SPCtrl *ctrl;
 209     gint x, y;
 210
 211     ctrl = SP_CTRL (item);
 212
 213     if (((SPCanvasItemClass *) parent_class)->update)
 214         (* ((SPCanvasItemClass *) parent_class)->update) (item, affine, flags);
 215
 216     sp_canvas_item_reset_bounds (item);
 217
 218     if (!ctrl->_moved) return;
 219
 220     if (ctrl->shown) {
 221         sp_canvas_request_redraw (item->canvas, ctrl->box.x0, ctrl->box.y0, ctrl->box.x1 + 1, ctrl->box.y1 + 1);
 222     }
 223
 224     if (!ctrl->defined) return;
 225
 226     x = (gint) ((affine[4] > 0) ? (affine[4] + 0.5) : (affine[4] - 0.5)) - ctrl->span;
 227     y = (gint) ((affine[5] > 0) ? (affine[5] + 0.5) : (affine[5] - 0.5)) - ctrl->span;
 228
 229     switch (ctrl->anchor) {
 230         case GTK_ANCHOR_N:
 231         case GTK_ANCHOR_CENTER:
 232         case GTK_ANCHOR_S:
 233             break;
 234
 235         case GTK_ANCHOR_NW:
 236         case GTK_ANCHOR_W:
 237         case GTK_ANCHOR_SW:
 238             x += ctrl->span;
 239             break;
 240
 241         case GTK_ANCHOR_NE:
 242         case GTK_ANCHOR_E:
 243         case GTK_ANCHOR_SE:
 244             x -= (ctrl->span + 1);
 245             break;
 246     }
 247
 248     switch (ctrl->anchor) {
 249         case GTK_ANCHOR_W:
 250         case GTK_ANCHOR_CENTER:
 251         case GTK_ANCHOR_E:
 252             break;
 253
 254         case GTK_ANCHOR_NW:
 255         case GTK_ANCHOR_N:
 256         case GTK_ANCHOR_NE:
 257             y += ctrl->span;
 258             break;
 259
 260         case GTK_ANCHOR_SW:
 261         case GTK_ANCHOR_S:
 262         case GTK_ANCHOR_SE:
 263             y -= (ctrl->span + 1);
 264             break;
 265     }
 266
 267     ctrl->box.x0 = x;
 268     ctrl->box.y0 = y;
 269     ctrl->box.x1 = ctrl->box.x0 + 2 * ctrl->span;
 270     ctrl->box.y1 = ctrl->box.y0 + 2 * ctrl->span;
 271
 272     sp_canvas_update_bbox (item, ctrl->box.x0, ctrl->box.y0, ctrl->box.x1 + 1, ctrl->box.y1 + 1);
 273 }
 274
 275 static double
 276 sp_ctrl_point (SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item)
 277 {
 278     SPCtrl *ctrl = SP_CTRL (item);
 279
 280     *actual_item = item;
 281
 282     double const x = p[Geom::X];
 283     double const y = p[Geom::Y];
 284
 285     if ((x >= ctrl->box.x0) && (x <= ctrl->box.x1) && (y >= ctrl->box.y0) && (y <= ctrl->box.y1)) return 0.0;
 286
 287     return 1e18;
 288 }
 289
 290 static void
 291 sp_ctrl_build_cache (SPCtrl *ctrl)
 292 {
 293     guchar * p, *q;
 294     gint size, x, y, z, s, a, side, c;
 295     guint8 fr, fg, fb, fa, sr, sg, sb, sa;
 296
 297     if (ctrl->filled) {
 298         fr = (ctrl->fill_color >> 24) & 0xff;
 299         fg = (ctrl->fill_color >> 16) & 0xff;
 300         fb = (ctrl->fill_color >> 8) & 0xff;
 301         fa = (ctrl->fill_color) & 0xff;
 302     } else {
 303         fr = 0x00; fg = 0x00; fb = 0x00; fa = 0x00;
 304     }
 305     if (ctrl->stroked) {
 306         sr = (ctrl->stroke_color >> 24) & 0xff;
 307         sg = (ctrl->stroke_color >> 16) & 0xff;
 308         sb = (ctrl->stroke_color >> 8) & 0xff;
 309         sa = (ctrl->stroke_color) & 0xff;
 310     } else {
 311         sr = fr; sg = fg; sb = fb; sa = fa;
 312     }
 313
 314
 315     side = (ctrl->span * 2 +1);
 316     c = ctrl->span ;
 317     g_free (ctrl->cache);
 318     size = (side) * (side) * 4;
 319     ctrl->cache = (guchar*)g_malloc (size);
 320     if (side < 2) return;
 321
 322     switch (ctrl->shape) {
 323         case SP_CTRL_SHAPE_SQUARE:
 324             p = ctrl->cache;
 325             for (x=0; x < side; x++) {
 326                 *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa;
 327             }
 328             for (y = 2; y < side; y++) {
 329                 *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa;
 330                 for (x=2; x < side; x++) {
 331                     *p++ = fr; *p++ = fg; *p++ = fb; *p++ = fa;
 332                 }
 333                 *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa;
 334             }
 335             for (x=0; x < side; x++) {
 336                 *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa;
 337             }
 338             ctrl->build = TRUE;
 339             break;
 340
 341         case SP_CTRL_SHAPE_DIAMOND:
 342             p = ctrl->cache;
 343             for (y = 0; y < side; y++) {
 344                 z = abs (c - y);
 345                 for (x = 0; x < z; x++) {
 346                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 347                 }
 348                 *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa; x++;
 349                 for (; x < side - z -1; x++) {
 350                     *p++ = fr; *p++ = fg; *p++ = fb; *p++ = fa;
 351                 }
 352                 if (z != c) {
 353                     *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa; x++;
 354                 }
 355                 for (; x < side; x++) {
 356                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 357                 }
 358             }
 359             break;
 360
 361         case SP_CTRL_SHAPE_CIRCLE:
 362             p = ctrl->cache;
 363             q = p + size -1;
 364             s = -1;
 365             for (y = 0; y <= c ; y++) {
 366                 a = abs (c - y);
 367                 z = (gint)(0.0 + sqrt ((c+.4)*(c+.4) - a*a));
 368                 x = 0;
 369                 while (x < c-z) {
 370                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 371                     *q-- = 0x00; *q-- = 0x00; *q-- = 0x00; *q-- = 0x00;
 372                     x++;
 373                 }
 374                 do {
 375                     *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa;
 376                     *q-- = sa; *q-- = sb; *q-- = sg; *q-- = sr;
 377                     x++;
 378                 } while (x < c-s);
 379                 while (x < MIN(c+s+1, c+z)) {
 380                     *p++ = fr;   *p++ = fg;   *p++ = fb;   *p++ = fa;
 381                     *q-- = fa;   *q-- = fb;   *q-- = fg;   *q-- = fr;
 382                     x++;
 383                 }
 384                 do {
 385                     *p++ = sr;   *p++ = sg;   *p++ = sb;   *p++ = sa;
 386                     *q-- = sa; *q-- = sb; *q-- = sg; *q-- = sr;
 387                     x++;
 388                 } while (x <= c+z);
 389                 while (x < side) {
 390                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 391                     *q-- = 0x00; *q-- = 0x00; *q-- = 0x00; *q-- = 0x00;
 392                     x++;
 393                 }
 394                 s = z;
 395             }
 396             ctrl->build = TRUE;
 397             break;
 398
 399         case SP_CTRL_SHAPE_CROSS:
 400             p = ctrl->cache;
 401             for (y = 0; y < side; y++) {
 402                 z = abs (c - y);
 403                 for (x = 0; x < c-z; x++) {
 404                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 405                 }
 406                 *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa; x++;
 407                 for (; x < c + z; x++) {
 408                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 409                 }
 410                 if (z != 0) {
 411                     *p++ = sr; *p++ = sg; *p++ = sb; *p++ = sa; x++;
 412                 }
 413                 for (; x < side; x++) {
 414                     *p++ = 0x00; *p++ = 0x00; *p++ = 0x00; *p++ = 0x00;
 415                 }
 416             }
 417             ctrl->build = TRUE;
 418             break;
 419
 420         case SP_CTRL_SHAPE_BITMAP:
 421             if (ctrl->pixbuf) {
 422                 unsigned char *px;
 423                 unsigned int rs;
 424                 px = gdk_pixbuf_get_pixels (ctrl->pixbuf);
 425                 rs = gdk_pixbuf_get_rowstride (ctrl->pixbuf);
 426                 for (y = 0; y < side; y++){
 427                     unsigned char *s, *d;
 428                     s = px + y * rs;
 429                     d = ctrl->cache + 4 * side * y;
 430                     for (x = 0; x < side; x++) {
 431                         if (s[3] < 0x80) {
 432                             d[0] = 0x00;
 433                             d[1] = 0x00;
 434                             d[2] = 0x00;
 435                             d[3] = 0x00;
 436                         } else if (s[0] < 0x80) {
 437                             d[0] = sr;
 438                             d[1] = sg;
 439                             d[2] = sb;
 440                             d[3] = sa;
 441                         } else {
 442                             d[0] = fr;
 443                             d[1] = fg;
 444                             d[2] = fb;
 445                             d[3] = fa;
 446                         }
 447                         s += 4;
 448                         d += 4;
 449                     }
 450                 }
 451             } else {
 452                 g_print ("control has no pixmap\n");
 453             }
 454             ctrl->build = TRUE;
 455             break;
 456
 457         case SP_CTRL_SHAPE_IMAGE:
 458             if (ctrl->pixbuf) {
 459                 guint r = gdk_pixbuf_get_rowstride (ctrl->pixbuf);
 460                 guchar * pix;
 461                 q = gdk_pixbuf_get_pixels (ctrl->pixbuf);
 462                 p = ctrl->cache;
 463                 for (y = 0; y < side; y++){
 464                     pix = q + (y * r);
 465                     for (x = 0; x < side; x++) {
 466                         *p++ = *pix++;
 467                         *p++ = *pix++;
 468                         *p++ = *pix++;
 469                         *p++ = *pix++;
 470                     }
 471                 }
 472             } else {
 473                 g_print ("control has no pixmap\n");
 474             }
 475             ctrl->build = TRUE;
 476             break;
 477
 478         default:
 479             break;
 480     }
 481
 482 }
 483
 484 // composite background, foreground, alpha for xor mode
 485 #define COMPOSE_X(b,f,a) ( ( ((guchar) b) * ((guchar) (0xff - a)) + ((guchar) ((b ^ ~f) + b/4 - (b>127? 63 : 0))) * ((guchar) a) ) / 0xff )
 486 // composite background, foreground, alpha for color mode
 487 #define COMPOSE_N(b,f,a) ( ( ((guchar) b) * ((guchar) (0xff - a)) + ((guchar) f) * ((guchar) a) ) / 0xff )
 488
 489 static void
 490 sp_ctrl_render (SPCanvasItem *item, SPCanvasBuf *buf)
 491 {
 492     gint y0, y1, y, x0,x1,x;
 493     guchar *p, *q, a;
 494
 495     SPCtrl *ctrl = SP_CTRL (item);
 496
 497     if (!ctrl->defined) return;
 498     if ((!ctrl->filled) && (!ctrl->stroked)) return;
 499
 500     sp_canvas_prepare_buffer (buf);
 501
 502     // the control-image is rendered into ctrl->cache
 503     if (!ctrl->build) {
 504         sp_ctrl_build_cache (ctrl);
 505     }
 506
 507     // then we render from ctrl->cache
 508     y0 = MAX (ctrl->box.y0, buf->rect.y0);
 509     y1 = MIN (ctrl->box.y1, buf->rect.y1 - 1);
 510     x0 = MAX (ctrl->box.x0, buf->rect.x0);
 511     x1 = MIN (ctrl->box.x1, buf->rect.x1 - 1);
 512
 513     bool colormode;
 514
 515     for (y = y0; y <= y1; y++) {
 516         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x0 - buf->rect.x0) * 4;
 517         q = ctrl->cache + ((y - ctrl->box.y0) * (ctrl->span*2+1) + (x0 - ctrl->box.x0)) * 4;
 518         for (x = x0; x <= x1; x++) {
 519             a = *(q + 3);
 520             // 00000000 is the only way to get invisible; all other colors with alpha 00 are treated as mode_color with alpha ff
 521             colormode = false;
 522             if (a == 0x00 && !(q[0] == 0x00 && q[1] == 0x00 && q[2] == 0x00)) {
 523                 a = 0xff;
 524                 colormode = true;
 525             }
 526             if (ctrl->mode == SP_CTRL_MODE_COLOR || colormode) {
 527                 p[0] = COMPOSE_N (p[0], q[0], a);
 528                 p[1] = COMPOSE_N (p[1], q[1], a);
 529                 p[2] = COMPOSE_N (p[2], q[2], a);
 530                 q += 4;
 531                 p += 4;
 532             } else if (ctrl->mode == SP_CTRL_MODE_XOR) {
 533                 p[0] = COMPOSE_X (p[0], q[0], a);
 534                 p[1] = COMPOSE_X (p[1], q[1], a);
 535                 p[2] = COMPOSE_X (p[2], q[2], a);
 536                 q += 4;
 537                 p += 4;
 538             }
 539         }
 540     }
 541     ctrl->shown = TRUE;
 542 }
 543
 544 void SPCtrl::moveto (Geom::Point const p) {
 545     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (this), Geom::Matrix(Geom::Translate (p)));
 546     _moved = true;
 547 }
 548
 549
 550 /*
 551   Local Variables:
 552   mode:c++
 553   c-file-style:"stroustrup"
 554   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 555   indent-tabs-mode:nil
 556   fill-column:99
 557   End:
 558 */
 559 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :