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