void SPUse::delete_self() {
// always delete uses which are used in flowtext
if (parent && dynamic_cast<SPFlowregion *>(parent)) {
deleteObject();
return;
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint const mode = prefs->getInt("/options/cloneorphans/value",
SP_CLONE_ORPHANS_UNLINK);
if (mode == SP_CLONE_ORPHANS_UNLINK) {
this->unlink();
} else if (mode == SP_CLONE_ORPHANS_DELETE) {
this->deleteObject();
}
}
void
FontSubstitution::checkFontSubstitutions(SPDocument* doc)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int show_dlg = prefs->getInt("/options/font/substitutedlg", 0);
if (show_dlg) {
Glib::ustring out;
GSList *l = getFontReplacedItems(doc, &out);
if (out.length() > 0) {
show(out, l);
}
if (l) {
g_slist_free(l);
l = NULL;
}
}
}
static void
sp_selection_layout_widget_update(SPWidget *spw, Inkscape::Selection *sel)
{
if (g_object_get_data(G_OBJECT(spw), "update")) {
return;
}
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
using Geom::X;
using Geom::Y;
if ( sel && !sel->isEmpty() ) {
int prefs_bbox = prefs->getInt("/tools/bounding_box", 0);
SPItem::BBoxType bbox_type = (prefs_bbox ==0)?
SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
Geom::OptRect const bbox(sel->bounds(bbox_type));
if ( bbox ) {
UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(G_OBJECT(spw), "tracker"));
SPUnit const &unit = *tracker->getActiveUnit();
struct { char const *key; double val; } const keyval[] = {
{ "X", bbox->min()[X] },
{ "Y", bbox->min()[Y] },
{ "width", bbox->dimensions()[X] },
{ "height", bbox->dimensions()[Y] }
};
if (unit.base == SP_UNIT_DIMENSIONLESS) {
double const val = 1. / unit.unittobase;
for (unsigned i = 0; i < G_N_ELEMENTS(keyval); ++i) {
GtkAdjustment *a = (GtkAdjustment *) g_object_get_data(G_OBJECT(spw), keyval[i].key);
gtk_adjustment_set_value(a, val);
tracker->setFullVal( a, keyval[i].val );
}
} else {
for (unsigned i = 0; i < G_N_ELEMENTS(keyval); ++i) {
GtkAdjustment *a = (GtkAdjustment *) g_object_get_data(G_OBJECT(spw), keyval[i].key);
gtk_adjustment_set_value(a, sp_pixels_get_units(keyval[i].val, unit));
}
}
}
}
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
}
/*
* set attributes via inner (t=t0) knot point:
* [default] increase/decrease inner point
* [shift] increase/decrease inner and outer arg synchronizely
* [control] constrain inner arg to round per PI/4
*/
void
SpiralKnotHolderEntityInner::knot_set(Geom::Point const &p, Geom::Point const &origin, guint state)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
SPSpiral *spiral = SP_SPIRAL(item);
gdouble dx = p[Geom::X] - spiral->cx;
gdouble dy = p[Geom::Y] - spiral->cy;
gdouble moved_y = p[Geom::Y] - origin[Geom::Y];
if (state & GDK_MOD1_MASK) {
// adjust divergence by vertical drag, relative to rad
if (spiral->rad > 0) {
double exp_delta = 0.1*moved_y/(spiral->rad); // arbitrary multiplier to slow it down
spiral->exp += exp_delta;
if (spiral->exp < 1e-3)
spiral->exp = 1e-3;
}
} else {
// roll/unroll from inside
gdouble arg_t0;
spiral->getPolar(spiral->t0, NULL, &arg_t0);
gdouble arg_tmp = atan2(dy, dx) - arg_t0;
gdouble arg_t0_new = arg_tmp - floor((arg_tmp+M_PI)/(2.0*M_PI))*2.0*M_PI + arg_t0;
spiral->t0 = (arg_t0_new - spiral->arg) / (2.0*M_PI*spiral->revo);
/* round inner arg per PI/snaps, if CTRL is pressed */
if ( ( state & GDK_CONTROL_MASK )
&& ( fabs(spiral->revo) > SP_EPSILON_2 )
&& ( snaps != 0 ) ) {
gdouble arg = 2.0*M_PI*spiral->revo*spiral->t0 + spiral->arg;
spiral->t0 = (sp_round(arg, M_PI/snaps) - spiral->arg)/(2.0*M_PI*spiral->revo);
}
spiral->t0 = CLAMP(spiral->t0, 0.0, 0.999);
}
(static_cast<SPObject *>(spiral))->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
static void
sp_usepath_move_compensate(Geom::Affine const *mp, SPItem *original, SPUsePath *self)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint mode = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_PARALLEL);
if (mode == SP_CLONE_COMPENSATION_NONE) {
return;
}
SPItem *item = SP_ITEM(self->owner);
// TODO kill naughty naughty #if 0
#if 0
Geom::Affine m(*mp);
if (!(m.is_translation())) {
return;
}
Geom::Affine const t(item->transform);
Geom::Affine clone_move = t.inverse() * m * t;
// Calculate the compensation matrix and the advertized movement matrix.
Geom::Affine advertized_move;
if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
//clone_move = clone_move.inverse();
advertized_move.set_identity();
} else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
clone_move = clone_move.inverse() * m;
advertized_move = m;
} else {
g_assert_not_reached();
}
// Commit the compensation.
item->transform *= clone_move;
sp_item_write_transform(item, item->getRepr(), item->transform, &advertized_move);
#else
(void)mp;
(void)original;
#endif
self->sourceDirty = true;
item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
static void
sp_offset_delete_self(SPObject */*deleted*/, SPOffset *offset)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint const mode = prefs->getInt("/options/cloneorphans/value", SP_CLONE_ORPHANS_UNLINK);
if (mode == SP_CLONE_ORPHANS_UNLINK) {
// leave it be. just forget about the source
sp_offset_quit_listening(offset);
if ( offset->sourceHref ) {
g_free(offset->sourceHref);
}
offset->sourceHref = NULL;
offset->sourceRef->detach();
} else if (mode == SP_CLONE_ORPHANS_DELETE) {
offset->deleteObject();
}
}
/**
* Dropper auxiliary toolbar construction and setup.
*
* TODO: Would like to add swatch of current color.
* TODO: Add queue of last 5 or so colors selected with new swatches so that
* can drag and drop places. Will provide a nice mixing palette.
*/
void sp_dropper_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
gint pickAlpha = prefs->getInt( "/tools/dropper/pick", 1 );
{
EgeOutputAction* act = ege_output_action_new( "DropperOpacityAction", _("Opacity:"), "", 0 );
ege_output_action_set_use_markup( act, TRUE );
gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
}
{
InkToggleAction* act = ink_toggle_action_new( "DropperPickAlphaAction",
_("Pick opacity"),
_("Pick both the color and the alpha (transparency) under cursor; otherwise, pick only the visible color premultiplied by alpha"),
NULL,
Inkscape::ICON_SIZE_DECORATION );
g_object_set( act, "short_label", _("Pick"), NULL );
gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
g_object_set_data( holder, "pick_action", act );
gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), pickAlpha );
g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_pick_alpha), holder );
}
{
InkToggleAction* act = ink_toggle_action_new( "DropperSetAlphaAction",
_("Assign opacity"),
_("If alpha was picked, assign it to selection as fill or stroke transparency"),
NULL,
Inkscape::ICON_SIZE_DECORATION );
g_object_set( act, "short_label", _("Assign"), NULL );
gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
g_object_set_data( holder, "set_action", act );
gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/dropper/setalpha", true) );
// make sure it's disabled if we're not picking alpha
gtk_action_set_sensitive( GTK_ACTION(act), pickAlpha );
g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_set_alpha), holder );
}
}
void
lpetool_create_measuring_items(SPLPEToolContext *lc, Inkscape::Selection *selection)
{
if (!selection) {
selection = sp_desktop_selection(lc->desktop);
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool show = prefs->getBool("/tools/lpetool/show_measuring_info", true);
SPPath *path;
SPCurve *curve;
SPCanvasText *canvas_text;
SPCanvasGroup *tmpgrp = sp_desktop_tempgroup(lc->desktop);
gchar *arc_length;
double lengthval;
for (GSList const *i = selection->itemList(); i != NULL; i = i->next) {
if (SP_IS_PATH(i->data)) {
path = SP_PATH(i->data);
curve = sp_shape_get_curve(SP_SHAPE(path));
Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2 = paths_to_pw(curve->get_pathvector());
canvas_text = (SPCanvasText *) sp_canvastext_new(tmpgrp, lc->desktop, Geom::Point(0,0), "");
if (!show)
sp_canvas_item_hide(SP_CANVAS_ITEM(canvas_text));
SPUnitId unitid = static_cast<SPUnitId>(prefs->getInt("/tools/lpetool/unitid", SP_UNIT_PX));
SPUnit unit = sp_unit_get_by_id(unitid);
lengthval = Geom::length(pwd2);
gboolean success;
success = sp_convert_distance(&lengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
arc_length = g_strdup_printf("%.2f %s", lengthval, success ? sp_unit_get_abbreviation(&unit) : "px");
sp_canvastext_set_text (canvas_text, arc_length);
set_pos_and_anchor(canvas_text, pwd2, 0.5, 10);
// TODO: must we free arc_length?
(*lc->measuring_items)[path] = SP_CANVAS_ITEM(canvas_text);
}
}
}
static void sp_offset_move_compensate(Geom::Affine const *mp, SPItem */*original*/, SPOffset *self)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint mode = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_PARALLEL);
Geom::Affine m(*mp);
if (!(m.isTranslation()) || mode == SP_CLONE_COMPENSATION_NONE) {
self->sourceDirty=true;
self->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
return;
}
// calculate the compensation matrix and the advertized movement matrix
self->readAttr("transform");
Geom::Affine t = self->transform;
Geom::Affine offset_move = t.inverse() * m * t;
Geom::Affine advertized_move;
if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
offset_move = offset_move.inverse() * m;
advertized_move = m;
} else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
offset_move = offset_move.inverse();
advertized_move.setIdentity();
} else {
g_assert_not_reached();
}
self->sourceDirty=true;
// commit the compensation
self->transform *= offset_move;
self->doWriteTransform(self->getRepr(), self->transform, &advertized_move);
self->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
static void sp_font_selector_size_changed( GtkComboBox */*cbox*/, SPFontSelector *fsel )
{
char *text = NULL;
#if GTK_CHECK_VERSION(2, 24,0)
text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (fsel->size));
#else
text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (fsel->size));
#endif
gfloat old_size = fsel->fontsize;
gchar *endptr;
gdouble value = -1;
if (text) {
value = g_strtod (text, &endptr);
if (endptr == text) // conversion failed, non-numeric input
value = -1;
free (text);
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int max_size = prefs->getInt("/dialogs/textandfont/maxFontSize", 10000); // somewhat arbitrary, but text&font preview freezes with too huge fontsizes
if (value <= 0) {
return; // could not parse value
}
if (value > max_size)
value = max_size;
fsel->fontsize = value;
if ( fabs(fsel->fontsize-old_size) > 0.001)
{
fsel->fontsize_dirty = true;
}
sp_font_selector_emit_set (fsel);
}
void
lpetool_update_measuring_items(SPLPEToolContext *lc)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
SPPath *path;
SPCurve *curve;
double lengthval;
gchar *arc_length;
std::map<SPPath *, SPCanvasItem*>::iterator i;
for (i = lc->measuring_items->begin(); i != lc->measuring_items->end(); ++i) {
path = i->first;
curve = sp_shape_get_curve(SP_SHAPE(path));
Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2 = Geom::paths_to_pw(curve->get_pathvector());
SPUnitId unitid = static_cast<SPUnitId>(prefs->getInt("/tools/lpetool/unitid", SP_UNIT_PX));
SPUnit unit = sp_unit_get_by_id(unitid);
lengthval = Geom::length(pwd2);
gboolean success;
success = sp_convert_distance(&lengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
arc_length = g_strdup_printf("%.2f %s", lengthval, success ? sp_unit_get_abbreviation(&unit) : "px");
sp_canvastext_set_text (SP_CANVASTEXT(i->second), arc_length);
set_pos_and_anchor(SP_CANVASTEXT(i->second), pwd2, 0.5, 10);
// TODO: must we free arc_length?
}
}
GtkWidget * sp_gradient_vector_editor_new(SPGradient *gradient, SPStop *stop)
{
if (dlg == NULL) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
dlg = sp_window_new(_("Gradient editor"), TRUE);
if (x == -1000 || y == -1000) {
x = prefs->getInt(prefs_path + "x", -1000);
y = prefs->getInt(prefs_path + "y", -1000);
}
if (w ==0 || h == 0) {
w = prefs->getInt(prefs_path + "w", 0);
h = prefs->getInt(prefs_path + "h", 0);
}
if (x<0) {
x=0;
}
if (y<0) {
y=0;
}
if (x != 0 || y != 0) {
gtk_window_move(reinterpret_cast<GtkWindow *>(dlg), x, y);
} else {
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
}
if (w && h) {
gtk_window_resize(reinterpret_cast<GtkWindow *>(dlg), w, h);
}
sp_transientize(dlg);
wd.win = dlg;
wd.stop = 0;
GObject *obj = G_OBJECT(dlg);
sigc::connection *conn = NULL;
conn = new sigc::connection(INKSCAPE.signal_activate_desktop.connect(sigc::bind(sigc::ptr_fun(&sp_transientize_callback), &wd)));
g_object_set_data(obj, "desktop-activate-connection", conn);
g_signal_connect(obj, "event", G_CALLBACK(sp_dialog_event_handler), dlg);
g_signal_connect(obj, "destroy", G_CALLBACK(sp_gradient_vector_dialog_destroy), dlg);
g_signal_connect(obj, "delete_event", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
conn = new sigc::connection(INKSCAPE.signal_shut_down.connect(
sigc::hide_return(
sigc::bind(sigc::ptr_fun(&sp_gradient_vector_dialog_delete), (GtkWidget *) NULL, (GdkEvent *) NULL, (GtkWidget *) NULL)
)));
g_object_set_data(obj, "shutdown-connection", conn);
conn = new sigc::connection(INKSCAPE.signal_dialogs_hide.connect(sigc::bind(sigc::ptr_fun(>k_widget_hide), dlg)));
g_object_set_data(obj, "dialog-hide-connection", conn);
conn = new sigc::connection(INKSCAPE.signal_dialogs_unhide.connect(sigc::bind(sigc::ptr_fun(>k_widget_show), dlg)));
g_object_set_data(obj, "dialog-unhide-connection", conn);
gtk_container_set_border_width(GTK_CONTAINER(dlg), PAD);
GtkWidget *wid = static_cast<GtkWidget*>(sp_gradient_vector_widget_new(gradient, stop));
g_object_set_data(G_OBJECT(dlg), "gradient-vector-widget", wid);
/* Connect signals */
gtk_widget_show(wid);
gtk_container_add(GTK_CONTAINER(dlg), wid);
} else {
// FIXME: temp fix for 0.38
// Simply load_gradient into the editor does not work for multi-stop gradients,
// as the stop list and other widgets are in a wrong state and crash readily.
// Instead we just delete the window (by sending the delete signal)
// and call sp_gradient_vector_editor_new again, so it creates the window anew.
GdkEventAny event;
GtkWidget *widget = static_cast<GtkWidget *>(dlg);
event.type = GDK_DELETE;
event.window = gtk_widget_get_window (widget);
event.send_event = TRUE;
g_object_ref(G_OBJECT(event.window));
gtk_main_do_event(reinterpret_cast<GdkEvent*>(&event));
g_object_unref(G_OBJECT(event.window));
g_assert(dlg == NULL);
sp_gradient_vector_editor_new(gradient, stop);
}
return dlg;
}
static gint sp_box3d_context_root_handler(SPEventContext *event_context, GdkEvent *event)
{
static bool dragging;
SPDesktop *desktop = event_context->desktop;
SPDocument *document = sp_desktop_document (desktop);
Inkscape::Selection *selection = sp_desktop_selection (desktop);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
Box3DContext *bc = SP_BOX3D_CONTEXT(event_context);
Persp3D *cur_persp = document->getCurrentPersp3D();
event_context->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
gint ret = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
if ( event->button.button == 1 && !event_context->space_panning) {
Geom::Point const button_w(event->button.x,
event->button.y);
// save drag origin
event_context->xp = (gint) button_w[Geom::X];
event_context->yp = (gint) button_w[Geom::Y];
event_context->within_tolerance = true;
// remember clicked item, *not* disregarding groups (since a 3D box is a group), honoring Alt
event_context->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, event->button.state & GDK_CONTROL_MASK);
dragging = true;
/* */
Geom::Point button_dt(desktop->w2d(button_w));
bc->drag_origin = from_2geom(button_dt);
bc->drag_ptB = from_2geom(button_dt);
bc->drag_ptC = from_2geom(button_dt);
// This can happen after saving when the last remaining perspective was purged and must be recreated.
if (!cur_persp) {
sp_box3d_context_ensure_persp_in_defs(document);
cur_persp = document->getCurrentPersp3D();
}
/* Projective preimages of clicked point under current perspective */
bc->drag_origin_proj = cur_persp->perspective_impl->tmat.preimage (from_2geom(button_dt), 0, Proj::Z);
bc->drag_ptB_proj = bc->drag_origin_proj;
bc->drag_ptC_proj = bc->drag_origin_proj;
bc->drag_ptC_proj.normalize();
bc->drag_ptC_proj[Proj::Z] = 0.25;
/* Snap center */
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop, true, bc->item);
m.freeSnapReturnByRef(button_dt, Inkscape::SNAPSOURCE_NODE_HANDLE);
bc->center = from_2geom(button_dt);
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
( GDK_KEY_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_PRESS_MASK ),
NULL, event->button.time);
ret = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if ( dragging
&& ( event->motion.state & GDK_BUTTON1_MASK ) && !event_context->space_panning)
{
if ( event_context->within_tolerance
&& ( abs( (gint) event->motion.x - event_context->xp ) < event_context->tolerance )
&& ( abs( (gint) event->motion.y - event_context->yp ) < event_context->tolerance ) ) {
break; // do not drag if we're within tolerance from origin
}
// Once the user has moved farther than tolerance from the original location
// (indicating they intend to draw, not click), then always process the
// motion notify coordinates as given (no snapping back to origin)
event_context->within_tolerance = false;
Geom::Point const motion_w(event->motion.x,
event->motion.y);
Geom::Point motion_dt(desktop->w2d(motion_w));
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop, true, bc->item);
m.freeSnapReturnByRef(motion_dt, Inkscape::SNAPSOURCE_NODE_HANDLE);
bc->ctrl_dragged = event->motion.state & GDK_CONTROL_MASK;
if (event->motion.state & GDK_SHIFT_MASK && !bc->extruded && bc->item) {
// once shift is pressed, set bc->extruded
bc->extruded = true;
}
if (!bc->extruded) {
bc->drag_ptB = from_2geom(motion_dt);
bc->drag_ptC = from_2geom(motion_dt);
bc->drag_ptB_proj = cur_persp->perspective_impl->tmat.preimage (from_2geom(motion_dt), 0, Proj::Z);
bc->drag_ptC_proj = bc->drag_ptB_proj;
bc->drag_ptC_proj.normalize();
bc->drag_ptC_proj[Proj::Z] = 0.25;
} else {
// Without Ctrl, motion of the extruded corner is constrained to the
// perspective line from drag_ptB to vanishing point Y.
if (!bc->ctrl_dragged) {
/* snapping */
Box3D::PerspectiveLine pline (bc->drag_ptB, Proj::Z, document->getCurrentPersp3D());
bc->drag_ptC = pline.closest_to (from_2geom(motion_dt));
bc->drag_ptB_proj.normalize();
bc->drag_ptC_proj = cur_persp->perspective_impl->tmat.preimage (bc->drag_ptC, bc->drag_ptB_proj[Proj::X], Proj::X);
} else {
bc->drag_ptC = from_2geom(motion_dt);
bc->drag_ptB_proj.normalize();
bc->drag_ptC_proj = cur_persp->perspective_impl->tmat.preimage (from_2geom(motion_dt), bc->drag_ptB_proj[Proj::X], Proj::X);
}
m.freeSnapReturnByRef(bc->drag_ptC, Inkscape::SNAPSOURCE_NODE_HANDLE);
}
sp_box3d_drag(*bc, event->motion.state);
ret = TRUE;
} else if (!sp_event_context_knot_mouseover(bc)) {
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop);
Geom::Point const motion_w(event->motion.x, event->motion.y);
Geom::Point motion_dt(desktop->w2d(motion_w));
m.preSnap(Inkscape::SnapCandidatePoint(motion_dt, Inkscape::SNAPSOURCE_NODE_HANDLE));
}
break;
case GDK_BUTTON_RELEASE:
event_context->xp = event_context->yp = 0;
if ( event->button.button == 1 && !event_context->space_panning) {
dragging = false;
sp_event_context_discard_delayed_snap_event(event_context);
if (!event_context->within_tolerance) {
// we've been dragging, finish the box
sp_box3d_finish(bc);
} else if (event_context->item_to_select) {
// no dragging, select clicked item if any
if (event->button.state & GDK_SHIFT_MASK) {
selection->toggle(event_context->item_to_select);
} else {
selection->set(event_context->item_to_select);
}
} else {
// click in an empty space
selection->clear();
}
event_context->item_to_select = NULL;
ret = TRUE;
sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
event->button.time);
}
break;
case GDK_KEY_PRESS:
switch (get_group0_keyval (&event->key)) {
case GDK_Up:
case GDK_Down:
case GDK_KP_Up:
case GDK_KP_Down:
// prevent the zoom field from activation
if (!MOD__CTRL_ONLY)
ret = TRUE;
break;
case GDK_bracketright:
persp3d_rotate_VP (document->getCurrentPersp3D(), Proj::X, -180/snaps, MOD__ALT);
sp_document_done(document, SP_VERB_CONTEXT_3DBOX,
_("Change perspective (angle of PLs)"));
ret = true;
break;
case GDK_bracketleft:
persp3d_rotate_VP (document->getCurrentPersp3D(), Proj::X, 180/snaps, MOD__ALT);
sp_document_done(document, SP_VERB_CONTEXT_3DBOX,
_("Change perspective (angle of PLs)"));
ret = true;
break;
case GDK_parenright:
persp3d_rotate_VP (document->getCurrentPersp3D(), Proj::Y, -180/snaps, MOD__ALT);
sp_document_done(document, SP_VERB_CONTEXT_3DBOX,
_("Change perspective (angle of PLs)"));
ret = true;
break;
case GDK_parenleft:
persp3d_rotate_VP (document->getCurrentPersp3D(), Proj::Y, 180/snaps, MOD__ALT);
sp_document_done(document, SP_VERB_CONTEXT_3DBOX,
_("Change perspective (angle of PLs)"));
ret = true;
break;
case GDK_braceright:
persp3d_rotate_VP (document->getCurrentPersp3D(), Proj::Z, -180/snaps, MOD__ALT);
sp_document_done(document, SP_VERB_CONTEXT_3DBOX,
_("Change perspective (angle of PLs)"));
ret = true;
break;
case GDK_braceleft:
persp3d_rotate_VP (document->getCurrentPersp3D(), Proj::Z, 180/snaps, MOD__ALT);
sp_document_done(document, SP_VERB_CONTEXT_3DBOX,
_("Change perspective (angle of PLs)"));
ret = true;
break;
/* TODO: what is this???
case GDK_O:
if (MOD__CTRL && MOD__SHIFT) {
Box3D::create_canvas_point(persp3d_get_VP(document()->getCurrentPersp3D(), Proj::W).affine(),
6, 0xff00ff00);
}
ret = true;
break;
*/
case GDK_g:
case GDK_G:
if (MOD__SHIFT_ONLY) {
sp_selection_to_guides(desktop);
ret = true;
}
break;
case GDK_p:
case GDK_P:
if (MOD__SHIFT_ONLY) {
if (document->getCurrentPersp3D()) {
persp3d_print_debugging_info (document->getCurrentPersp3D());
}
ret = true;
}
break;
case GDK_x:
case GDK_X:
if (MOD__ALT_ONLY) {
desktop->setToolboxFocusTo ("altx-box3d");
ret = TRUE;
}
if (MOD__SHIFT_ONLY) {
persp3d_toggle_VPs(selection->perspList(), Proj::X);
bc->_vpdrag->updateLines(); // FIXME: Shouldn't this be done automatically?
ret = true;
}
break;
case GDK_y:
case GDK_Y:
if (MOD__SHIFT_ONLY) {
persp3d_toggle_VPs(selection->perspList(), Proj::Y);
bc->_vpdrag->updateLines(); // FIXME: Shouldn't this be done automatically?
ret = true;
}
break;
case GDK_z:
case GDK_Z:
if (MOD__SHIFT_ONLY) {
persp3d_toggle_VPs(selection->perspList(), Proj::Z);
bc->_vpdrag->updateLines(); // FIXME: Shouldn't this be done automatically?
ret = true;
}
break;
case GDK_Escape:
sp_desktop_selection(desktop)->clear();
//TODO: make dragging escapable by Esc
break;
case GDK_space:
if (dragging) {
sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
event->button.time);
dragging = false;
sp_event_context_discard_delayed_snap_event(event_context);
if (!event_context->within_tolerance) {
// we've been dragging, finish the box
sp_box3d_finish(bc);
}
// do not return true, so that space would work switching to selector
}
break;
default:
break;
}
break;
default:
break;
}
if (!ret) {
if (((SPEventContextClass *) parent_class)->root_handler) {
ret = ((SPEventContextClass *) parent_class)->root_handler(event_context, event);
}
}
return ret;
}
bool LpeTool::root_handler(GdkEvent* event) {
Inkscape::Selection *selection = desktop->getSelection();
bool ret = false;
if (this->hasWaitingLPE()) {
// quit when we are waiting for a LPE to be applied
//ret = ((ToolBaseClass *) sp_lpetool_context_parent_class)->root_handler(event_context, event);
return PenTool::root_handler(event);
}
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event->button.button == 1 && !this->space_panning) {
if (this->mode == Inkscape::LivePathEffect::INVALID_LPE) {
// don't do anything for now if we are inactive (except clearing the selection
// since this was a click into empty space)
selection->clear();
desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Choose a construction tool from the toolbar."));
ret = true;
break;
}
// save drag origin
this->xp = (gint) event->button.x;
this->yp = (gint) event->button.y;
this->within_tolerance = true;
using namespace Inkscape::LivePathEffect;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int mode = prefs->getInt("/tools/lpetool/mode");
EffectType type = lpesubtools[mode].type;
//bool over_stroke = lc->shape_editor->is_over_stroke(Geom::Point(event->button.x, event->button.y), true);
this->waitForLPEMouseClicks(type, Inkscape::LivePathEffect::Effect::acceptsNumClicks(type));
// we pass the mouse click on to pen tool as the first click which it should collect
//ret = ((ToolBaseClass *) sp_lpetool_context_parent_class)->root_handler(event_context, event);
ret = PenTool::root_handler(event);
}
break;
case GDK_BUTTON_RELEASE:
{
/**
break;
**/
}
case GDK_KEY_PRESS:
/**
switch (get_group0_keyval (&event->key)) {
}
break;
**/
case GDK_KEY_RELEASE:
/**
switch (get_group0_keyval(&event->key)) {
case GDK_Control_L:
case GDK_Control_R:
dc->_message_context->clear();
break;
default:
break;
}
**/
default:
break;
}
if (!ret) {
ret = PenTool::root_handler(event);
}
return ret;
}
static void sp_gradient_drag(SPGradientContext &rc, Geom::Point const pt, guint /*state*/, guint32 etime)
{
SPDesktop *desktop = SP_EVENT_CONTEXT(&rc)->desktop;
Inkscape::Selection *selection = sp_desktop_selection(desktop);
SPDocument *document = sp_desktop_document(desktop);
SPEventContext *ec = SP_EVENT_CONTEXT(&rc);
if (!selection->isEmpty()) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int type = prefs->getInt("/tools/gradient/newgradient", 1);
int fill_or_stroke = prefs->getInt("/tools/gradient/newfillorstroke", 1);
SPGradient *vector;
if (ec->item_to_select) {
// pick color from the object where drag started
vector = sp_gradient_vector_for_object(document, desktop, ec->item_to_select, fill_or_stroke);
} else {
// Starting from empty space:
// Sort items so that the topmost comes last
GSList *items = g_slist_copy ((GSList *) selection->itemList());
items = g_slist_sort(items, (GCompareFunc) sp_item_repr_compare_position);
// take topmost
vector = sp_gradient_vector_for_object(document, desktop, SP_ITEM(g_slist_last(items)->data), fill_or_stroke);
g_slist_free (items);
}
// HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
SPCSSAttr *css = sp_repr_css_attr_new();
sp_repr_css_set_property(css, "fill-opacity", "1.0");
for (GSList const *i = selection->itemList(); i != NULL; i = i->next) {
//FIXME: see above
sp_repr_css_change_recursive(SP_OBJECT_REPR(i->data), css, "style");
sp_item_set_gradient(SP_ITEM(i->data), vector, (SPGradientType) type, fill_or_stroke);
if (type == SP_GRADIENT_TYPE_LINEAR) {
sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_LG_BEGIN, 0, rc.origin, fill_or_stroke, true, false);
sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_LG_END, 0, pt, fill_or_stroke, true, false);
} else if (type == SP_GRADIENT_TYPE_RADIAL) {
sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_RG_CENTER, 0, rc.origin, fill_or_stroke, true, false);
sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_RG_R1, 0, pt, fill_or_stroke, true, false);
}
SP_OBJECT (i->data)->requestModified(SP_OBJECT_MODIFIED_FLAG);
}
if (ec->_grdrag) {
ec->_grdrag->updateDraggers();
// prevent regenerating draggers by selection modified signal, which sometimes
// comes too late and thus destroys the knot which we will now grab:
ec->_grdrag->local_change = true;
// give the grab out-of-bounds values of xp/yp because we're already dragging
// and therefore are already out of tolerance
ec->_grdrag->grabKnot (SP_ITEM(selection->itemList()->data),
type == SP_GRADIENT_TYPE_LINEAR? POINT_LG_END : POINT_RG_R1,
-1, // ignore number (though it is always 1)
fill_or_stroke, 99999, 99999, etime);
}
// We did an undoable action, but sp_document_done will be called by the knot when released
// status text; we do not track coords because this branch is run once, not all the time
// during drag
int n_objects = g_slist_length((GSList *) selection->itemList());
rc._message_context->setF(Inkscape::NORMAL_MESSAGE,
ngettext("<b>Gradient</b> for %d object; with <b>Ctrl</b> to snap angle",
"<b>Gradient</b> for %d objects; with <b>Ctrl</b> to snap angle", n_objects),
n_objects);
} else {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>objects</b> on which to create gradient."));
}
}
void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
EgeAdjustmentAction* eact = 0;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
{
GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
GList* items = 0;
gint count = 0;
for ( items = Inkscape::UI::Tools::flood_channels_dropdown_items_list(); items ; items = g_list_next(items) )
{
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
count++;
}
g_list_free( items );
items = 0;
EgeSelectOneAction* act1 = ege_select_one_action_new( "ChannelsAction", _("Fill by"), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act1, "short_label", _("Fill by:"), NULL );
ege_select_one_action_set_appearance( act1, "compact" );
ege_select_one_action_set_active( act1, prefs->getInt("/tools/paintbucket/channels", 0) );
g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(paintbucket_channels_changed), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
g_object_set_data( holder, "channels_action", act1 );
}
// Spacing spinbox
{
eact = create_adjustment_action(
"ThresholdAction",
_("Fill Threshold"), _("Threshold:"),
_("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
"/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), holder, TRUE,
"inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0,
0, 0, 0,
paintbucket_threshold_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
}
// Create the units menu.
UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits");
if (!stored_unit.empty()) {
Unit const *u = unit_table.getUnit(stored_unit);
tracker->setActiveUnit(u);
}
g_object_set_data( holder, "tracker", tracker );
{
GtkAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") );
gtk_action_group_add_action( mainActions, act );
}
// Offset spinbox
{
eact = create_adjustment_action(
"OffsetAction",
_("Grow/shrink by"), _("Grow/shrink by:"),
_("The amount to grow (positive) or shrink (negative) the created fill path"),
"/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), holder, TRUE,
"inkscape:paintbucket-offset", -1e4, 1e4, 0.1, 0.5,
0, 0, 0,
paintbucket_offset_changed, tracker, 1, 2);
tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
}
/* Auto Gap */
{
GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
GList* items = 0;
gint count = 0;
for ( items = Inkscape::UI::Tools::flood_autogap_dropdown_items_list(); items ; items = g_list_next(items) )
{
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
count++;
}
g_list_free( items );
items = 0;
EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Close gaps"), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act2, "short_label", _("Close gaps:"), NULL );
ege_select_one_action_set_appearance( act2, "compact" );
ege_select_one_action_set_active( act2, prefs->getBool("/tools/paintbucket/autogap") );
g_signal_connect( G_OBJECT(act2), "changed", G_CALLBACK(paintbucket_autogap_changed), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(act2) );
g_object_set_data( holder, "autogap_action", act2 );
}
/* Reset */
{
GtkAction* act = gtk_action_new( "PaintbucketResetAction",
_("Defaults"),
_("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
GTK_STOCK_CLEAR );
g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(paintbucket_defaults), holder );
gtk_action_group_add_action( mainActions, act );
gtk_action_set_sensitive( act, TRUE );
}
}
static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
{
/* Freehand mode toggle buttons */
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint freehandMode = prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/freehand-mode" : "/tools/freehand/pen/freehand-mode" ), 0);
Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
{
GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Bezier"),
1, _("Create regular Bezier path"),
2, INKSCAPE_ICON("path-mode-bezier"),
-1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Spiro"),
1, _("Create Spiro path"),
2, INKSCAPE_ICON("path-mode-spiro"),
-1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("BSpline"),
1, _("Create BSpline path"),
2, INKSCAPE_ICON("path-mode-bspline"),
-1 );
if (!tool_is_pencil) {
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Zigzag"),
1, _("Create a sequence of straight line segments"),
2, INKSCAPE_ICON("path-mode-polyline"),
-1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Paraxial"),
1, _("Create a sequence of paraxial line segments"),
2, INKSCAPE_ICON("path-mode-polyline-paraxial"),
-1 );
}
EgeSelectOneAction* act = ege_select_one_action_new(tool_is_pencil ?
"FreehandModeActionPencil" :
"FreehandModeActionPen",
(_("Mode:")), (_("Mode of new lines drawn by this tool")), NULL, GTK_TREE_MODEL(model) );
gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
ege_select_one_action_set_appearance( act, "full" );
ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
ege_select_one_action_set_icon_column( act, 2 );
ege_select_one_action_set_icon_size( act, secondarySize );
ege_select_one_action_set_tooltip_column( act, 1 );
ege_select_one_action_set_active( act, freehandMode);
g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(freehand_mode_changed), holder);
}
}
}
SPDocument *
sp_document_create(Inkscape::XML::Document *rdoc,
gchar const *uri,
gchar const *base,
gchar const *name,
unsigned int keepalive)
{
SPDocument *document;
Inkscape::XML::Node *rroot;
Inkscape::Version sodipodi_version;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
rroot = rdoc->root();
document = new SPDocument();
document->keepalive = keepalive;
document->rdoc = rdoc;
document->rroot = rroot;
#ifndef WIN32
prepend_current_dir_if_relative(&(document->uri), uri);
#else
// FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!
document->uri = uri? g_strdup(uri) : NULL;
#endif
// base is simply the part of the path before filename; e.g. when running "inkscape ../file.svg" the base is "../"
// which is why we use g_get_current_dir() in calculating the abs path above
//This is NULL for a new document
if (base)
document->base = g_strdup(base);
else
document->base = NULL;
document->name = g_strdup(name);
document->root = sp_object_repr_build_tree(document, rroot);
sodipodi_version = SP_ROOT(document->root)->version.sodipodi;
/* fixme: Not sure about this, but lets assume ::build updates */
rroot->setAttribute("sodipodi:version", SODIPODI_VERSION);
rroot->setAttribute("inkscape:version", Inkscape::version_string);
/* fixme: Again, I moved these here to allow version determining in ::build (Lauris) */
/* Quick hack 2 - get default image size into document */
if (!rroot->attribute("width")) rroot->setAttribute("width", "100%");
if (!rroot->attribute("height")) rroot->setAttribute("height", "100%");
/* End of quick hack 2 */
/* Quick hack 3 - Set uri attributes */
if (uri) {
rroot->setAttribute("sodipodi:docname", uri);
}
/* End of quick hack 3 */
/* Eliminate obsolete sodipodi:docbase, for privacy reasons */
rroot->setAttribute("sodipodi:docbase", NULL);
/* Eliminate any claim to adhere to a profile, as we don't try to */
rroot->setAttribute("baseProfile", NULL);
// creating namedview
if (!sp_item_group_get_child_by_name((SPGroup *) document->root, NULL, "sodipodi:namedview")) {
// if there's none in the document already,
Inkscape::XML::Node *rnew = NULL;
rnew = rdoc->createElement("sodipodi:namedview");
//rnew->setAttribute("id", "base");
// Add namedview data from the preferences
// we can't use getAllEntries because this could produce non-SVG doubles
Glib::ustring pagecolor = prefs->getString("/template/base/pagecolor");
if (!pagecolor.empty()) {
rnew->setAttribute("pagecolor", pagecolor.data());
}
Glib::ustring bordercolor = prefs->getString("/template/base/bordercolor");
if (!bordercolor.empty()) {
rnew->setAttribute("bordercolor", bordercolor.data());
}
sp_repr_set_svg_double(rnew, "borderopacity",
prefs->getDouble("/template/base/borderopacity", 1.0));
sp_repr_set_svg_double(rnew, "objecttolerance",
prefs->getDouble("/template/base/objecttolerance", 10.0));
sp_repr_set_svg_double(rnew, "gridtolerance",
prefs->getDouble("/template/base/gridtolerance", 10.0));
sp_repr_set_svg_double(rnew, "guidetolerance",
prefs->getDouble("/template/base/guidetolerance", 10.0));
sp_repr_set_svg_double(rnew, "inkscape:pageopacity",
prefs->getDouble("/template/base/inkscape:pageopacity", 0.0));
sp_repr_set_int(rnew, "inkscape:pageshadow",
prefs->getInt("/template/base/inkscape:pageshadow", 2));
sp_repr_set_int(rnew, "inkscape:window-width",
prefs->getInt("/template/base/inkscape:window-width", 640));
sp_repr_set_int(rnew, "inkscape:window-height",
prefs->getInt("/template/base/inkscape:window-height", 480));
// insert into the document
rroot->addChild(rnew, NULL);
// clean up
Inkscape::GC::release(rnew);
}
/* Defs */
if (!SP_ROOT(document->root)->defs) {
Inkscape::XML::Node *r;
r = rdoc->createElement("svg:defs");
rroot->addChild(r, NULL);
Inkscape::GC::release(r);
g_assert(SP_ROOT(document->root)->defs);
}
/* Default RDF */
rdf_set_defaults( document );
if (keepalive) {
inkscape_ref();
}
// Remark: Here, we used to create a "currentpersp3d" element in the document defs.
// But this is probably a bad idea since we need to adapt it for every change of selection, which will
// completely clutter the undo history. Maybe rather save it to prefs on exit and re-read it on startup?
document->current_persp3d = persp3d_document_first_persp(document);
if (!document->current_persp3d) {
document->current_persp3d = persp3d_create_xml_element (document);
}
sp_document_set_undo_sensitive(document, true);
// reset undo key when selection changes, so that same-key actions on different objects are not coalesced
if (!Inkscape::NSApplication::Application::getNewGui()) {
g_signal_connect(G_OBJECT(INKSCAPE), "change_selection",
G_CALLBACK(sp_document_reset_key), document);
g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop",
G_CALLBACK(sp_document_reset_key), document);
} else {
document->_selection_changed_connection = Inkscape::NSApplication::Editor::connectSelectionChanged (sigc::mem_fun (*document, &SPDocument::reset_key));
document->_desktop_activated_connection = Inkscape::NSApplication::Editor::connectDesktopActivated (sigc::mem_fun (*document, &SPDocument::reset_key));
}
return document;
}
static void
sp_object_layout_any_value_changed(GtkAdjustment *adj, SPWidget *spw)
{
if (g_object_get_data(G_OBJECT(spw), "update")) {
return;
}
UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(G_OBJECT(spw), "tracker"));
if ( !tracker || tracker->isUpdating() ) {
/*
* When only units are being changed, don't treat changes
* to adjuster values as object changes.
*/
return;
}
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
Inkscape::Selection *selection = sp_desktop_selection(desktop);
SPDocument *document = sp_desktop_document(desktop);
document->ensureUpToDate ();
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Geom::OptRect bbox_vis = selection->visualBounds();
Geom::OptRect bbox_geom = selection->geometricBounds();
int prefs_bbox = prefs->getInt("/tools/bounding_box");
SPItem::BBoxType bbox_type = (prefs_bbox == 0)?
SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
Geom::OptRect bbox_user = selection->bounds(bbox_type);
if ( !bbox_user ) {
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
return;
}
gdouble x0 = 0;
gdouble y0 = 0;
gdouble x1 = 0;
gdouble y1 = 0;
gdouble xrel = 0;
gdouble yrel = 0;
SPUnit const &unit = *tracker->getActiveUnit();
GtkAdjustment* a_x = GTK_ADJUSTMENT( g_object_get_data( G_OBJECT(spw), "X" ) );
GtkAdjustment* a_y = GTK_ADJUSTMENT( g_object_get_data( G_OBJECT(spw), "Y" ) );
GtkAdjustment* a_w = GTK_ADJUSTMENT( g_object_get_data( G_OBJECT(spw), "width" ) );
GtkAdjustment* a_h = GTK_ADJUSTMENT( g_object_get_data( G_OBJECT(spw), "height" ) );
if (unit.base == SP_UNIT_ABSOLUTE || unit.base == SP_UNIT_DEVICE) {
x0 = sp_units_get_pixels (gtk_adjustment_get_value (a_x), unit);
y0 = sp_units_get_pixels (gtk_adjustment_get_value (a_y), unit);
x1 = x0 + sp_units_get_pixels (gtk_adjustment_get_value (a_w), unit);
xrel = sp_units_get_pixels (gtk_adjustment_get_value (a_w), unit) / bbox_user->dimensions()[Geom::X];
y1 = y0 + sp_units_get_pixels (gtk_adjustment_get_value (a_h), unit);
yrel = sp_units_get_pixels (gtk_adjustment_get_value (a_h), unit) / bbox_user->dimensions()[Geom::Y];
} else {
double const x0_propn = gtk_adjustment_get_value (a_x) * unit.unittobase;
x0 = bbox_user->min()[Geom::X] * x0_propn;
double const y0_propn = gtk_adjustment_get_value (a_y) * unit.unittobase;
y0 = y0_propn * bbox_user->min()[Geom::Y];
xrel = gtk_adjustment_get_value (a_w) * unit.unittobase;
x1 = x0 + xrel * bbox_user->dimensions()[Geom::X];
yrel = gtk_adjustment_get_value (a_h) * unit.unittobase;
y1 = y0 + yrel * bbox_user->dimensions()[Geom::Y];
}
// Keep proportions if lock is on
GtkToggleAction *lock = GTK_TOGGLE_ACTION( g_object_get_data(G_OBJECT(spw), "lock") );
if ( gtk_toggle_action_get_active(lock) ) {
if (adj == a_h) {
x1 = x0 + yrel * bbox_user->dimensions()[Geom::X];
} else if (adj == a_w) {
y1 = y0 + xrel * bbox_user->dimensions()[Geom::Y];
}
}
// scales and moves, in px
double mh = fabs(x0 - bbox_user->min()[Geom::X]);
double sh = fabs(x1 - bbox_user->max()[Geom::X]);
double mv = fabs(y0 - bbox_user->min()[Geom::Y]);
double sv = fabs(y1 - bbox_user->max()[Geom::Y]);
// unless the unit is %, convert the scales and moves to the unit
if (unit.base == SP_UNIT_ABSOLUTE || unit.base == SP_UNIT_DEVICE) {
mh = sp_pixels_get_units (mh, unit);
sh = sp_pixels_get_units (sh, unit);
mv = sp_pixels_get_units (mv, unit);
sv = sp_pixels_get_units (sv, unit);
}
// do the action only if one of the scales/moves is greater than half the last significant
// digit in the spinbox (currently spinboxes have 3 fractional digits, so that makes 0.0005). If
// the value was changed by the user, the difference will be at least that much; otherwise it's
// just rounding difference between the spinbox value and actual value, so no action is
// performed
char const * const actionkey = ( mh > 5e-4 ? "selector:toolbar:move:horizontal" :
sh > 5e-4 ? "selector:toolbar:scale:horizontal" :
mv > 5e-4 ? "selector:toolbar:move:vertical" :
sv > 5e-4 ? "selector:toolbar:scale:vertical" : NULL );
if (actionkey != NULL) {
// FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed
sp_desktop_canvas(desktop)->forceFullRedrawAfterInterruptions(0);
int transform_stroke = prefs->getBool("/options/transform/stroke", true) ? 1 : 0;
Geom::Affine scaler;
if (bbox_type == SPItem::VISUAL_BBOX) {
scaler = get_scale_transform_for_variable_stroke (*bbox_vis, *bbox_geom, transform_stroke, x0, y0, x1, y1);
} else {
// 1) We could have use the newer get_scale_transform_for_variable_stroke() here, but to avoid regressions
// we'll just use the old get_scale_transform_for_uniform_stroke() for now.
// 2) get_scale_transform_for_uniform_stroke() is intended for visual bounding boxes, not geometrical ones!
// we'll trick it into using a geometric bounding box though, by setting the stroke width to zero
scaler = get_scale_transform_for_uniform_stroke (*bbox_geom, 0, false, x0, y0, x1, y1);
}
sp_selection_apply_affine(selection, scaler);
DocumentUndo::maybeDone(document, actionkey, SP_VERB_CONTEXT_SELECT,
_("Transform by toolbar"));
// resume interruptibility
sp_desktop_canvas(desktop)->endForcedFullRedraws();
}
g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
}
void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
{
/* Width */
gchar const* labels[] = {_("(narrow spray)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad spray)")};
gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "SprayWidthAction",
_("Width"), _("Width:"), _("The width of the spray area (relative to the visible canvas area)"),
"/tools/spray/width", 15,
GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-spray",
1, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_spray_width_value_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
}
{
/* Mean */
gchar const* labels[] = {_("(default)"), 0, 0, 0, 0, 0, 0, _("(maximum mean)")};
gdouble values[] = {0, 5, 10, 20, 30, 50, 70, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "SprayMeanAction",
_("Focus"), _("Focus:"), _("0 to spray a spot; increase to enlarge the ring radius"),
"/tools/spray/mean", 0,
GTK_WIDGET(desktop->canvas), holder, TRUE, "spray-mean",
0, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_spray_mean_value_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
}
{
/* Standard_deviation */
gchar const* labels[] = {_("(minimum scatter)"), 0, 0, 0, 0, 0, _("(default)"), _("(maximum scatter)")};
gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "SprayStandard_deviationAction",
C_("Spray tool", "Scatter"), C_("Spray tool", "Scatter:"), _("Increase to scatter sprayed objects"),
"/tools/spray/standard_deviation", 70,
GTK_WIDGET(desktop->canvas), holder, TRUE, "spray-standard_deviation",
1, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_spray_standard_deviation_value_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
}
/* Mode */
{
GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Spray with copies"),
1, _("Spray copies of the initial selection"),
2, INKSCAPE_ICON("spray-mode-copy"),
-1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Spray with clones"),
1, _("Spray clones of the initial selection"),
2, INKSCAPE_ICON("spray-mode-clone"),
-1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Spray single path"),
1, _("Spray objects in a single path"),
2, INKSCAPE_ICON("spray-mode-union"),
-1 );
EgeSelectOneAction* act = ege_select_one_action_new( "SprayModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act, "short_label", _("Mode:"), NULL );
gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
g_object_set_data( holder, "mode_action", act );
ege_select_one_action_set_appearance( act, "full" );
ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
ege_select_one_action_set_icon_column( act, 2 );
ege_select_one_action_set_icon_size( act, secondarySize );
ege_select_one_action_set_tooltip_column( act, 1 );
gint mode = prefs->getInt("/tools/spray/mode", 1);
ege_select_one_action_set_active( act, mode );
g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_spray_mode_changed), holder );
g_object_set_data( G_OBJECT(holder), "spray_tool_mode", act);
}
{ /* Population */
gchar const* labels[] = {_("(low population)"), 0, 0, 0, _("(default)"), 0, _("(high population)")};
gdouble values[] = {5, 20, 35, 50, 70, 85, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "SprayPopulationAction",
_("Amount"), _("Amount:"),
_("Adjusts the number of items sprayed per click"),
"/tools/spray/population", 70,
GTK_WIDGET(desktop->canvas), holder, TRUE, "spray-population",
1, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_spray_population_value_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
g_object_set_data( holder, "spray_population", eact );
}
/* Use Pressure button */
{
InkToggleAction* act = ink_toggle_action_new( "SprayPressureAction",
_("Pressure"),
_("Use the pressure of the input device to alter the amount of sprayed objects"),
INKSCAPE_ICON("draw-use-pressure"),
Inkscape::ICON_SIZE_DECORATION );
gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressure");
g_signal_connect(holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
}
{ /* Rotation */
gchar const* labels[] = {_("(default)"), 0, 0, 0, 0, 0, 0, _("(high rotation variation)")};
gdouble values[] = {0, 10, 25, 35, 50, 60, 80, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "SprayRotationAction",
_("Rotation"), _("Rotation:"),
// xgettext:no-c-format
_("Variation of the rotation of the sprayed objects; 0% for the same rotation than the original object"),
"/tools/spray/rotation_variation", 0,
GTK_WIDGET(desktop->canvas), holder, TRUE, "spray-rotation",
0, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_spray_rotation_value_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
g_object_set_data( holder, "spray_rotation", eact );
}
{ /* Scale */
gchar const* labels[] = {_("(default)"), 0, 0, 0, 0, 0, 0, _("(high scale variation)")};
gdouble values[] = {0, 10, 25, 35, 50, 60, 80, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "SprayScaleAction",
C_("Spray tool", "Scale"), C_("Spray tool", "Scale:"),
// xgettext:no-c-format
_("Variation in the scale of the sprayed objects; 0% for the same scale than the original object"),
"/tools/spray/scale_variation", 0,
GTK_WIDGET(desktop->canvas), holder, TRUE, "spray-scale",
0, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_spray_scale_value_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
g_object_set_data( holder, "spray_scale", eact );
}
}
static gint sp_dropper_context_root_handler(SPEventContext *event_context, GdkEvent *event)
{
SPDropperContext *dc = (SPDropperContext *) event_context;
int ret = FALSE;
SPDesktop *desktop = event_context->desktop;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int pick = prefs->getInt("/tools/dropper/pick", SP_DROPPER_PICK_VISIBLE);
bool setalpha = prefs->getBool("/tools/dropper/setalpha", true);
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event->button.button == 1 && !event_context->space_panning) {
dc->centre = Geom::Point(event->button.x, event->button.y);
dc->dragging = TRUE;
ret = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (event->motion.state & GDK_BUTTON2_MASK) {
// pass on middle-drag
ret = FALSE;
break;
} else if (!event_context->space_panning) {
// otherwise, constantly calculate color no matter is any button pressed or not
double rw = 0.0;
double W(0), R(0), G(0), B(0), A(0);
if (dc->dragging) {
// calculate average
// radius
rw = std::min(Geom::L2(Geom::Point(event->button.x, event->button.y) - dc->centre), 400.0);
if (rw == 0) { // happens sometimes, little idea why...
break;
}
Geom::Point const cd = desktop->w2d(dc->centre);
Geom::Matrix const w2dt = desktop->w2d();
const double scale = rw * w2dt.descrim();
Geom::Matrix const sm( Geom::Scale(scale, scale) * Geom::Translate(cd) );
sp_canvas_item_affine_absolute(dc->area, sm);
sp_canvas_item_show(dc->area);
/* Get buffer */
const int x0 = (int) floor(dc->centre[Geom::X] - rw);
const int y0 = (int) floor(dc->centre[Geom::Y] - rw);
const int x1 = (int) ceil(dc->centre[Geom::X] + rw);
const int y1 = (int) ceil(dc->centre[Geom::Y] + rw);
if ((x1 > x0) && (y1 > y0)) {
NRPixBlock pb;
nr_pixblock_setup_fast(&pb, NR_PIXBLOCK_MODE_R8G8B8A8P, x0, y0, x1, y1, TRUE);
/* fixme: (Lauris) */
sp_canvas_arena_render_pixblock(SP_CANVAS_ARENA(sp_desktop_drawing(desktop)), &pb);
for (int y = y0; y < y1; y++) {
const unsigned char *s = NR_PIXBLOCK_PX(&pb) + (y - y0) * pb.rs;
for (int x = x0; x < x1; x++) {
const double dx = x - dc->centre[Geom::X];
const double dy = y - dc->centre[Geom::Y];
const double w = exp(-((dx * dx) + (dy * dy)) / (rw * rw));
W += w;
R += w * s[0];
G += w * s[1];
B += w * s[2];
A += w * s[3];
s += 4;
}
}
nr_pixblock_release(&pb);
R = (R + 0.001) / (255.0 * W);
G = (G + 0.001) / (255.0 * W);
B = (B + 0.001) / (255.0 * W);
A = (A + 0.001) / (255.0 * W);
R = CLAMP(R, 0.0, 1.0);
G = CLAMP(G, 0.0, 1.0);
B = CLAMP(B, 0.0, 1.0);
A = CLAMP(A, 0.0, 1.0);
}
} else {
// pick single pixel
NRPixBlock pb;
int x = (int) floor(event->button.x);
int y = (int) floor(event->button.y);
nr_pixblock_setup_fast(&pb, NR_PIXBLOCK_MODE_R8G8B8A8P, x, y, x+1, y+1, TRUE);
sp_canvas_arena_render_pixblock(SP_CANVAS_ARENA(sp_desktop_drawing(desktop)), &pb);
const unsigned char *s = NR_PIXBLOCK_PX(&pb);
R = s[0] / 255.0;
G = s[1] / 255.0;
B = s[2] / 255.0;
A = s[3] / 255.0;
}
if (pick == SP_DROPPER_PICK_VISIBLE) {
// compose with page color
guint32 bg = sp_desktop_namedview(desktop)->pagecolor;
R = R + (SP_RGBA32_R_F(bg)) * (1 - A);
G = G + (SP_RGBA32_G_F(bg)) * (1 - A);
B = B + (SP_RGBA32_B_F(bg)) * (1 - A);
A = 1.0;
} else {
// un-premultiply color channels
if (A > 0) {
R /= A;
G /= A;
B /= A;
}
}
if (fabs(A) < 1e-4) {
A = 0; // suppress exponentials, CSS does not allow that
}
// remember color
dc->R = R;
dc->G = G;
dc->B = B;
dc->alpha = A;
// status message
double alpha_to_set = setalpha? dc->alpha : 1.0;
guint32 c32 = SP_RGBA32_F_COMPOSE(R, G, B, alpha_to_set);
gchar c[64];
sp_svg_write_color(c, sizeof(c), c32);
// alpha of color under cursor, to show in the statusbar
// locale-sensitive printf is OK, since this goes to the UI, not into SVG
gchar *alpha = g_strdup_printf(_(" alpha %.3g"), alpha_to_set);
// where the color is picked, to show in the statusbar
gchar *where = dc->dragging ? g_strdup_printf(_(", averaged with radius %d"), (int) rw) : g_strdup_printf(_(" under cursor"));
// message, to show in the statusbar
const gchar *message = dc->dragging ? _("<b>Release mouse</b> to set color.") : _("<b>Click</b> to set fill, <b>Shift+click</b> to set stroke; <b>drag</b> to average color in area; with <b>Alt</b> to pick inverse color; <b>Ctrl+C</b> to copy the color under mouse to clipboard");
event_context->defaultMessageContext()->setF(
Inkscape::NORMAL_MESSAGE,
"<b>%s%s</b>%s. %s", c,
(pick == SP_DROPPER_PICK_VISIBLE)? "" : alpha,
where, message
);
g_free(where);
g_free(alpha);
ret = TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 1 && !event_context->space_panning)
{
sp_canvas_item_hide(dc->area);
dc->dragging = FALSE;
double alpha_to_set = setalpha? dc->alpha : 1.0;
// do the actual color setting
sp_desktop_set_color(desktop,
(event->button.state & GDK_MOD1_MASK)?
ColorRGBA(1 - dc->R, 1 - dc->G, 1 - dc->B, alpha_to_set) : ColorRGBA(dc->R, dc->G, dc->B, alpha_to_set),
false, !(event->button.state & GDK_SHIFT_MASK));
// REJON: set aux. toolbar input to hex color!
if (!(sp_desktop_selection(desktop)->isEmpty())) {
sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_DROPPER,
_("Set picked color"));
}
ret = TRUE;
}
break;
case GDK_KEY_PRESS:
switch (get_group0_keyval(&event->key)) {
case GDK_Up:
case GDK_Down:
case GDK_KP_Up:
case GDK_KP_Down:
// prevent the zoom field from activation
if (!MOD__CTRL_ONLY) {
ret = TRUE;
}
break;
case GDK_Escape:
sp_desktop_selection(desktop)->clear();
default:
break;
}
break;
default:
break;
}
if (!ret) {
if (((SPEventContextClass *) parent_class)->root_handler) {
ret = ((SPEventContextClass *) parent_class)->root_handler(event_context, event);
}
}
return ret;
}
GtkWidget *
sp_find_dialog_old (void)
{
if (!dlg)
{
gchar title[500];
sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_FIND), title);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
dlg = sp_window_new (title, TRUE);
if (x == -1000 || y == -1000) {
x = prefs->getInt(prefs_path + "x", -1000);
y = prefs->getInt(prefs_path + "y", -1000);
}
if (w ==0 || h == 0) {
w = prefs->getInt(prefs_path + "w", 0);
h = prefs->getInt(prefs_path + "h", 0);
}
// if (x<0) x=0;
// if (y<0) y=0;
if (w && h)
gtk_window_resize ((GtkWindow *) dlg, w, h);
if (x >= 0 && y >= 0 && (x < (gdk_screen_width()-MIN_ONSCREEN_DISTANCE)) && (y < (gdk_screen_height()-MIN_ONSCREEN_DISTANCE))) {
gtk_window_move ((GtkWindow *) dlg, x, y);
} else {
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
}
sp_transientize (dlg);
wd.win = dlg;
wd.stop = 0;
g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd );
gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_find_dialog_destroy), NULL );
gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_find_dialog_delete), dlg);
g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_find_dialog_delete), dlg);
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg);
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg);
GtkTooltips *tt = gtk_tooltips_new ();
gtk_container_set_border_width (GTK_CONTAINER (dlg), 4);
/* Toplevel vbox */
GtkWidget *vb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), vb);
sp_find_new_searchfield (dlg, vb, _("_Text: "), "text", tt, _("Find objects by their text content (exact or partial match)"));
sp_find_new_searchfield (dlg, vb, _("_ID: "), "id", tt, _("Find objects by the value of the id attribute (exact or partial match)"));
sp_find_new_searchfield (dlg, vb, _("_Style: "), "style", tt, _("Find objects by the value of the style attribute (exact or partial match)"));
sp_find_new_searchfield (dlg, vb, _("_Attribute: "), "attr", tt ,_("Find objects by the name of an attribute (exact or partial match)"));
gtk_widget_show_all (vb);
GtkWidget *types = sp_find_types ();
gtk_object_set_data (GTK_OBJECT (dlg), "types", types);
gtk_box_pack_start (GTK_BOX (vb), types, FALSE, FALSE, 0);
{
GtkWidget *w = gtk_hseparator_new ();
gtk_widget_show (w);
gtk_box_pack_start (GTK_BOX (vb), w, FALSE, FALSE, 3);
{
GtkWidget *b = gtk_check_button_new_with_mnemonic (_("Search in s_election"));
gtk_widget_show (b);
gtk_toggle_button_set_active ((GtkToggleButton *) b, FALSE);
gtk_object_set_data (GTK_OBJECT (dlg), "inselection", b);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Limit search to the current selection"), NULL);
gtk_box_pack_start (GTK_BOX (vb), b, FALSE, FALSE, 0);
}
{
GtkWidget *b = gtk_check_button_new_with_mnemonic (_("Search in current _layer"));
gtk_widget_show (b);
gtk_toggle_button_set_active ((GtkToggleButton *) b, FALSE);
gtk_object_set_data (GTK_OBJECT (dlg), "inlayer", b);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Limit search to the current layer"), NULL);
gtk_box_pack_start (GTK_BOX (vb), b, FALSE, FALSE, 0);
}
{
GtkWidget *b = gtk_check_button_new_with_mnemonic (_("Include _hidden"));
gtk_widget_show (b);
gtk_toggle_button_set_active ((GtkToggleButton *) b, FALSE);
gtk_object_set_data (GTK_OBJECT (dlg), "includehidden", b);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Include hidden objects in search"), NULL);
gtk_box_pack_start (GTK_BOX (vb), b, FALSE, FALSE, 0);
}
{
GtkWidget *b = gtk_check_button_new_with_mnemonic (_("Include l_ocked"));
gtk_widget_show (b);
gtk_toggle_button_set_active ((GtkToggleButton *) b, FALSE);
gtk_object_set_data (GTK_OBJECT (dlg), "includelocked", b);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Include locked objects in search"), NULL);
gtk_box_pack_start (GTK_BOX (vb), b, FALSE, FALSE, 0);
}
}
{
GtkWidget *hb = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hb);
gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);
// TRANSLATORS: "Clear" is a verb here
sp_find_new_button (dlg, hb, _("_Clear"), tt, _("Clear values"), sp_find_dialog_reset);
sp_find_new_button (dlg, hb, _("_Find"), tt, _("Select objects matching all of the fields you filled in"), sp_find_dialog_find);
}
}
gtk_widget_show((GtkWidget *) dlg);
gtk_window_present ((GtkWindow *) dlg);
sp_find_dialog_reset (NULL, G_OBJECT (dlg));
return dlg;
}
AlignAndDistribute::AlignAndDistribute()
: UI::Widget::Panel ("", "/dialogs/align", SP_VERB_DIALOG_ALIGN_DISTRIBUTE),
randomize_bbox(),
_alignFrame(_("Align")),
_distributeFrame(_("Distribute")),
_rearrangeFrame(_("Rearrange")),
_removeOverlapFrame(_("Remove overlaps")),
_nodesFrame(_("Nodes")),
#if WITH_GTKMM_3_0
_alignTable(),
_distributeTable(),
_rearrangeTable(),
_removeOverlapTable(),
_nodesTable(),
#else
_alignTable(2, 6, true),
_distributeTable(2, 6, true),
_rearrangeTable(1, 5, false),
_removeOverlapTable(1, 5, false),
_nodesTable(1, 4, true),
#endif
_anchorLabel(_("Relative to: ")),
_selgrpLabel(_("_Treat selection as group: "), 1)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
//Instanciate the align buttons
addAlignButton(INKSCAPE_ICON("align-horizontal-right-to-anchor"),
_("Align right edges of objects to the left edge of the anchor"),
0, 0);
addAlignButton(INKSCAPE_ICON("align-horizontal-left"),
_("Align left edges"),
0, 1);
addAlignButton(INKSCAPE_ICON("align-horizontal-center"),
_("Center on vertical axis"),
0, 2);
addAlignButton(INKSCAPE_ICON("align-horizontal-right"),
_("Align right sides"),
0, 3);
addAlignButton(INKSCAPE_ICON("align-horizontal-left-to-anchor"),
_("Align left edges of objects to the right edge of the anchor"),
0, 4);
addAlignButton(INKSCAPE_ICON("align-vertical-bottom-to-anchor"),
_("Align bottom edges of objects to the top edge of the anchor"),
1, 0);
addAlignButton(INKSCAPE_ICON("align-vertical-top"),
_("Align top edges"),
1, 1);
addAlignButton(INKSCAPE_ICON("align-vertical-center"),
_("Center on horizontal axis"),
1, 2);
addAlignButton(INKSCAPE_ICON("align-vertical-bottom"),
_("Align bottom edges"),
1, 3);
addAlignButton(INKSCAPE_ICON("align-vertical-top-to-anchor"),
_("Align top edges of objects to the bottom edge of the anchor"),
1, 4);
//Baseline aligns
addBaselineButton(INKSCAPE_ICON("align-horizontal-baseline"),
_("Align baseline anchors of texts horizontally"),
0, 5, this->align_table(), Geom::X, false);
addBaselineButton(INKSCAPE_ICON("align-vertical-baseline"),
_("Align baselines of texts"),
1, 5, this->align_table(), Geom::Y, false);
//The distribute buttons
addDistributeButton(INKSCAPE_ICON("distribute-horizontal-gaps"),
_("Make horizontal gaps between objects equal"),
0, 4, true, Geom::X, .5, .5);
addDistributeButton(INKSCAPE_ICON("distribute-horizontal-left"),
_("Distribute left edges equidistantly"),
0, 1, false, Geom::X, 1., 0.);
addDistributeButton(INKSCAPE_ICON("distribute-horizontal-center"),
_("Distribute centers equidistantly horizontally"),
0, 2, false, Geom::X, .5, .5);
addDistributeButton(INKSCAPE_ICON("distribute-horizontal-right"),
_("Distribute right edges equidistantly"),
0, 3, false, Geom::X, 0., 1.);
addDistributeButton(INKSCAPE_ICON("distribute-vertical-gaps"),
_("Make vertical gaps between objects equal"),
1, 4, true, Geom::Y, .5, .5);
addDistributeButton(INKSCAPE_ICON("distribute-vertical-top"),
_("Distribute top edges equidistantly"),
1, 1, false, Geom::Y, 0, 1);
addDistributeButton(INKSCAPE_ICON("distribute-vertical-center"),
_("Distribute centers equidistantly vertically"),
1, 2, false, Geom::Y, .5, .5);
addDistributeButton(INKSCAPE_ICON("distribute-vertical-bottom"),
_("Distribute bottom edges equidistantly"),
1, 3, false, Geom::Y, 1., 0.);
//Baseline distribs
addBaselineButton(INKSCAPE_ICON("distribute-horizontal-baseline"),
_("Distribute baseline anchors of texts horizontally"),
0, 5, this->distribute_table(), Geom::X, true);
addBaselineButton(INKSCAPE_ICON("distribute-vertical-baseline"),
_("Distribute baselines of texts vertically"),
1, 5, this->distribute_table(), Geom::Y, true);
// Rearrange
//Graph Layout
addGraphLayoutButton(INKSCAPE_ICON("distribute-graph"),
_("Nicely arrange selected connector network"),
0, 0);
addExchangePositionsButton(INKSCAPE_ICON("exchange-positions"),
_("Exchange positions of selected objects - selection order"),
0, 1);
addExchangePositionsByZOrderButton(INKSCAPE_ICON("exchange-positions-zorder"),
_("Exchange positions of selected objects - stacking order"),
0, 2);
addExchangePositionsClockwiseButton(INKSCAPE_ICON("exchange-positions-clockwise"),
_("Exchange positions of selected objects - clockwise rotate"),
0, 3);
//Randomize & Unclump
addRandomizeButton(INKSCAPE_ICON("distribute-randomize"),
_("Randomize centers in both dimensions"),
0, 4);
addUnclumpButton(INKSCAPE_ICON("distribute-unclump"),
_("Unclump objects: try to equalize edge-to-edge distances"),
0, 5);
//Remove overlaps
addRemoveOverlapsButton(INKSCAPE_ICON("distribute-remove-overlaps"),
_("Move objects as little as possible so that their bounding boxes do not overlap"),
0, 0);
//Node Mode buttons
// NOTE: "align nodes vertically" means "move nodes vertically until they align on a common
// _horizontal_ line". This is analogous to what the "align-vertical-center" icon means.
// There is no doubt some ambiguity. For this reason the descriptions are different.
addNodeButton(INKSCAPE_ICON("align-vertical-node"),
_("Align selected nodes to a common horizontal line"),
0, Geom::X, false);
addNodeButton(INKSCAPE_ICON("align-horizontal-node"),
_("Align selected nodes to a common vertical line"),
1, Geom::Y, false);
addNodeButton(INKSCAPE_ICON("distribute-horizontal-node"),
_("Distribute selected nodes horizontally"),
2, Geom::X, true);
addNodeButton(INKSCAPE_ICON("distribute-vertical-node"),
_("Distribute selected nodes vertically"),
3, Geom::Y, true);
//Rest of the widgetry
_combo.append(_("Last selected"));
_combo.append(_("First selected"));
_combo.append(_("Biggest object"));
_combo.append(_("Smallest object"));
_combo.append(_("Page"));
_combo.append(_("Drawing"));
_combo.append(_("Selection"));
_combo.set_active(prefs->getInt("/dialogs/align/align-to", 6));
_combo.signal_changed().connect(sigc::mem_fun(*this, &AlignAndDistribute::on_ref_change));
_anchorBox.pack_end(_combo, false, false);
_anchorBox.pack_end(_anchorLabel, false, false);
_selgrpLabel.set_mnemonic_widget(_selgrp);
_selgrpBox.pack_end(_selgrp, false, false);
_selgrpBox.pack_end(_selgrpLabel, false, false);
_selgrp.set_active(prefs->getBool("/dialogs/align/sel-as-groups"));
_selgrp.signal_toggled().connect(sigc::mem_fun(*this, &AlignAndDistribute::on_selgrp_toggled));
// Right align the buttons
_alignTableBox.pack_end(_alignTable, false, false);
_distributeTableBox.pack_end(_distributeTable, false, false);
_rearrangeTableBox.pack_end(_rearrangeTable, false, false);
_removeOverlapTableBox.pack_end(_removeOverlapTable, false, false);
_nodesTableBox.pack_end(_nodesTable, false, false);
_alignBox.pack_start(_anchorBox);
_alignBox.pack_start(_selgrpBox);
_alignBox.pack_start(_alignTableBox);
_alignFrame.add(_alignBox);
_distributeFrame.add(_distributeTableBox);
_rearrangeFrame.add(_rearrangeTableBox);
_removeOverlapFrame.add(_removeOverlapTableBox);
_nodesFrame.add(_nodesTableBox);
Gtk::Box *contents = _getContents();
contents->set_spacing(4);
// Notebook for individual transformations
contents->pack_start(_alignFrame, true, true);
contents->pack_start(_distributeFrame, true, true);
contents->pack_start(_rearrangeFrame, true, true);
contents->pack_start(_removeOverlapFrame, true, true);
contents->pack_start(_nodesFrame, true, true);
//Connect to the global tool change signal
g_signal_connect (G_OBJECT (INKSCAPE), "set_eventcontext", G_CALLBACK (on_tool_changed), this);
// Connect to the global selection change, to invalidate cached randomize_bbox
g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (on_selection_changed), this);
randomize_bbox = Geom::OptRect();
_desktopChangeConn = _deskTrack.connectDesktopChanged( sigc::mem_fun(*this, &AlignAndDistribute::setDesktop) );
_deskTrack.connect(GTK_WIDGET(gobj()));
show_all_children();
on_tool_changed (NULL, NULL, this); // set current mode
}
/**
* Gradient auxiliary toolbar construction and setup.
*
*/
void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* holder)
{
Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
/* New gradient linear or radial */
{
GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("linear"), 1, _("Create linear gradient"), 2, INKSCAPE_ICON("paint-gradient-linear"), -1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("radial"), 1, _("Create radial (elliptic or circular) gradient"), 2, INKSCAPE_ICON("paint-gradient-radial"), -1 );
EgeSelectOneAction* act = ege_select_one_action_new( "GradientNewTypeAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act, "short_label", _("New:"), NULL );
gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
g_object_set_data( holder, "gradient_new_type_action", act );
ege_select_one_action_set_appearance( act, "full" );
ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
ege_select_one_action_set_icon_column( act, 2 );
ege_select_one_action_set_tooltip_column( act, 1 );
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
gint mode = prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) != SP_GRADIENT_TYPE_LINEAR;
ege_select_one_action_set_active( act, mode );
g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(gr_new_type_changed), holder );
}
/* New gradient on fill or stroke*/
{
GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("fill"), 1, _("Create gradient in the fill"), 2, INKSCAPE_ICON("object-fill"), -1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("stroke"), 1, _("Create gradient in the stroke"), 2, INKSCAPE_ICON("object-stroke"), -1 );
EgeSelectOneAction* act = ege_select_one_action_new( "GradientNewFillStrokeAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act, "short_label", _("on:"), NULL );
gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
g_object_set_data( holder, "gradient_new_fillstroke_action", act );
ege_select_one_action_set_appearance( act, "full" );
ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
ege_select_one_action_set_icon_column( act, 2 );
ege_select_one_action_set_tooltip_column( act, 1 );
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Inkscape::PaintTarget fsmode = (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
ege_select_one_action_set_active( act, (fsmode == Inkscape::FOR_FILL) ? 0 : 1 );
g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(gr_new_fillstroke_changed), holder );
}
/* Gradient Select list*/
{
GtkListStore *store = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, _("No gradient"), 1, NULL, 2, NULL, -1);
EgeSelectOneAction* act1 = ege_select_one_action_new( "GradientSelectGradientAction", _("Select"), (_("Choose a gradient")), NULL, GTK_TREE_MODEL(store) );
g_object_set( act1, "short_label", _("Select:"), NULL );
ege_select_one_action_set_appearance( act1, "compact" );
gtk_action_set_sensitive( GTK_ACTION(act1), FALSE );
g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(gr_gradient_combo_changed), desktop );
gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
g_object_set_data( holder, "gradient_select_combo_action", act1 );
}
// Gradient Repeat type
{
GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, C_("Gradient repeat type", "None"), 1, SP_GRADIENT_SPREAD_PAD, -1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, _("Reflected"), 1, SP_GRADIENT_SPREAD_REFLECT, -1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, _("Direct"), 1, SP_GRADIENT_SPREAD_REPEAT, -1 );
EgeSelectOneAction* act1 = ege_select_one_action_new( "GradientSelectRepeatAction", _("Repeat"),
(// TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/pservers.html#LinearGradientSpreadMethodAttribute
_("Whether to fill with flat color beyond the ends of the gradient vector "
"(spreadMethod=\"pad\"), or repeat the gradient in the same direction "
"(spreadMethod=\"repeat\"), or repeat the gradient in alternating opposite "
"directions (spreadMethod=\"reflect\")")),
NULL, GTK_TREE_MODEL(model) );
g_object_set( act1, "short_label", _("Repeat:"), NULL );
ege_select_one_action_set_appearance( act1, "compact" );
gtk_action_set_sensitive( GTK_ACTION(act1), FALSE );
g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(gr_spread_change), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
g_object_set_data( holder, "gradient_select_repeat_action", act1 );
}
/* Gradient Stop list */
{
GtkListStore *store = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, _("No stops"), 1, NULL, 2, NULL, -1);
EgeSelectOneAction* act1 = ege_select_one_action_new( "GradientEditStopsAction", _("Stops"), _("Select a stop for the current gradient"), NULL, GTK_TREE_MODEL(store) );
g_object_set( act1, "short_label", _("Stops:"), NULL );
ege_select_one_action_set_appearance( act1, "compact" );
gtk_action_set_sensitive( GTK_ACTION(act1), FALSE );
g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(gr_stop_combo_changed), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
g_object_set_data( holder, "gradient_stops_combo_action", act1 );
}
/* Offset */
{
EgeAdjustmentAction* eact = 0;
eact = create_adjustment_action( "GradientEditOffsetAction",
_("Offset"), C_("Gradient", "Offset:"), _("Offset of selected stop"),
"/tools/gradient/stopoffset", 0,
GTK_WIDGET(desktop->canvas), holder, FALSE, NULL,
0.0, 1.0, 0.01, 0.1,
0, 0, 0,
gr_stop_offset_adjustment_changed,
NULL /*unit tracker*/,
0.01, 2, 1.0);
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
g_object_set_data( holder, "offset_action", eact );
gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
}
/* Add stop */
{
InkAction* inky = ink_action_new( "GradientEditAddAction",
_("Insert new stop"),
_("Insert new stop"),
INKSCAPE_ICON("node-add"),
secondarySize );
g_object_set( inky, "short_label", _("Delete"), NULL );
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_add_stop), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
gtk_action_set_sensitive( GTK_ACTION(inky), FALSE );
g_object_set_data( holder, "gradient_stops_add_action", inky );
}
/* Delete stop */
{
InkAction* inky = ink_action_new( "GradientEditDeleteAction",
_("Delete stop"),
_("Delete stop"),
INKSCAPE_ICON("node-delete"),
secondarySize );
g_object_set( inky, "short_label", _("Delete"), NULL );
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_remove_stop), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
gtk_action_set_sensitive( GTK_ACTION(inky), FALSE );
g_object_set_data( holder, "gradient_stops_delete_action", inky );
}
/* Reverse */
{
InkAction* inky = ink_action_new( "GradientEditReverseAction",
_("Reverse"),
_("Reverse the direction of the gradient"),
INKSCAPE_ICON("object-flip-horizontal"),
secondarySize );
g_object_set( inky, "short_label", _("Delete"), NULL );
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_reverse), desktop );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
gtk_action_set_sensitive( GTK_ACTION(inky), FALSE );
g_object_set_data( holder, "gradient_stops_reverse_action", inky );
}
// Gradients Linked toggle
{
InkToggleAction* itact = ink_toggle_action_new( "GradientEditLinkAction",
_("Link gradients"),
_("Link gradients to change all related gradients"),
INKSCAPE_ICON("object-unlocked"),
Inkscape::ICON_SIZE_DECORATION );
g_object_set( itact, "short_label", "Lock", NULL );
g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(gr_linked_changed), desktop) ;
gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool linkedmode = prefs->getBool("/options/forkgradientvectors/value", true);
gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), !linkedmode );
}
g_object_set_data(holder, "desktop", desktop);
desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(&gradient_toolbox_check_ec), holder));
}
void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
sp_add_freehand_mode_toggle(mainActions, holder, true);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
EgeAdjustmentAction* eact = 0;
/* Tolerance */
{
gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), 0, 0, 0, 0, _("(few nodes, smooth)")};
gdouble values[] = {1, 10, 20, 30, 50, 75, 100};
eact = create_adjustment_action( "PencilToleranceAction",
_("Smoothing:"), _("Smoothing: "),
_("How much smoothing (simplifying) is applied to the line"),
"/tools/freehand/pencil/tolerance",
3.0,
GTK_WIDGET(desktop->canvas),
holder, TRUE, "altx-pencil",
1, 100.0, 0.5, 1.0,
labels, values, G_N_ELEMENTS(labels),
sp_pencil_tb_tolerance_value_changed,
NULL /*unit tracker*/,
1, 2);
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
}
/* advanced shape options */
freehand_add_advanced_shape_options(mainActions, holder, true);
/* Reset */
{
InkAction* inky = ink_action_new( "PencilResetAction",
_("Defaults"),
_("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
INKSCAPE_ICON("edit-clear"),
Inkscape::ICON_SIZE_SMALL_TOOLBAR );
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_pencil_tb_defaults), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
}
/* LPE simplify based tolerance */
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
InkToggleAction* itact = ink_toggle_action_new( "PencilLpeSimplify",
_("LPE based interactive simplify"),
_("LPE based interactive simplify"),
INKSCAPE_ICON("interactive_simplify"),
Inkscape::ICON_SIZE_SMALL_TOOLBAR );
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), prefs->getInt("/tools/freehand/pencil/simplify", 0) );
g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(freehand_simplify_lpe), holder) ;
gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
}
/* LPE simplify flatten */
{
InkAction* inky = ink_action_new( "PencilLpeSimplifyFlatten",
_("LPE simplify flatten"),
_("LPE simplify flatten"),
INKSCAPE_ICON("flatten_simplify"),
Inkscape::ICON_SIZE_SMALL_TOOLBAR );
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_simplify_flatten), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
g_object_set_data( holder, "flatten_simplify", inky );
if (!prefs->getInt("/tools/freehand/pencil/simplify", 0)) {
gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_simplify") ), false );
}
}
g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
}
/**
* Sensing a movement of the original, this function attempts to compensate for it in such a way
* that the clone stays unmoved or moves in parallel (depending on user setting) regardless of the
* clone's transform.
*/
void SPUse::move_compensate(Geom::Affine const *mp) {
// the clone is orphaned; or this is not a real use, but a clone of another use;
// we skip it, otherwise duplicate compensation will occur
if (this->cloned) {
return;
}
// never compensate uses which are used in flowtext
if (parent && dynamic_cast<SPFlowregion *>(parent)) {
return;
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint mode = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_PARALLEL);
// user wants no compensation
if (mode == SP_CLONE_COMPENSATION_NONE)
return;
Geom::Affine m(*mp);
Geom::Affine t = this->get_parent_transform();
Geom::Affine clone_move = t.inverse() * m * t;
// this is not a simple move, do not try to compensate
if (!(m.isTranslation())){
//BUT move clippaths accordingly.
//if clone has a clippath, move it accordingly
if(clip_ref->getObject()){
SPObject *clip = clip_ref->getObject()->firstChild() ;
while(clip){
SPItem *item = (SPItem*) clip;
if(item){
item->transform *= m;
Geom::Affine identity;
item->doWriteTransform(clip->getRepr(),item->transform, &identity);
}
clip = clip->getNext();
}
}
if(mask_ref->getObject()){
SPObject *mask = mask_ref->getObject()->firstChild() ;
while(mask){
SPItem *item = (SPItem*) mask;
if(item){
item->transform *= m;
Geom::Affine identity;
item->doWriteTransform(mask->getRepr(),item->transform, &identity);
}
mask = mask->getNext();
}
}
return;
}
// restore item->transform field from the repr, in case it was changed by seltrans
this->readAttr ("transform");
// calculate the compensation matrix and the advertized movement matrix
Geom::Affine advertized_move;
if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
clone_move = clone_move.inverse() * m;
advertized_move = m;
} else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
clone_move = clone_move.inverse();
advertized_move.setIdentity();
} else {
g_assert_not_reached();
}
//if clone has a clippath, move it accordingly
if(clip_ref->getObject()){
SPObject *clip = clip_ref->getObject()->firstChild() ;
while(clip){
SPItem *item = (SPItem*) clip;
if(item){
item->transform *= clone_move.inverse();
Geom::Affine identity;
item->doWriteTransform(clip->getRepr(),item->transform, &identity);
}
clip = clip->getNext();
}
}
if(mask_ref->getObject()){
SPObject *mask = mask_ref->getObject()->firstChild() ;
while(mask){
SPItem *item = (SPItem*) mask;
if(item){
item->transform *= clone_move.inverse();
Geom::Affine identity;
item->doWriteTransform(mask->getRepr(),item->transform, &identity);
}
mask = mask->getNext();
}
}
// commit the compensation
this->transform *= clone_move;
this->doWriteTransform(this->getRepr(), this->transform, &advertized_move);
this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
gchar *
sp_svg_transform_write(Geom::Matrix const &transform)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
double e = 0.000001 * transform.descrim();
int prec = prefs->getInt("/options/svgoutput/numericprecision", 8);
int min_exp = prefs->getInt("/options/svgoutput/minimumexponent", -8);
/* fixme: We could use t1 * t1 + t2 * t2 here instead */
if ( Geom::are_near(transform[1], 0.0, e) && Geom::are_near (transform[2], 0.0, e)) {
if (Geom::are_near (transform[4], 0.0, e) && Geom::are_near (transform[5], 0.0, e)) {
if (Geom::are_near (transform[0], 1.0, e) && Geom::are_near (transform[3], 1.0, e)) {
/* We are more or less identity */
return NULL;
} else {
/* We are more or less scale */
gchar c[256];
unsigned p = 0;
strcpy (c + p, "scale(");
p += 6;
p += sp_svg_number_write_de (c + p, transform[0], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[3], prec, min_exp);
c[p++] = ')';
c[p] = '\000';
g_assert( p <= sizeof(c) );
return g_strdup(c);
}
} else {
if (Geom::are_near (transform[0], 1.0, e) && Geom::are_near (transform[3], 1.0, e)) {
/* We are more or less translate */
gchar c[256];
unsigned p = 0;
strcpy (c + p, "translate(");
p += 10;
p += sp_svg_number_write_de (c + p, transform[4], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[5], prec, min_exp);
c[p++] = ')';
c[p] = '\000';
g_assert( p <= sizeof(c) );
return g_strdup(c);
} else {
gchar c[256];
unsigned p = 0;
strcpy (c + p, "matrix(");
p += 7;
p += sp_svg_number_write_de (c + p, transform[0], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[1], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[2], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[3], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[4], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[5], prec, min_exp);
c[p++] = ')';
c[p] = '\000';
g_assert( p <= sizeof(c) );
return g_strdup(c);
}
}
} else {
gchar c[256];
unsigned p = 0;
strcpy (c + p, "matrix(");
p += 7;
p += sp_svg_number_write_de (c + p, transform[0], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[1], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[2], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[3], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[4], prec, min_exp);
c[p++] = ',';
p += sp_svg_number_write_de (c + p, transform[5], prec, min_exp);
c[p++] = ')';
c[p] = '\000';
g_assert( p <= sizeof(c) );
return g_strdup(c);
}
}
gint sp_dt_guide_event(SPCanvasItem *item, GdkEvent *event, gpointer data)
{
static bool moved = false;
gint ret = FALSE;
SPGuide *guide = SP_GUIDE(data);
SPDesktop *desktop = static_cast<SPDesktop*>(g_object_get_data(G_OBJECT(item->canvas), "SPDesktop"));
switch (event->type) {
case GDK_2BUTTON_PRESS:
if (event->button.button == 1) {
drag_type = SP_DRAG_NONE;
sp_event_context_discard_delayed_snap_event(desktop->event_context);
sp_canvas_item_ungrab(item, event->button.time);
Inkscape::UI::Dialogs::GuidelinePropertiesDialog::showDialog(guide, desktop);
ret = TRUE;
}
break;
case GDK_BUTTON_PRESS:
if (event->button.button == 1) {
Geom::Point const event_w(event->button.x, event->button.y);
Geom::Point const event_dt(desktop->w2d(event_w));
// Due to the tolerance allowed when grabbing a guide, event_dt will generally
// be close to the guide but not just exactly on it. The drag origin calculated
// here must be exactly on the guide line though, otherwise
// small errors will occur once we snap, see
// https://bugs.launchpad.net/inkscape/+bug/333762
drag_origin = Geom::projection(event_dt, Geom::Line(guide->getPoint(), guide->angle()));
if (event->button.state & GDK_SHIFT_MASK) {
// with shift we rotate the guide
drag_type = SP_DRAG_ROTATE;
} else {
if (event->button.state & GDK_CONTROL_MASK) {
drag_type = SP_DRAG_MOVE_ORIGIN;
} else {
drag_type = SP_DRAG_TRANSLATE;
}
}
if (drag_type == SP_DRAG_ROTATE || drag_type == SP_DRAG_TRANSLATE) {
sp_canvas_item_grab(item,
( GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK ),
NULL,
event->button.time);
}
ret = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (drag_type != SP_DRAG_NONE) {
Geom::Point const motion_w(event->motion.x,
event->motion.y);
Geom::Point motion_dt(desktop->w2d(motion_w));
sp_event_context_snap_delay_handler(desktop->event_context, (gpointer) item, data, (GdkEventMotion *)event, Inkscape::UI::Tools::DelayedSnapEvent::GUIDE_HANDLER);
// This is for snapping while dragging existing guidelines. New guidelines,
// which are dragged off the ruler, are being snapped in sp_dt_ruler_event
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop, true, NULL, NULL, guide);
if (drag_type == SP_DRAG_MOVE_ORIGIN) {
// If we snap in guideConstrainedSnap() below, then motion_dt will
// be forced to be on the guide. If we don't snap however, then
// the origin should still be constrained to the guide. So let's do
// that explicitly first:
Geom::Line line(guide->getPoint(), guide->angle());
Geom::Coord t = line.nearestTime(motion_dt);
motion_dt = line.pointAt(t);
if (!(event->motion.state & GDK_SHIFT_MASK)) {
m.guideConstrainedSnap(motion_dt, *guide);
}
} else if (!((drag_type == SP_DRAG_ROTATE) && (event->motion.state & GDK_CONTROL_MASK))) {
// cannot use shift here to disable snapping, because we already use it for rotating the guide
Geom::Point temp;
if (drag_type == SP_DRAG_ROTATE) {
temp = guide->getPoint();
m.guideFreeSnap(motion_dt, temp, true, false);
guide->moveto(temp, false);
} else {
temp = guide->getNormal();
m.guideFreeSnap(motion_dt, temp, false, true);
guide->set_normal(temp, false);
}
}
m.unSetup();
switch (drag_type) {
case SP_DRAG_TRANSLATE:
{
guide->moveto(motion_dt, false);
break;
}
case SP_DRAG_ROTATE:
{
Geom::Point pt = motion_dt - guide->getPoint();
Geom::Angle angle(pt);
if (event->motion.state & GDK_CONTROL_MASK) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
unsigned const snaps = abs(prefs->getInt("/options/rotationsnapsperpi/value", 12));
bool const relative_snaps = prefs->getBool("/options/relativeguiderotationsnap/value", false);
if (snaps) {
if (relative_snaps) {
Geom::Angle orig_angle(guide->getNormal());
Geom::Angle snap_angle = angle - orig_angle;
double sections = floor(snap_angle.radians0() * snaps / M_PI + .5);
angle = (M_PI / snaps) * sections + orig_angle.radians0();
} else {
double sections = floor(angle.radians0() * snaps / M_PI + .5);
angle = (M_PI / snaps) * sections;
}
}
}
guide->set_normal(Geom::Point::polar(angle).cw(), false);
break;
}
case SP_DRAG_MOVE_ORIGIN:
{
guide->moveto(motion_dt, false);
break;
}
case SP_DRAG_NONE:
assert(false);
break;
}
moved = true;
desktop->set_coordinate_status(motion_dt);
ret = TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (drag_type != SP_DRAG_NONE && event->button.button == 1) {
sp_event_context_discard_delayed_snap_event(desktop->event_context);
if (moved) {
Geom::Point const event_w(event->button.x,
event->button.y);
Geom::Point event_dt(desktop->w2d(event_w));
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop, true, NULL, NULL, guide);
if (drag_type == SP_DRAG_MOVE_ORIGIN) {
// If we snap in guideConstrainedSnap() below, then motion_dt will
// be forced to be on the guide. If we don't snap however, then
// the origin should still be constrained to the guide. So let's
// do that explicitly first:
Geom::Line line(guide->getPoint(), guide->angle());
Geom::Coord t = line.nearestTime(event_dt);
event_dt = line.pointAt(t);
if (!(event->button.state & GDK_SHIFT_MASK)) {
m.guideConstrainedSnap(event_dt, *guide);
}
} else if (!((drag_type == SP_DRAG_ROTATE) && (event->motion.state & GDK_CONTROL_MASK))) {
// cannot use shift here to disable snapping, because we already use it for rotating the guide
Geom::Point temp;
if (drag_type == SP_DRAG_ROTATE) {
temp = guide->getPoint();
m.guideFreeSnap(event_dt, temp, true, false);
guide->moveto(temp, false);
} else {
temp = guide->getNormal();
m.guideFreeSnap(event_dt, temp, false, true);
guide->set_normal(temp, false);
}
}
m.unSetup();
if (sp_canvas_world_pt_inside_window(item->canvas, event_w)) {
switch (drag_type) {
case SP_DRAG_TRANSLATE:
{
guide->moveto(event_dt, true);
break;
}
case SP_DRAG_ROTATE:
{
Geom::Point pt = event_dt - guide->getPoint();
Geom::Angle angle(pt);
if (event->motion.state & GDK_CONTROL_MASK) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
unsigned const snaps = abs(prefs->getInt("/options/rotationsnapsperpi/value", 12));
bool const relative_snaps = prefs->getBool("/options/relativeguiderotationsnap/value", false);
if (snaps) {
if (relative_snaps) {
Geom::Angle orig_angle(guide->getNormal());
Geom::Angle snap_angle = angle - orig_angle;
double sections = floor(snap_angle.radians0() * snaps / M_PI + .5);
angle = (M_PI / snaps) * sections + orig_angle.radians0();
} else {
double sections = floor(angle.radians0() * snaps / M_PI + .5);
angle = (M_PI / snaps) * sections;
}
}
}
guide->set_normal(Geom::Point::polar(angle).cw(), true);
break;
}
case SP_DRAG_MOVE_ORIGIN:
{
guide->moveto(event_dt, true);
break;
}
case SP_DRAG_NONE:
assert(false);
break;
}
DocumentUndo::done(desktop->getDocument(), SP_VERB_NONE,
_("Move guide"));
} else {
/* Undo movement of any attached shapes. */
guide->moveto(guide->getPoint(), false);
guide->set_normal(guide->getNormal(), false);
sp_guide_remove(guide);
DocumentUndo::done(desktop->getDocument(), SP_VERB_NONE,
_("Delete guide"));
}
moved = false;
desktop->set_coordinate_status(event_dt);
}
drag_type = SP_DRAG_NONE;
sp_canvas_item_ungrab(item, event->button.time);
ret=TRUE;
}
break;
case GDK_ENTER_NOTIFY:
{
sp_guideline_set_color(SP_GUIDELINE(item), guide->getHiColor());
// set move or rotate cursor
Geom::Point const event_w(event->crossing.x, event->crossing.y);
if ((event->crossing.state & GDK_SHIFT_MASK) && (drag_type != SP_DRAG_MOVE_ORIGIN)) {
GdkCursor *guide_cursor;
guide_cursor = gdk_cursor_new (GDK_EXCHANGE);
gdk_window_set_cursor(gtk_widget_get_window (GTK_WIDGET(desktop->getCanvas())), guide_cursor);
#if GTK_CHECK_VERSION(3,0,0)
g_object_unref(guide_cursor);
#else
gdk_cursor_unref(guide_cursor);
#endif
} else {
GdkCursor *guide_cursor;
guide_cursor = gdk_cursor_new (GDK_HAND1);
gdk_window_set_cursor(gtk_widget_get_window (GTK_WIDGET(desktop->getCanvas())), guide_cursor);
#if GTK_CHECK_VERSION(3,0,0)
g_object_unref(guide_cursor);
#else
gdk_cursor_unref(guide_cursor);
#endif
}
char *guide_description = guide->description();
desktop->guidesMessageContext()->setF(Inkscape::NORMAL_MESSAGE, _("<b>Guideline</b>: %s"), guide_description);
g_free(guide_description);
break;
}
case GDK_LEAVE_NOTIFY:
sp_guideline_set_color(SP_GUIDELINE(item), guide->getColor());
// restore event context's cursor
gdk_window_set_cursor(gtk_widget_get_window (GTK_WIDGET(desktop->getCanvas())), desktop->event_context->cursor);
desktop->guidesMessageContext()->clear();
break;
case GDK_KEY_PRESS:
switch (Inkscape::UI::Tools::get_group0_keyval (&event->key)) {
case GDK_KEY_Delete:
case GDK_KEY_KP_Delete:
case GDK_KEY_BackSpace:
{
SPDocument *doc = guide->document;
sp_guide_remove(guide);
DocumentUndo::done(doc, SP_VERB_NONE, _("Delete guide"));
ret = TRUE;
sp_event_context_discard_delayed_snap_event(desktop->event_context);
break;
}
case GDK_KEY_Shift_L:
case GDK_KEY_Shift_R:
if (drag_type != SP_DRAG_MOVE_ORIGIN) {
GdkCursor *guide_cursor;
guide_cursor = gdk_cursor_new (GDK_EXCHANGE);
gdk_window_set_cursor(gtk_widget_get_window (GTK_WIDGET(desktop->getCanvas())), guide_cursor);
#if GTK_CHECK_VERSION(3,0,0)
g_object_unref(guide_cursor);
#else
gdk_cursor_unref(guide_cursor);
#endif
ret = TRUE;
break;
}
default:
// do nothing;
break;
}
break;
case GDK_KEY_RELEASE:
switch (Inkscape::UI::Tools::get_group0_keyval (&event->key)) {
case GDK_KEY_Shift_L:
case GDK_KEY_Shift_R:
GdkCursor *guide_cursor;
guide_cursor = gdk_cursor_new (GDK_EXCHANGE);
gdk_window_set_cursor(gtk_widget_get_window (GTK_WIDGET(desktop->getCanvas())), guide_cursor);
#if GTK_CHECK_VERSION(3,0,0)
g_object_unref(guide_cursor);
#else
gdk_cursor_unref(guide_cursor);
#endif
break;
default:
// do nothing;
break;
}
break;
default:
break;
}
return ret;
}
static gint
sp_select_context_root_handler(SPEventContext *event_context, GdkEvent *event)
{
SPItem *item = NULL;
SPItem *item_at_point = NULL, *group_at_point = NULL, *item_in_group = NULL;
gint ret = FALSE;
SPDesktop *desktop = event_context->desktop;
SPSelectContext *sc = SP_SELECT_CONTEXT(event_context);
Inkscape::SelTrans *seltrans = sc->_seltrans;
Inkscape::Selection *selection = sp_desktop_selection(desktop);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
// make sure we still have valid objects to move around
if (sc->item && SP_OBJECT_DOCUMENT( SP_OBJECT(sc->item))==NULL) {
sp_select_context_abort(event_context);
}
switch (event->type) {
case GDK_2BUTTON_PRESS:
if (event->button.button == 1) {
if (!selection->isEmpty()) {
SPItem *clicked_item = (SPItem *) selection->itemList()->data;
if (SP_IS_GROUP(clicked_item) && !SP_IS_BOX3D(clicked_item)) { // enter group if it's not a 3D box
desktop->setCurrentLayer(reinterpret_cast<SPObject *>(clicked_item));
sp_desktop_selection(desktop)->clear();
sc->dragging = false;
sp_event_context_discard_delayed_snap_event(event_context);
desktop->canvas->end_forced_full_redraws();
} else { // switch tool
Geom::Point const button_pt(event->button.x, event->button.y);
Geom::Point const p(desktop->w2d(button_pt));
tools_switch_by_item (desktop, clicked_item, p);
}
} else {
sp_select_context_up_one_layer(desktop);
}
ret = TRUE;
}
break;
case GDK_BUTTON_PRESS:
if (event->button.button == 1 && !event_context->space_panning) {
// save drag origin
xp = (gint) event->button.x;
yp = (gint) event->button.y;
within_tolerance = true;
Geom::Point const button_pt(event->button.x, event->button.y);
Geom::Point const p(desktop->w2d(button_pt));
if (event->button.state & GDK_MOD1_MASK)
Inkscape::Rubberband::get(desktop)->setMode(RUBBERBAND_MODE_TOUCHPATH);
Inkscape::Rubberband::get(desktop)->start(desktop, p);
if (sc->grabbed) {
sp_canvas_item_ungrab(sc->grabbed, event->button.time);
sc->grabbed = NULL;
}
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK,
NULL, event->button.time);
sc->grabbed = SP_CANVAS_ITEM(desktop->acetate);
// remember what modifiers were on before button press
sc->button_press_shift = (event->button.state & GDK_SHIFT_MASK) ? true : false;
sc->button_press_ctrl = (event->button.state & GDK_CONTROL_MASK) ? true : false;
sc->button_press_alt = (event->button.state & GDK_MOD1_MASK) ? true : false;
sc->moved = FALSE;
rb_escaped = drag_escaped = 0;
ret = TRUE;
} else if (event->button.button == 3) {
// right click; do not eat it so that right-click menu can appear, but cancel dragging & rubberband
sp_select_context_abort(event_context);
}
break;
case GDK_MOTION_NOTIFY:
tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
if (event->motion.state & GDK_BUTTON1_MASK && !event_context->space_panning) {
Geom::Point const motion_pt(event->motion.x, event->motion.y);
Geom::Point const p(desktop->w2d(motion_pt));
if ( within_tolerance
&& ( abs( (gint) event->motion.x - xp ) < tolerance )
&& ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
break; // do not drag if we're within tolerance from origin
}
// Once the user has moved farther than tolerance from the original location
// (indicating they intend to move the object, not click), then always process the
// motion notify coordinates as given (no snapping back to origin)
within_tolerance = false;
if (sc->button_press_ctrl || (sc->button_press_alt && !sc->button_press_shift && !selection->isEmpty())) {
// if it's not click and ctrl or alt was pressed (the latter with some selection
// but not with shift) we want to drag rather than rubberband
sc->dragging = TRUE;
desktop->setCursor(SP_SELECT_D_CURSOR);
desktop->canvas->force_full_redraw_after_interruptions(5);
}
if (sc->dragging) {
/* User has dragged fast, so we get events on root (lauris)*/
// not only that; we will end up here when ctrl-dragging as well
// and also when we started within tolerance, but trespassed tolerance outside of item
Inkscape::Rubberband::get(desktop)->stop();
SP_EVENT_CONTEXT(sc)->defaultMessageContext()->clear();
item_at_point = desktop->item_at_point(Geom::Point(event->button.x, event->button.y), FALSE);
if (!item_at_point) // if no item at this point, try at the click point (bug 1012200)
item_at_point = desktop->item_at_point(Geom::Point(xp, yp), FALSE);
if (item_at_point || sc->moved || sc->button_press_alt) {
// drag only if starting from an item, or if something is already grabbed, or if alt-dragging
if (!sc->moved) {
item_in_group = desktop->item_at_point(Geom::Point(event->button.x, event->button.y), TRUE);
group_at_point = desktop->group_at_point(Geom::Point(event->button.x, event->button.y));
if (SP_IS_LAYER(selection->single()))
group_at_point = SP_GROUP(selection->single());
// group-at-point is meant to be topmost item if it's a group,
// not topmost group of all items at point
if (group_at_point != item_in_group &&
!(group_at_point && item_at_point &&
group_at_point->isAncestorOf(item_at_point)))
group_at_point = NULL;
// if neither a group nor an item (possibly in a group) at point are selected, set selection to the item at point
if ((!item_in_group || !selection->includes(item_in_group)) &&
(!group_at_point || !selection->includes(group_at_point))
&& !sc->button_press_alt) {
// select what is under cursor
if (!seltrans->isEmpty()) {
seltrans->resetState();
}
// when simply ctrl-dragging, we don't want to go into groups
if (item_at_point && !selection->includes(item_at_point))
selection->set(item_at_point);
} // otherwise, do not change selection so that dragging selected-within-group items, as well as alt-dragging, is possible
seltrans->grab(p, -1, -1, FALSE, TRUE);
sc->moved = TRUE;
}
if (!seltrans->isEmpty())
seltrans->moveTo(p, event->button.state);
desktop->scroll_to_point(p);
gobble_motion_events(GDK_BUTTON1_MASK);
ret = TRUE;
} else {
sc->dragging = FALSE;
sp_event_context_discard_delayed_snap_event(event_context);
desktop->canvas->end_forced_full_redraws();
}
} else {
if (Inkscape::Rubberband::get(desktop)->is_started()) {
Inkscape::Rubberband::get(desktop)->move(p);
if (Inkscape::Rubberband::get(desktop)->getMode() == RUBBERBAND_MODE_TOUCHPATH) {
event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("<b>Draw over</b> objects to select them; release <b>Alt</b> to switch to rubberband selection"));
} else {
event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("<b>Drag around</b> objects to select them; press <b>Alt</b> to switch to touch selection"));
}
gobble_motion_events(GDK_BUTTON1_MASK);
}
}
}
break;
case GDK_BUTTON_RELEASE:
xp = yp = 0;
if ((event->button.button == 1) && (sc->grabbed) && !event_context->space_panning) {
if (sc->dragging) {
if (sc->moved) {
// item has been moved
seltrans->ungrab();
sc->moved = FALSE;
} else if (sc->item && !drag_escaped) {
// item has not been moved -> simply a click, do selecting
if (!selection->isEmpty()) {
if (event->button.state & GDK_SHIFT_MASK) {
// with shift, toggle selection
seltrans->resetState();
selection->toggle(sc->item);
} else {
SPObject* single = selection->single();
// without shift, increase state (i.e. toggle scale/rotation handles)
if (selection->includes(sc->item)) {
seltrans->increaseState();
} else if (SP_IS_LAYER(single) && single->isAncestorOf(sc->item)) {
seltrans->increaseState();
} else {
seltrans->resetState();
selection->set(sc->item);
}
}
} else { // simple or shift click, no previous selection
seltrans->resetState();
selection->set(sc->item);
}
}
sc->dragging = FALSE;
desktop->setCursor(SP_SELECT_CURSOR);
sp_event_context_discard_delayed_snap_event(event_context);
desktop->canvas->end_forced_full_redraws();
if (sc->item) {
sp_object_unref( SP_OBJECT(sc->item), NULL);
}
sc->item = NULL;
} else {
Inkscape::Rubberband *r = Inkscape::Rubberband::get(desktop);
if (r->is_started() && !within_tolerance) {
// this was a rubberband drag
GSList *items = NULL;
if (r->getMode() == RUBBERBAND_MODE_RECT) {
Geom::OptRect const b = r->getRectangle();
items = sp_document_items_in_box(sp_desktop_document(desktop), desktop->dkey, *b);
} else if (r->getMode() == RUBBERBAND_MODE_TOUCHPATH) {
items = sp_document_items_at_points(sp_desktop_document(desktop), desktop->dkey, r->getPoints());
}
seltrans->resetState();
r->stop();
SP_EVENT_CONTEXT(sc)->defaultMessageContext()->clear();
if (event->button.state & GDK_SHIFT_MASK) {
// with shift, add to selection
selection->addList (items);
} else {
// without shift, simply select anew
selection->setList (items);
}
g_slist_free (items);
} else { // it was just a click, or a too small rubberband
r->stop();
if (sc->button_press_shift && !rb_escaped && !drag_escaped) {
// this was a shift+click or alt+shift+click, select what was clicked upon
sc->button_press_shift = false;
if (sc->button_press_ctrl) {
// go into groups, honoring Alt
item = sp_event_context_find_item (desktop,
Geom::Point(event->button.x, event->button.y), event->button.state & GDK_MOD1_MASK, TRUE);
sc->button_press_ctrl = FALSE;
} else {
// don't go into groups, honoring Alt
item = sp_event_context_find_item (desktop,
Geom::Point(event->button.x, event->button.y), event->button.state & GDK_MOD1_MASK, FALSE);
}
if (item) {
selection->toggle(item);
item = NULL;
}
} else if ((sc->button_press_ctrl || sc->button_press_alt) && !rb_escaped && !drag_escaped) { // ctrl+click, alt+click
item = sp_event_context_find_item (desktop,
Geom::Point(event->button.x, event->button.y), sc->button_press_alt, sc->button_press_ctrl);
sc->button_press_ctrl = FALSE;
sc->button_press_alt = FALSE;
if (item) {
if (selection->includes(item)) {
seltrans->increaseState();
} else {
seltrans->resetState();
selection->set(item);
}
item = NULL;
}
} else { // click without shift, simply deselect, unless with Alt or something was cancelled
if (!selection->isEmpty()) {
if (!(rb_escaped) && !(drag_escaped) && !(event->button.state & GDK_MOD1_MASK))
selection->clear();
rb_escaped = 0;
ret = TRUE;
}
}
}
ret = TRUE;
}
if (sc->grabbed) {
sp_canvas_item_ungrab(sc->grabbed, event->button.time);
sc->grabbed = NULL;
}
desktop->updateNow();
}
if (event->button.button == 1) {
Inkscape::Rubberband::get(desktop)->stop(); // might have been started in another tool!
}
sc->button_press_shift = false;
sc->button_press_ctrl = false;
sc->button_press_alt = false;
break;
case GDK_KEY_PRESS: // keybindings for select context
{
{
guint keyval = get_group0_keyval(&event->key);
bool alt = ( MOD__ALT
|| (keyval == GDK_Alt_L)
|| (keyval == GDK_Alt_R)
|| (keyval == GDK_Meta_L)
|| (keyval == GDK_Meta_R));
if (!key_is_a_modifier (keyval)) {
event_context->defaultMessageContext()->clear();
} else if (sc->grabbed || seltrans->isGrabbed()) {
if (Inkscape::Rubberband::get(desktop)->is_started()) {
// if Alt then change cursor to moving cursor:
if (alt) {
Inkscape::Rubberband::get(desktop)->setMode(RUBBERBAND_MODE_TOUCHPATH);
}
} else {
// do not change the statusbar text when mousekey is down to move or transform the object,
// because the statusbar text is already updated somewhere else.
break;
}
} else {
sp_event_show_modifier_tip (event_context->defaultMessageContext(), event,
_("<b>Ctrl</b>: click to select in groups; drag to move hor/vert"),
_("<b>Shift</b>: click to toggle select; drag for rubberband selection"),
_("<b>Alt</b>: click to select under; drag to move selected or select by touch"));
// if Alt and nonempty selection, show moving cursor ("move selected"):
if (alt && !selection->isEmpty() && !desktop->isWaitingCursor()) {
desktop->setCursor(SP_SELECT_D_CURSOR);
}
//*/
break;
}
}
gdouble const nudge = prefs->getDoubleLimited("/options/nudgedistance/value", 2, 0, 1000); // in px
gdouble const offset = prefs->getDoubleLimited("/options/defaultscale/value", 2, 0, 1000);
int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
switch (get_group0_keyval (&event->key)) {
case GDK_Left: // move selection left
case GDK_KP_Left:
case GDK_KP_4:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) sp_selection_move_screen(desktop, mul*-10, 0); // shift
else sp_selection_move_screen(desktop, mul*-1, 0); // no shift
}
else { // no alt
if (MOD__SHIFT) sp_selection_move(desktop, mul*-10*nudge, 0); // shift
else sp_selection_move(desktop, mul*-nudge, 0); // no shift
}
ret = TRUE;
}
break;
case GDK_Up: // move selection up
case GDK_KP_Up:
case GDK_KP_8:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) sp_selection_move_screen(desktop, 0, mul*10); // shift
else sp_selection_move_screen(desktop, 0, mul*1); // no shift
}
else { // no alt
if (MOD__SHIFT) sp_selection_move(desktop, 0, mul*10*nudge); // shift
else sp_selection_move(desktop, 0, mul*nudge); // no shift
}
ret = TRUE;
}
break;
case GDK_Right: // move selection right
case GDK_KP_Right:
case GDK_KP_6:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) sp_selection_move_screen(desktop, mul*10, 0); // shift
else sp_selection_move_screen(desktop, mul*1, 0); // no shift
}
else { // no alt
if (MOD__SHIFT) sp_selection_move(desktop, mul*10*nudge, 0); // shift
else sp_selection_move(desktop, mul*nudge, 0); // no shift
}
ret = TRUE;
}
break;
case GDK_Down: // move selection down
case GDK_KP_Down:
case GDK_KP_2:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) sp_selection_move_screen(desktop, 0, mul*-10); // shift
else sp_selection_move_screen(desktop, 0, mul*-1); // no shift
}
else { // no alt
if (MOD__SHIFT) sp_selection_move(desktop, 0, mul*-10*nudge); // shift
else sp_selection_move(desktop, 0, mul*-nudge); // no shift
}
ret = TRUE;
}
break;
case GDK_Escape:
if (!sp_select_context_abort(event_context))
selection->clear();
ret = TRUE;
break;
case GDK_a:
case GDK_A:
if (MOD__CTRL_ONLY) {
sp_edit_select_all(desktop);
ret = TRUE;
}
break;
case GDK_space:
/* stamping mode: show outline mode moving */
/* FIXME: Is next condition ok? (lauris) */
if (sc->dragging && sc->grabbed) {
seltrans->stamp();
ret = TRUE;
}
break;
case GDK_x:
case GDK_X:
if (MOD__ALT_ONLY) {
desktop->setToolboxFocusTo ("altx");
ret = TRUE;
}
break;
case GDK_bracketleft:
if (MOD__ALT) {
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
sp_selection_rotate_screen(selection, mul*1);
} else if (MOD__CTRL) {
sp_selection_rotate(selection, 90);
} else if (snaps) {
sp_selection_rotate(selection, 180.0/snaps);
}
ret = TRUE;
break;
case GDK_bracketright:
if (MOD__ALT) {
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
sp_selection_rotate_screen(selection, -1*mul);
} else if (MOD__CTRL) {
sp_selection_rotate(selection, -90);
} else if (snaps) {
sp_selection_rotate(selection, -180.0/snaps);
}
ret = TRUE;
break;
case GDK_less:
case GDK_comma:
if (MOD__ALT) {
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
sp_selection_scale_screen(selection, -2*mul);
} else if (MOD__CTRL) {
sp_selection_scale_times(selection, 0.5);
} else {
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
sp_selection_scale(selection, -offset*mul);
}
ret = TRUE;
break;
case GDK_greater:
case GDK_period:
if (MOD__ALT) {
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
sp_selection_scale_screen(selection, 2*mul);
} else if (MOD__CTRL) {
sp_selection_scale_times(selection, 2);
} else {
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
sp_selection_scale(selection, offset*mul);
}
ret = TRUE;
break;
case GDK_Return:
if (MOD__CTRL_ONLY) {
if (selection->singleItem()) {
SPItem *clicked_item = selection->singleItem();
if ( SP_IS_GROUP(clicked_item) ||
SP_IS_BOX3D(clicked_item)) { // enter group or a 3D box
desktop->setCurrentLayer(reinterpret_cast<SPObject *>(clicked_item));
sp_desktop_selection(desktop)->clear();
} else {
SP_EVENT_CONTEXT(sc)->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Selected object is not a group. Cannot enter."));
}
}
ret = TRUE;
}
break;
case GDK_BackSpace:
if (MOD__CTRL_ONLY) {
sp_select_context_up_one_layer(desktop);
ret = TRUE;
}
break;
case GDK_s:
case GDK_S:
if (MOD__SHIFT_ONLY) {
if (!selection->isEmpty()) {
seltrans->increaseState();
}
ret = TRUE;
}
break;
case GDK_g:
case GDK_G:
if (MOD__SHIFT_ONLY) {
sp_selection_to_guides(desktop);
ret = true;
}
break;
default:
break;
}
break;
}
case GDK_KEY_RELEASE:
{
guint keyval = get_group0_keyval(&event->key);
if (key_is_a_modifier (keyval))
event_context->defaultMessageContext()->clear();
bool alt = ( MOD__ALT
|| (keyval == GDK_Alt_L)
|| (keyval == GDK_Alt_R)
|| (keyval == GDK_Meta_L)
|| (keyval == GDK_Meta_R));
if (Inkscape::Rubberband::get(desktop)->is_started()) {
// if Alt then change cursor to moving cursor:
if (alt) {
Inkscape::Rubberband::get(desktop)->setMode(RUBBERBAND_MODE_RECT);
}
}
}
// set cursor to default.
if (!desktop->isWaitingCursor()) {
desktop->setCursor(event_context->cursor_shape);
}
break;
default:
break;
}
if (!ret) {
if (((SPEventContextClass *) parent_class)->root_handler)
ret = ((SPEventContextClass *) parent_class)->root_handler(event_context, event);
}
return ret;
}
static gint
sp_gradient_context_root_handler(SPEventContext *event_context, GdkEvent *event)
{
static bool dragging;
SPDesktop *desktop = event_context->desktop;
Inkscape::Selection *selection = sp_desktop_selection (desktop);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
SPGradientContext *rc = SP_GRADIENT_CONTEXT(event_context);
event_context->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
double const nudge = prefs->getDoubleLimited("/options/nudgedistance/value", 2, 0, 1000); // in px
GrDrag *drag = event_context->_grdrag;
g_assert (drag);
gint ret = FALSE;
switch (event->type) {
case GDK_2BUTTON_PRESS:
if ( event->button.button == 1 ) {
bool over_line = false;
SPCtrlLine *line = NULL;
if (drag->lines) {
for (GSList *l = drag->lines; (l != NULL) && (!over_line); l = l->next) {
line = (SPCtrlLine*) l->data;
over_line |= sp_gradient_context_is_over_line (rc, (SPItem*) line, Geom::Point(event->motion.x, event->motion.y));
}
}
if (over_line) {
// we take the first item in selection, because with doubleclick, the first click
// always resets selection to the single object under cursor
sp_gradient_context_add_stop_near_point(rc, SP_ITEM(selection->itemList()->data), rc->mousepoint_doc, event->button.time);
} else {
for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
SPItem *item = SP_ITEM(i->data);
SPGradientType new_type = (SPGradientType) prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
guint new_fill = prefs->getInt("/tools/gradient/newfillorstroke", 1);
SPGradient *vector = sp_gradient_vector_for_object(sp_desktop_document(desktop), desktop, SP_OBJECT (item), new_fill);
SPGradient *priv = sp_item_set_gradient(item, vector, new_type, new_fill);
sp_gradient_reset_to_userspace(priv, item);
}
sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
_("Create default gradient"));
}
ret = TRUE;
}
break;
case GDK_BUTTON_PRESS:
if ( event->button.button == 1 && !event_context->space_panning ) {
Geom::Point button_w(event->button.x, event->button.y);
// save drag origin
event_context->xp = (gint) button_w[Geom::X];
event_context->yp = (gint) button_w[Geom::Y];
event_context->within_tolerance = true;
dragging = true;
Geom::Point button_dt = to_2geom(desktop->w2d(button_w));
if (event->button.state & GDK_SHIFT_MASK) {
Inkscape::Rubberband::get(desktop)->start(desktop, from_2geom(button_dt));
} else {
// remember clicked item, disregarding groups, honoring Alt; do nothing with Crtl to
// enable Ctrl+doubleclick of exactly the selected item(s)
if (!(event->button.state & GDK_CONTROL_MASK))
event_context->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
/* Snap center to nearest magnetic point */
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop);
m.freeSnapReturnByRef(Inkscape::SnapPreferences::SNAPPOINT_NODE, button_dt);
rc->origin = from_2geom(button_dt);
}
ret = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if ( dragging
&& ( event->motion.state & GDK_BUTTON1_MASK ) && !event_context->space_panning )
{
if ( event_context->within_tolerance
&& ( abs( (gint) event->motion.x - event_context->xp ) < event_context->tolerance )
&& ( abs( (gint) event->motion.y - event_context->yp ) < event_context->tolerance ) ) {
break; // do not drag if we're within tolerance from origin
}
// Once the user has moved farther than tolerance from the original location
// (indicating they intend to draw, not click), then always process the
// motion notify coordinates as given (no snapping back to origin)
event_context->within_tolerance = false;
Geom::Point const motion_w(event->motion.x,
event->motion.y);
Geom::Point const motion_dt = event_context->desktop->w2d(motion_w);
if (Inkscape::Rubberband::get(desktop)->is_started()) {
Inkscape::Rubberband::get(desktop)->move(motion_dt);
event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, _("<b>Draw around</b> handles to select them"));
} else {
sp_gradient_drag(*rc, motion_dt, event->motion.state, event->motion.time);
}
gobble_motion_events(GDK_BUTTON1_MASK);
ret = TRUE;
} else {
bool over_line = false;
if (drag->lines) {
for (GSList *l = drag->lines; l != NULL; l = l->next) {
over_line |= sp_gradient_context_is_over_line (rc, (SPItem*) l->data, Geom::Point(event->motion.x, event->motion.y));
}
}
if (rc->cursor_addnode && !over_line) {
event_context->cursor_shape = cursor_gradient_xpm;
sp_event_context_update_cursor(event_context);
rc->cursor_addnode = false;
} else if (!rc->cursor_addnode && over_line) {
event_context->cursor_shape = cursor_gradient_add_xpm;
sp_event_context_update_cursor(event_context);
rc->cursor_addnode = true;
}
}
break;
case GDK_BUTTON_RELEASE:
event_context->xp = event_context->yp = 0;
if ( event->button.button == 1 && !event_context->space_panning ) {
if ( (event->button.state & GDK_CONTROL_MASK) && (event->button.state & GDK_MOD1_MASK ) ) {
bool over_line = false;
SPCtrlLine *line = NULL;
if (drag->lines) {
for (GSList *l = drag->lines; (l != NULL) && (!over_line); l = l->next) {
line = (SPCtrlLine*) l->data;
over_line = sp_gradient_context_is_over_line (rc, (SPItem*) line, Geom::Point(event->motion.x, event->motion.y));
if (over_line)
break;
}
}
if (over_line && line) {
sp_gradient_context_add_stop_near_point(rc, line->item, rc->mousepoint_doc, 0);
ret = TRUE;
}
} else {
dragging = false;
// unless clicked with Ctrl (to enable Ctrl+doubleclick).
if (event->button.state & GDK_CONTROL_MASK) {
ret = TRUE;
break;
}
if (!event_context->within_tolerance) {
// we've been dragging, either do nothing (grdrag handles that),
// or rubberband-select if we have rubberband
Inkscape::Rubberband::Rubberband *r = Inkscape::Rubberband::get(desktop);
if (r->is_started() && !event_context->within_tolerance) {
// this was a rubberband drag
if (r->getMode() == RUBBERBAND_MODE_RECT) {
Geom::OptRect const b = r->getRectangle();
drag->selectRect(*b);
}
}
} else if (event_context->item_to_select) {
// no dragging, select clicked item if any
if (event->button.state & GDK_SHIFT_MASK) {
selection->toggle(event_context->item_to_select);
} else {
selection->set(event_context->item_to_select);
}
} else {
// click in an empty space; do the same as Esc
if (drag->selected) {
drag->deselectAll();
} else {
selection->clear();
}
}
event_context->item_to_select = NULL;
ret = TRUE;
}
Inkscape::Rubberband::get(desktop)->stop();
}
break;
case GDK_KEY_PRESS:
switch (get_group0_keyval (&event->key)) {
case GDK_Alt_L:
case GDK_Alt_R:
case GDK_Control_L:
case GDK_Control_R:
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Meta_L: // Meta is when you press Shift+Alt (at least on my machine)
case GDK_Meta_R:
sp_event_show_modifier_tip (event_context->defaultMessageContext(), event,
_("<b>Ctrl</b>: snap gradient angle"),
_("<b>Shift</b>: draw gradient around the starting point"),
NULL);
break;
case GDK_x:
case GDK_X:
if (MOD__ALT_ONLY) {
desktop->setToolboxFocusTo ("altx-grad");
ret = TRUE;
}
break;
case GDK_A:
case GDK_a:
if (MOD__CTRL_ONLY && drag->isNonEmpty()) {
drag->selectAll();
ret = TRUE;
}
break;
case GDK_L:
case GDK_l:
if (MOD__CTRL_ONLY && drag->isNonEmpty() && drag->hasSelection()) {
sp_gradient_simplify(rc, 1e-4);
ret = TRUE;
}
break;
case GDK_Escape:
if (drag->selected) {
drag->deselectAll();
} else {
selection->clear();
}
ret = TRUE;
//TODO: make dragging escapable by Esc
break;
case GDK_Left: // move handle left
case GDK_KP_Left:
case GDK_KP_4:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) drag->selected_move_screen(mul*-10, 0); // shift
else drag->selected_move_screen(mul*-1, 0); // no shift
}
else { // no alt
if (MOD__SHIFT) drag->selected_move(mul*-10*nudge, 0); // shift
else drag->selected_move(mul*-nudge, 0); // no shift
}
ret = TRUE;
}
break;
case GDK_Up: // move handle up
case GDK_KP_Up:
case GDK_KP_8:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) drag->selected_move_screen(0, mul*10); // shift
else drag->selected_move_screen(0, mul*1); // no shift
}
else { // no alt
if (MOD__SHIFT) drag->selected_move(0, mul*10*nudge); // shift
else drag->selected_move(0, mul*nudge); // no shift
}
ret = TRUE;
}
break;
case GDK_Right: // move handle right
case GDK_KP_Right:
case GDK_KP_6:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) drag->selected_move_screen(mul*10, 0); // shift
else drag->selected_move_screen(mul*1, 0); // no shift
}
else { // no alt
if (MOD__SHIFT) drag->selected_move(mul*10*nudge, 0); // shift
else drag->selected_move(mul*nudge, 0); // no shift
}
ret = TRUE;
}
break;
case GDK_Down: // move handle down
case GDK_KP_Down:
case GDK_KP_2:
if (!MOD__CTRL) { // not ctrl
gint mul = 1 + gobble_key_events(
get_group0_keyval(&event->key), 0); // with any mask
if (MOD__ALT) { // alt
if (MOD__SHIFT) drag->selected_move_screen(0, mul*-10); // shift
else drag->selected_move_screen(0, mul*-1); // no shift
}
else { // no alt
if (MOD__SHIFT) drag->selected_move(0, mul*-10*nudge); // shift
else drag->selected_move(0, mul*-nudge); // no shift
}
ret = TRUE;
}
break;
case GDK_r:
case GDK_R:
if (MOD__SHIFT_ONLY) {
// First try selected dragger
if (drag && drag->selected) {
drag->selected_reverse_vector();
} else { // If no drag or no dragger selected, act on selection (both fill and stroke gradients)
for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
sp_item_gradient_reverse_vector (SP_ITEM(i->data), true);
sp_item_gradient_reverse_vector (SP_ITEM(i->data), false);
}
}
// we did an undoable action
sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
_("Invert gradient"));
ret = TRUE;
}
break;
case GDK_Insert:
case GDK_KP_Insert:
// with any modifiers:
sp_gradient_context_add_stops_between_selected_stops (rc);
ret = TRUE;
break;
case GDK_Delete:
case GDK_KP_Delete:
case GDK_BackSpace:
if ( drag->selected ) {
drag->deleteSelected(MOD__CTRL_ONLY);
ret = TRUE;
}
break;
default:
break;
}
break;
case GDK_KEY_RELEASE:
switch (get_group0_keyval (&event->key)) {
case GDK_Alt_L:
case GDK_Alt_R:
case GDK_Control_L:
case GDK_Control_R:
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Meta_L: // Meta is when you press Shift+Alt
case GDK_Meta_R:
event_context->defaultMessageContext()->clear();
break;
default:
break;
}
break;
default:
break;
}
if (!ret) {
if (((SPEventContextClass *) parent_class)->root_handler) {
ret = ((SPEventContextClass *) parent_class)->root_handler(event_context, event);
}
}
return ret;
}