1 #define __SP_DRAW_CONTEXT_C__
3 /*
4 * Generic drawing context
5 *
6 * Author:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 *
9 * Copyright (C) 2000 Lauris Kaplinski
10 * Copyright (C) 2000-2001 Ximian, Inc.
11 * Copyright (C) 2002 Lauris Kaplinski
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #define DRAW_VERBOSE
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
21 #include <gdk/gdkkeysyms.h>
23 #include "display/canvas-bpath.h"
24 #include "xml/repr.h"
25 #include "svg/svg.h"
26 #include <glibmm/i18n.h>
27 #include "display/curve.h"
28 #include "desktop.h"
29 #include "desktop-affine.h"
30 #include "desktop-handles.h"
31 #include "desktop-style.h"
32 #include "document.h"
33 #include "draw-anchor.h"
34 #include "macros.h"
35 #include "message-stack.h"
36 #include "pen-context.h"
37 #include "prefs-utils.h"
38 #include "selection.h"
39 #include "selection-chemistry.h"
40 #include "snap.h"
41 #include "sp-path.h"
42 #include "sp-namedview.h"
43 #include "live_effects/lpe-patternalongpath.h"
44 #include "style.h"
46 static void sp_draw_context_class_init(SPDrawContextClass *klass);
47 static void sp_draw_context_init(SPDrawContext *dc);
48 static void sp_draw_context_dispose(GObject *object);
50 static void sp_draw_context_setup(SPEventContext *ec);
51 static void sp_draw_context_set(SPEventContext *ec, gchar const *key, gchar const *value);
52 static void sp_draw_context_finish(SPEventContext *ec);
54 static gint sp_draw_context_root_handler(SPEventContext *event_context, GdkEvent *event);
56 static void spdc_selection_changed(Inkscape::Selection *sel, SPDrawContext *dc);
57 static void spdc_selection_modified(Inkscape::Selection *sel, guint flags, SPDrawContext *dc);
59 static void spdc_attach_selection(SPDrawContext *dc, Inkscape::Selection *sel);
61 static void spdc_flush_white(SPDrawContext *dc, SPCurve *gc);
63 static void spdc_reset_white(SPDrawContext *dc);
64 static void spdc_free_colors(SPDrawContext *dc);
67 static SPEventContextClass *draw_parent_class;
70 GType
71 sp_draw_context_get_type(void)
72 {
73 static GType type = 0;
74 if (!type) {
75 GTypeInfo info = {
76 sizeof(SPDrawContextClass),
77 NULL, NULL,
78 (GClassInitFunc) sp_draw_context_class_init,
79 NULL, NULL,
80 sizeof(SPDrawContext),
81 4,
82 (GInstanceInitFunc) sp_draw_context_init,
83 NULL, /* value_table */
84 };
85 type = g_type_register_static(SP_TYPE_EVENT_CONTEXT, "SPDrawContext", &info, (GTypeFlags)0);
86 }
87 return type;
88 }
90 static void
91 sp_draw_context_class_init(SPDrawContextClass *klass)
92 {
93 GObjectClass *object_class;
94 SPEventContextClass *ec_class;
96 object_class = (GObjectClass *)klass;
97 ec_class = (SPEventContextClass *) klass;
99 draw_parent_class = (SPEventContextClass*)g_type_class_peek_parent(klass);
101 object_class->dispose = sp_draw_context_dispose;
103 ec_class->setup = sp_draw_context_setup;
104 ec_class->set = sp_draw_context_set;
105 ec_class->finish = sp_draw_context_finish;
106 ec_class->root_handler = sp_draw_context_root_handler;
107 }
109 static void
110 sp_draw_context_init(SPDrawContext *dc)
111 {
112 dc->attach = FALSE;
114 dc->red_color = 0xff00007f;
115 dc->blue_color = 0x0000ff7f;
116 dc->green_color = 0x00ff007f;
117 dc->red_curve_is_valid = false;
119 dc->red_bpath = NULL;
120 dc->red_curve = NULL;
122 dc->blue_bpath = NULL;
123 dc->blue_curve = NULL;
125 dc->green_bpaths = NULL;
126 dc->green_curve = NULL;
127 dc->green_anchor = NULL;
128 dc->green_closed = false;
130 dc->white_item = NULL;
131 dc->white_curves = NULL;
132 dc->white_anchors = NULL;
134 dc->sa = NULL;
135 dc->ea = NULL;
137 dc->waiting_LPE_type = Inkscape::LivePathEffect::INVALID_LPE;
139 new (&dc->sel_changed_connection) sigc::connection();
140 new (&dc->sel_modified_connection) sigc::connection();
141 }
143 static void
144 sp_draw_context_dispose(GObject *object)
145 {
146 SPDrawContext *dc = SP_DRAW_CONTEXT(object);
148 dc->sel_changed_connection.~connection();
149 dc->sel_modified_connection.~connection();
151 if (dc->grab) {
152 sp_canvas_item_ungrab(dc->grab, GDK_CURRENT_TIME);
153 dc->grab = NULL;
154 }
156 if (dc->selection) {
157 dc->selection = NULL;
158 }
160 dc->waiting_LPE_type = Inkscape::LivePathEffect::INVALID_LPE;
162 spdc_free_colors(dc);
164 G_OBJECT_CLASS(draw_parent_class)->dispose(object);
165 }
167 static void
168 sp_draw_context_setup(SPEventContext *ec)
169 {
170 SPDrawContext *dc = SP_DRAW_CONTEXT(ec);
171 SPDesktop *dt = ec->desktop;
173 if (((SPEventContextClass *) draw_parent_class)->setup) {
174 ((SPEventContextClass *) draw_parent_class)->setup(ec);
175 }
177 dc->selection = sp_desktop_selection(dt);
179 /* Connect signals to track selection changes */
180 dc->sel_changed_connection = dc->selection->connectChanged(
181 sigc::bind(sigc::ptr_fun(&spdc_selection_changed), dc)
182 );
183 dc->sel_modified_connection = dc->selection->connectModified(
184 sigc::bind(sigc::ptr_fun(&spdc_selection_modified), dc)
185 );
187 /* Create red bpath */
188 dc->red_bpath = sp_canvas_bpath_new(sp_desktop_sketch(ec->desktop), NULL);
189 sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(dc->red_bpath), dc->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
190 /* Create red curve */
191 dc->red_curve = new SPCurve();
193 /* Create blue bpath */
194 dc->blue_bpath = sp_canvas_bpath_new(sp_desktop_sketch(ec->desktop), NULL);
195 sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(dc->blue_bpath), dc->blue_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
196 /* Create blue curve */
197 dc->blue_curve = new SPCurve();
199 /* Create green curve */
200 dc->green_curve = new SPCurve();
201 /* No green anchor by default */
202 dc->green_anchor = NULL;
203 dc->green_closed = FALSE;
205 dc->attach = TRUE;
206 spdc_attach_selection(dc, dc->selection);
207 }
209 static void
210 sp_draw_context_finish(SPEventContext *ec)
211 {
212 SPDrawContext *dc = SP_DRAW_CONTEXT(ec);
214 dc->sel_changed_connection.disconnect();
215 dc->sel_modified_connection.disconnect();
217 if (dc->grab) {
218 sp_canvas_item_ungrab(dc->grab, GDK_CURRENT_TIME);
219 }
221 if (dc->selection) {
222 dc->selection = NULL;
223 }
225 spdc_free_colors(dc);
226 }
228 static void
229 sp_draw_context_set(SPEventContext */*ec*/, const gchar */*key*/, const gchar */*value*/)
230 {
231 }
233 gint
234 sp_draw_context_root_handler(SPEventContext *ec, GdkEvent *event)
235 {
236 gint ret = FALSE;
238 switch (event->type) {
239 case GDK_KEY_PRESS:
240 switch (get_group0_keyval (&event->key)) {
241 case GDK_Up:
242 case GDK_Down:
243 case GDK_KP_Up:
244 case GDK_KP_Down:
245 // prevent the zoom field from activation
246 if (!MOD__CTRL_ONLY) {
247 ret = TRUE;
248 }
249 break;
250 default:
251 break;
252 }
253 break;
254 default:
255 break;
256 }
258 if (!ret) {
259 if (((SPEventContextClass *) draw_parent_class)->root_handler) {
260 ret = ((SPEventContextClass *) draw_parent_class)->root_handler(ec, event);
261 }
262 }
264 return ret;
265 }
267 static char const *
268 tool_name(SPDrawContext *dc)
269 {
270 return ( SP_IS_PEN_CONTEXT(dc)
271 ? "tools.freehand.pen"
272 : "tools.freehand.pencil" );
273 }
275 static void
276 spdc_paste_curve_as_freehand_shape(const SPCurve *c, SPDrawContext *dc, SPItem *item)
277 {
278 using namespace Inkscape::LivePathEffect;
280 // TODO: Don't paste path if nothing is on the clipboard
282 Effect::createAndApply(Inkscape::LivePathEffect::FREEHAND_SHAPE, dc->desktop->doc(), item);
283 Effect* lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(item));
284 gchar *svgd = sp_svg_write_path(c->get_pathvector());
285 static_cast<LPEPatternAlongPath*>(lpe)->pattern.paste_param_path(svgd);
286 }
288 /*
289 * If we have an item and a waiting LPE, apply the effect to the item
290 * (spiro spline mode is treated separately)
291 */
292 void
293 spdc_check_for_and_apply_waiting_LPE(SPDrawContext *dc, SPItem *item)
294 {
295 using namespace Inkscape::LivePathEffect;
297 if (item && SP_IS_LPE_ITEM(item)) {
298 if (prefs_get_int_attribute(tool_name(dc), "freehand-mode", 0) == 1) {
299 Effect::createAndApply(SPIRO, dc->desktop->doc(), item);
300 }
302 int shape = prefs_get_int_attribute(tool_name(dc), "shape", 0);
303 bool shape_applied = false;
304 SPCSSAttr *css_item = sp_css_attr_from_object (SP_OBJECT(item), SP_STYLE_FLAG_ALWAYS);
305 const char *cstroke = sp_repr_css_property(css_item, "stroke", "none");
307 #define SHAPE_LENGTH 100
308 #define SHAPE_HEIGHT 10
310 switch (shape) {
311 case 0:
312 // don't apply any shape
313 break;
314 case 1:
315 {
316 // "triangle in"
317 // TODO: this is only for illustration (we create a "decrescendo"-shaped path
318 // manually; eventually we should read the path from a separate file)
319 SPCurve *c = new SPCurve();
320 c->moveto(0,0);
321 c->lineto(0, SHAPE_HEIGHT);
322 c->lineto(SHAPE_LENGTH, SHAPE_HEIGHT/2);
323 c->closepath();
324 spdc_paste_curve_as_freehand_shape(c, dc, item);
325 c->unref();
327 shape_applied = true;
328 break;
329 }
330 case 2:
331 {
332 // "triangle out"
333 SPCurve *c = new SPCurve();
334 c->moveto(0, SHAPE_HEIGHT/2);
335 c->lineto(SHAPE_LENGTH, SHAPE_HEIGHT);
336 c->lineto(SHAPE_LENGTH, 0);
337 c->closepath();
338 spdc_paste_curve_as_freehand_shape(c, dc, item);
339 c->unref();
341 shape_applied = true;
342 break;
343 }
344 case 3:
345 {
346 // "ellipse"
347 SPCurve *c = new SPCurve();
348 const double C1 = 0.552;
349 c->moveto(0, SHAPE_HEIGHT/2);
350 c->curveto(0, (1 - C1) * SHAPE_HEIGHT/2, (1 - C1) * SHAPE_LENGTH/2, 0, SHAPE_LENGTH/2, 0);
351 c->curveto((1 + C1) * SHAPE_LENGTH/2, 0, SHAPE_LENGTH, (1 - C1) * SHAPE_HEIGHT/2, SHAPE_LENGTH, SHAPE_HEIGHT/2);
352 c->curveto(SHAPE_LENGTH, (1 + C1) * SHAPE_HEIGHT/2, (1 + C1) * SHAPE_LENGTH/2, SHAPE_HEIGHT, SHAPE_LENGTH/2, SHAPE_HEIGHT);
353 c->curveto((1 - C1) * SHAPE_LENGTH/2, SHAPE_HEIGHT, 0, (1 + C1) * SHAPE_HEIGHT/2, 0, SHAPE_HEIGHT/2);
354 c->closepath();
355 spdc_paste_curve_as_freehand_shape(c, dc, item);
356 c->unref();
357 shape_applied = true;
358 break;
359 }
360 case 4:
361 {
362 // take shape from clipboard; TODO: catch the case where clipboard is empty
363 Effect::createAndApply(FREEHAND_SHAPE, dc->desktop->doc(), item);
364 Effect* lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(item));
365 static_cast<LPEPatternAlongPath*>(lpe)->pattern.on_paste_button_click();
367 shape_applied = true;
368 break;
369 }
370 default:
371 break;
372 }
373 if (shape_applied) {
374 // apply original stroke color as fill and unset stroke; then return
375 SPCSSAttr *css = sp_repr_css_attr_new();
376 sp_repr_css_set_property (css, "fill", cstroke);
377 sp_repr_css_set_property (css, "stroke", "none");
378 sp_desktop_apply_css_recursive(SP_OBJECT(item), css, true);
379 sp_repr_css_attr_unref(css);
380 return;
381 }
383 if (dc->waiting_LPE_type != INVALID_LPE) {
384 Effect::createAndApply(dc->waiting_LPE_type, dc->desktop->doc(), item);
385 dc->waiting_LPE_type = INVALID_LPE;
386 }
387 if (SP_IS_PEN_CONTEXT(dc)) {
388 sp_pen_context_set_polyline_mode(SP_PEN_CONTEXT(dc));
389 }
390 }
391 }
393 /*
394 * Selection handlers
395 */
397 static void
398 spdc_selection_changed(Inkscape::Selection *sel, SPDrawContext *dc)
399 {
400 if (dc->attach) {
401 spdc_attach_selection(dc, sel);
402 }
403 }
405 /* fixme: We have to ensure this is not delayed (Lauris) */
407 static void
408 spdc_selection_modified(Inkscape::Selection *sel, guint /*flags*/, SPDrawContext *dc)
409 {
410 if (dc->attach) {
411 spdc_attach_selection(dc, sel);
412 }
413 }
415 static void
416 spdc_attach_selection(SPDrawContext *dc, Inkscape::Selection */*sel*/)
417 {
418 /* We reset white and forget white/start/end anchors */
419 spdc_reset_white(dc);
420 dc->sa = NULL;
421 dc->ea = NULL;
423 SPItem *item = dc->selection ? dc->selection->singleItem() : NULL;
425 if ( item && SP_IS_PATH(item) ) {
426 /* Create new white data */
427 /* Item */
428 dc->white_item = item;
429 /* Curve list */
430 /* We keep it in desktop coordinates to eliminate calculation errors */
431 SPCurve *norm = sp_path_get_curve_for_edit (SP_PATH(item));
432 norm->transform(sp_item_i2d_affine(dc->white_item));
433 g_return_if_fail( norm != NULL );
434 dc->white_curves = g_slist_reverse(norm->split());
435 norm->unref();
436 /* Anchor list */
437 for (GSList *l = dc->white_curves; l != NULL; l = l->next) {
438 SPCurve *c;
439 c = (SPCurve*)l->data;
440 g_return_if_fail( c->get_segment_count() > 0 );
441 if ( !c->is_closed() ) {
442 SPDrawAnchor *a;
443 a = sp_draw_anchor_new(dc, c, TRUE, *(c->first_point()));
444 dc->white_anchors = g_slist_prepend(dc->white_anchors, a);
445 a = sp_draw_anchor_new(dc, c, FALSE, *(c->last_point()));
446 dc->white_anchors = g_slist_prepend(dc->white_anchors, a);
447 }
448 }
449 /* fixme: recalculate active anchor? */
450 }
451 }
454 /**
455 * Snaps node or handle to PI/rotationsnapsperpi degree increments.
456 *
457 * \param dc draw context
458 * \param p cursor point (to be changed by snapping)
459 * \param o origin point
460 * \param state keyboard state to check if ctrl was pressed
461 */
463 void spdc_endpoint_snap_rotation(SPEventContext const *const ec, NR::Point &p, NR::Point const &o,
464 guint state)
465 {
466 unsigned const snaps = abs(prefs_get_int_attribute("options.rotationsnapsperpi", "value", 12));
467 /* 0 means no snapping. */
469 /* mirrored by fabs, so this corresponds to 15 degrees */
470 NR::Point best; /* best solution */
471 double bn = NR_HUGE; /* best normal */
472 double bdot = 0;
473 NR::Point v = NR::Point(0, 1);
474 double const r00 = cos(M_PI / snaps), r01 = sin(M_PI / snaps);
475 double const r10 = -r01, r11 = r00;
477 NR::Point delta = p - o;
479 for (unsigned i = 0; i < snaps; i++) {
480 double const ndot = fabs(dot(v,NR::rot90(delta)));
481 NR::Point t(r00*v[NR::X] + r01*v[NR::Y],
482 r10*v[NR::X] + r11*v[NR::Y]);
483 if (ndot < bn) {
484 /* I think it is better numerically to use the normal, rather than the dot product
485 * to assess solutions, but I haven't proven it. */
486 bn = ndot;
487 best = v;
488 bdot = dot(v, delta);
489 }
490 v = t;
491 }
493 if (fabs(bdot) > 0) {
494 p = o + bdot * best;
496 if (!(state & GDK_SHIFT_MASK)) { //SHIFT disables all snapping, except the angular snapping above
497 //After all, the user explicitely asked for angular snapping by
498 //pressing CTRL
499 /* Snap it along best vector */
500 SnapManager &m = SP_EVENT_CONTEXT_DESKTOP(ec)->namedview->snap_manager;
501 m.setup(SP_EVENT_CONTEXT_DESKTOP(ec), NULL);
502 Geom::Point pt2g = to_2geom(p);
503 m.constrainedSnapReturnByRef( Inkscape::Snapper::SNAPPOINT_NODE, pt2g, Inkscape::Snapper::ConstraintLine(best));
504 p = from_2geom(pt2g);
505 }
506 }
507 }
510 void spdc_endpoint_snap_free(SPEventContext const * const ec, NR::Point& p, guint const /*state*/)
511 {
512 SnapManager &m = SP_EVENT_CONTEXT_DESKTOP(ec)->namedview->snap_manager;
513 m.setup(SP_EVENT_CONTEXT_DESKTOP(ec), NULL);
514 Geom::Point pt2g = to_2geom(p);
515 m.freeSnapReturnByRef(Inkscape::Snapper::SNAPPOINT_NODE, pt2g);
516 p = from_2geom(pt2g);
517 }
519 static SPCurve *
520 reverse_then_unref(SPCurve *orig)
521 {
522 SPCurve *ret = orig->create_reverse();
523 orig->unref();
524 return ret;
525 }
527 /**
528 * Concats red, blue and green.
529 * If any anchors are defined, process these, optionally removing curves from white list
530 * Invoke _flush_white to write result back to object.
531 */
532 void
533 spdc_concat_colors_and_flush(SPDrawContext *dc, gboolean forceclosed)
534 {
535 /* Concat RBG */
536 SPCurve *c = dc->green_curve;
538 /* Green */
539 dc->green_curve = new SPCurve();
540 while (dc->green_bpaths) {
541 gtk_object_destroy(GTK_OBJECT(dc->green_bpaths->data));
542 dc->green_bpaths = g_slist_remove(dc->green_bpaths, dc->green_bpaths->data);
543 }
544 /* Blue */
545 c->append_continuous(dc->blue_curve, 0.0625);
546 dc->blue_curve->reset();
547 sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->blue_bpath), NULL);
548 /* Red */
549 if (dc->red_curve_is_valid) {
550 c->append_continuous(dc->red_curve, 0.0625);
551 }
552 dc->red_curve->reset();
553 sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->red_bpath), NULL);
555 if (c->is_empty()) {
556 c->unref();
557 return;
558 }
560 /* Step A - test, whether we ended on green anchor */
561 if ( forceclosed || ( dc->green_anchor && dc->green_anchor->active ) ) {
562 // We hit green anchor, closing Green-Blue-Red
563 SP_EVENT_CONTEXT_DESKTOP(dc)->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Path is closed."));
564 c->closepath_current();
565 /* Closed path, just flush */
566 spdc_flush_white(dc, c);
567 c->unref();
568 return;
569 }
571 /* Step B - both start and end anchored to same curve */
572 if ( dc->sa && dc->ea
573 && ( dc->sa->curve == dc->ea->curve )
574 && ( ( dc->sa != dc->ea )
575 || dc->sa->curve->is_closed() ) )
576 {
577 // We hit bot start and end of single curve, closing paths
578 SP_EVENT_CONTEXT_DESKTOP(dc)->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Closing path."));
579 if (dc->sa->start && !(dc->sa->curve->is_closed()) ) {
580 c = reverse_then_unref(c);
581 }
582 dc->sa->curve->append_continuous(c, 0.0625);
583 c->unref();
584 dc->sa->curve->closepath_current();
585 spdc_flush_white(dc, NULL);
586 return;
587 }
589 /* Step C - test start */
590 if (dc->sa) {
591 SPCurve *s = dc->sa->curve;
592 dc->white_curves = g_slist_remove(dc->white_curves, s);
593 if (dc->sa->start) {
594 s = reverse_then_unref(s);
595 }
596 s->append_continuous(c, 0.0625);
597 c->unref();
598 c = s;
599 } else /* Step D - test end */ if (dc->ea) {
600 SPCurve *e = dc->ea->curve;
601 dc->white_curves = g_slist_remove(dc->white_curves, e);
602 if (!dc->ea->start) {
603 e = reverse_then_unref(e);
604 }
605 c->append_continuous(e, 0.0625);
606 e->unref();
607 }
610 spdc_flush_white(dc, c);
612 c->unref();
613 }
615 /*
616 * Flushes white curve(s) and additional curve into object
617 *
618 * No cleaning of colored curves - this has to be done by caller
619 * No rereading of white data, so if you cannot rely on ::modified, do it in caller
620 *
621 */
623 static void
624 spdc_flush_white(SPDrawContext *dc, SPCurve *gc)
625 {
626 SPCurve *c;
628 if (dc->white_curves) {
629 g_assert(dc->white_item);
630 c = SPCurve::concat(dc->white_curves);
631 g_slist_free(dc->white_curves);
632 dc->white_curves = NULL;
633 if (gc) {
634 c->append(gc, FALSE);
635 }
636 } else if (gc) {
637 c = gc;
638 c->ref();
639 } else {
640 return;
641 }
643 /* Now we have to go back to item coordinates at last */
644 c->transform( dc->white_item
645 ? sp_item_dt2i_affine(dc->white_item)
646 : to_2geom(sp_desktop_dt2root_affine(SP_EVENT_CONTEXT_DESKTOP(dc))) );
648 SPDesktop *desktop = SP_EVENT_CONTEXT_DESKTOP(dc);
649 SPDocument *doc = sp_desktop_document(desktop);
650 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
652 if ( c && !c->is_empty() ) {
653 /* We actually have something to write */
655 bool has_lpe = false;
656 Inkscape::XML::Node *repr;
657 if (dc->white_item) {
658 repr = SP_OBJECT_REPR(dc->white_item);
659 has_lpe = sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(dc->white_item));
660 } else {
661 repr = xml_doc->createElement("svg:path");
662 /* Set style */
663 sp_desktop_apply_style_tool(desktop, repr, tool_name(dc), false);
664 }
666 gchar *str = sp_svg_write_path( c->get_pathvector() );
667 g_assert( str != NULL );
668 if (has_lpe)
669 repr->setAttribute("inkscape:original-d", str);
670 else
671 repr->setAttribute("d", str);
672 g_free(str);
674 if (!dc->white_item) {
675 /* Attach repr */
676 SPItem *item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
677 dc->selection->set(repr);
678 Inkscape::GC::release(repr);
679 item->transform = i2i_affine(desktop->currentRoot(), desktop->currentLayer());
680 item->updateRepr();
681 }
684 // we finished the path; now apply any waiting LPEs or freehand shapes
685 // FIXME: placing this here seems to cause issues with undo!
686 spdc_check_for_and_apply_waiting_LPE(dc, dc->selection->singleItem());
688 sp_document_done(doc, SP_IS_PEN_CONTEXT(dc)? SP_VERB_CONTEXT_PEN : SP_VERB_CONTEXT_PENCIL,
689 _("Draw path"));
691 // When quickly drawing several subpaths with Shift, the next subpath may be finished and
692 // flushed before the selection_modified signal is fired by the previous change, which
693 // results in the tool losing all of the selected path's curve except that last subpath. To
694 // fix this, we force the selection_modified callback now, to make sure the tool's curve is
695 // in sync immediately.
696 spdc_selection_modified(sp_desktop_selection(desktop), 0, dc);
697 }
699 c->unref();
701 /* Flush pending updates */
702 sp_document_ensure_up_to_date(doc);
703 }
705 /**
706 * Returns FIRST active anchor (the activated one).
707 */
708 SPDrawAnchor *
709 spdc_test_inside(SPDrawContext *dc, NR::Point p)
710 {
711 SPDrawAnchor *active = NULL;
713 /* Test green anchor */
714 if (dc->green_anchor) {
715 active = sp_draw_anchor_test(dc->green_anchor, p, TRUE);
716 }
718 for (GSList *l = dc->white_anchors; l != NULL; l = l->next) {
719 SPDrawAnchor *na = sp_draw_anchor_test((SPDrawAnchor *) l->data, p, !active);
720 if ( !active && na ) {
721 active = na;
722 }
723 }
725 return active;
726 }
728 static void
729 spdc_reset_white(SPDrawContext *dc)
730 {
731 if (dc->white_item) {
732 /* We do not hold refcount */
733 dc->white_item = NULL;
734 }
735 while (dc->white_curves) {
736 reinterpret_cast<SPCurve *>(dc->white_curves->data)->unref();
737 dc->white_curves = g_slist_remove(dc->white_curves, dc->white_curves->data);
738 }
739 while (dc->white_anchors) {
740 sp_draw_anchor_destroy((SPDrawAnchor *) dc->white_anchors->data);
741 dc->white_anchors = g_slist_remove(dc->white_anchors, dc->white_anchors->data);
742 }
743 }
745 static void
746 spdc_free_colors(SPDrawContext *dc)
747 {
748 /* Red */
749 if (dc->red_bpath) {
750 gtk_object_destroy(GTK_OBJECT(dc->red_bpath));
751 dc->red_bpath = NULL;
752 }
753 if (dc->red_curve) {
754 dc->red_curve = dc->red_curve->unref();
755 }
756 /* Blue */
757 if (dc->blue_bpath) {
758 gtk_object_destroy(GTK_OBJECT(dc->blue_bpath));
759 dc->blue_bpath = NULL;
760 }
761 if (dc->blue_curve) {
762 dc->blue_curve = dc->blue_curve->unref();
763 }
764 /* Green */
765 while (dc->green_bpaths) {
766 gtk_object_destroy(GTK_OBJECT(dc->green_bpaths->data));
767 dc->green_bpaths = g_slist_remove(dc->green_bpaths, dc->green_bpaths->data);
768 }
769 if (dc->green_curve) {
770 dc->green_curve = dc->green_curve->unref();
771 }
772 if (dc->green_anchor) {
773 dc->green_anchor = sp_draw_anchor_destroy(dc->green_anchor);
774 }
775 /* White */
776 if (dc->white_item) {
777 /* We do not hold refcount */
778 dc->white_item = NULL;
779 }
780 while (dc->white_curves) {
781 reinterpret_cast<SPCurve *>(dc->white_curves->data)->unref();
782 dc->white_curves = g_slist_remove(dc->white_curves, dc->white_curves->data);
783 }
784 while (dc->white_anchors) {
785 sp_draw_anchor_destroy((SPDrawAnchor *) dc->white_anchors->data);
786 dc->white_anchors = g_slist_remove(dc->white_anchors, dc->white_anchors->data);
787 }
788 }
791 /*
792 Local Variables:
793 mode:c++
794 c-file-style:"stroustrup"
795 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
796 indent-tabs-mode:nil
797 fill-column:99
798 End:
799 */
800 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :