static void sp_dropper_context_setup(SPEventContext *ec)
{
SPDropperContext *dc = SP_DROPPER_CONTEXT(ec);
if (((SPEventContextClass *) parent_class)->setup) {
((SPEventContextClass *) parent_class)->setup(ec);
}
/* TODO: have a look at sp_dyna_draw_context_setup where the same is done.. generalize? at least make it an arcto! */
SPCurve *c = new SPCurve();
const double C1 = 0.552;
c->moveto(-1,0);
c->curveto(-1, C1, -C1, 1, 0, 1 );
c->curveto(C1, 1, 1, C1, 1, 0 );
c->curveto(1, -C1, C1, -1, 0, -1 );
c->curveto(-C1, -1, -1, -C1, -1, 0 );
c->closepath();
dc->area = sp_canvas_bpath_new(sp_desktop_controls(ec->desktop), c);
c->unref();
sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(dc->area), 0x00000000,(SPWindRule)0);
sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(dc->area), 0x0000007f, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
sp_canvas_item_hide(dc->area);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/dropper/selcue")) {
ec->enableSelectionCue();
}
if (prefs->getBool("/tools/dropper/gradientdrag")) {
ec->enableGrDrag();
}
}
static void sp_box3d_context_setup(SPEventContext *ec)
{
Box3DContext *bc = SP_BOX3D_CONTEXT(ec);
if (((SPEventContextClass *) parent_class)->setup) {
((SPEventContextClass *) parent_class)->setup(ec);
}
ec->shape_editor = new ShapeEditor(ec->desktop);
SPItem *item = sp_desktop_selection(ec->desktop)->singleItem();
if (item) {
ec->shape_editor->set_item(item, SH_KNOTHOLDER);
}
bc->sel_changed_connection.disconnect();
bc->sel_changed_connection = sp_desktop_selection(ec->desktop)->connectChanged(
sigc::bind(sigc::ptr_fun(&sp_box3d_context_selection_changed), (gpointer)bc)
);
bc->_vpdrag = new Box3D::VPDrag(sp_desktop_document (ec->desktop));
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/shapes/selcue")) {
ec->enableSelectionCue();
}
if (prefs->getBool("/tools/shapes/gradientdrag")) {
ec->enableGrDrag();
}
bc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());
}
/*
* Map each gradient to its usage count for both fill and stroke styles
*/
void gr_get_usage_counts(SPDocument *doc, std::map<SPGradient *, gint> *mapUsageCount )
{
if (!doc)
return;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
bool ingroups = TRUE;
GSList *all_list = get_all_doc_items(NULL, doc->getRoot(), onlyvisible, onlysensitive, ingroups, NULL);
for (GSList *i = all_list; i != NULL; i = i->next) {
SPItem *item = SP_ITEM(i->data);
if (!item->getId())
continue;
SPGradient *gr = NULL;
gr = gr_item_get_gradient(item, true); // fill
if (gr) {
mapUsageCount->count(gr) > 0 ? (*mapUsageCount)[gr] += 1 : (*mapUsageCount)[gr] = 1;
}
gr = gr_item_get_gradient(item, false); // stroke
if (gr) {
mapUsageCount->count(gr) > 0 ? (*mapUsageCount)[gr] += 1 : (*mapUsageCount)[gr] = 1;
}
}
}
static void
sp_spiral_context_setup(SPEventContext *ec)
{
SPSpiralContext *sc = SP_SPIRAL_CONTEXT(ec);
if (((SPEventContextClass *) parent_class)->setup)
((SPEventContextClass *) parent_class)->setup(ec);
sp_event_context_read(ec, "expansion");
sp_event_context_read(ec, "revolution");
sp_event_context_read(ec, "t0");
ec->shape_editor = new ShapeEditor(ec->desktop);
SPItem *item = sp_desktop_selection(ec->desktop)->singleItem();
if (item) {
ec->shape_editor->set_item(item, SH_KNOTHOLDER);
}
Inkscape::Selection *selection = sp_desktop_selection(ec->desktop);
sc->sel_changed_connection.disconnect();
sc->sel_changed_connection = selection->connectChanged(sigc::bind(sigc::ptr_fun(&sp_spiral_context_selection_changed), (gpointer)sc));
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/shapes/selcue")) {
ec->enableSelectionCue();
}
if (prefs->getBool("/tools/shapes/gradientdrag")) {
ec->enableGrDrag();
}
sc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());
}
/* If the viewBox is missing, set one
*/
void Metafile::setViewBoxIfMissing(SPDocument *doc) {
if (doc && !doc->getRoot()->viewBox_set) {
bool saved = Inkscape::DocumentUndo::getUndoSensitive(doc);
Inkscape::DocumentUndo::setUndoSensitive(doc, false);
doc->ensureUpToDate();
// Set document unit
Inkscape::XML::Node *repr = sp_document_namedview(doc, 0)->getRepr();
Inkscape::SVGOStringStream os;
Inkscape::Util::Unit const* doc_unit = doc->getWidth().unit;
os << doc_unit->abbr;
repr->setAttribute("inkscape:document-units", os.str().c_str());
// Set viewBox
doc->setViewBox(Geom::Rect::from_xywh(0, 0, doc->getWidth().value(doc_unit), doc->getHeight().value(doc_unit)));
doc->ensureUpToDate();
// Scale and translate objects
double scale = Inkscape::Util::Quantity::convert(1, "px", doc_unit);
Inkscape::UI::ShapeEditor::blockSetItem(true);
double dh;
if(SP_ACTIVE_DOCUMENT){ // for file menu open or import, or paste from clipboard
dh = SP_ACTIVE_DOCUMENT->getHeight().value("px");
}
else { // for open via --file on command line
dh = doc->getHeight().value("px");
}
// These should not affect input, but they do, so set them to a neutral state
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool transform_stroke = prefs->getBool("/options/transform/stroke", true);
bool transform_rectcorners = prefs->getBool("/options/transform/rectcorners", true);
bool transform_pattern = prefs->getBool("/options/transform/pattern", true);
bool transform_gradient = prefs->getBool("/options/transform/gradient", true);
prefs->setBool("/options/transform/stroke", true);
prefs->setBool("/options/transform/rectcorners", true);
prefs->setBool("/options/transform/pattern", true);
prefs->setBool("/options/transform/gradient", true);
doc->getRoot()->scaleChildItemsRec(Geom::Scale(scale), Geom::Point(0, dh), true);
Inkscape::UI::ShapeEditor::blockSetItem(false);
// restore options
prefs->setBool("/options/transform/stroke", transform_stroke);
prefs->setBool("/options/transform/rectcorners", transform_rectcorners);
prefs->setBool("/options/transform/pattern", transform_pattern);
prefs->setBool("/options/transform/gradient", transform_gradient);
Inkscape::DocumentUndo::setUndoSensitive(doc, saved);
}
}
void ZoomTool::setup() {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/zoom/selcue")) {
this->enableSelectionCue();
}
if (prefs->getBool("/tools/zoom/gradientdrag")) {
this->enableGrDrag();
}
ToolBase::setup();
}
static void sp_spray_context_setup(SPEventContext *ec)
{
SPSprayContext *tc = SP_SPRAY_CONTEXT(ec);
if (((SPEventContextClass *) parent_class)->setup) {
((SPEventContextClass *) parent_class)->setup(ec);
}
{
/* TODO: have a look at sp_dyna_draw_context_setup where the same is done.. generalize? at least make it an arcto! */
SPCurve *c = new SPCurve();
const double C1 = 0.552;
c->moveto(-1,0);
c->curveto(-1, C1, -C1, 1, 0, 1 );
c->curveto(C1, 1, 1, C1, 1, 0 );
c->curveto(1, -C1, C1, -1, 0, -1 );
c->curveto(-C1, -1, -1, -C1, -1, 0 );
c->closepath();
tc->dilate_area = sp_canvas_bpath_new(sp_desktop_controls(ec->desktop), c);
c->unref();
sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(tc->dilate_area), 0x00000000,(SPWindRule)0);
sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(tc->dilate_area), 0xff9900ff, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
sp_canvas_item_hide(tc->dilate_area);
}
tc->is_drawing = false;
tc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());
sp_event_context_read(ec, "distrib");
sp_event_context_read(ec, "width");
sp_event_context_read(ec, "ratio");
sp_event_context_read(ec, "tilt");
sp_event_context_read(ec, "rotation_variation");
sp_event_context_read(ec, "scale_variation");
sp_event_context_read(ec, "mode");
sp_event_context_read(ec, "population");
sp_event_context_read(ec, "force");
sp_event_context_read(ec, "mean");
sp_event_context_read(ec, "standard_deviation");
sp_event_context_read(ec, "usepressure");
sp_event_context_read(ec, "Scale");
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/spray/selcue")) {
ec->enableSelectionCue();
}
if (prefs->getBool("/tools/spray/gradientdrag")) {
ec->enableGrDrag();
}
}
Glib::ustring
get_file_save_path (SPDocument *doc, FileSaveMethod method) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring path;
bool use_current_dir = true;
switch (method) {
case FILE_SAVE_METHOD_SAVE_AS:
{
use_current_dir = prefs->getBool("/dialogs/save_as/use_current_dir", true);
if (doc->getURI() && use_current_dir) {
path = Glib::path_get_dirname(doc->getURI());
} else {
path = prefs->getString("/dialogs/save_as/path");
}
break;
}
case FILE_SAVE_METHOD_TEMPORARY:
path = prefs->getString("/dialogs/save_as/path");
break;
case FILE_SAVE_METHOD_SAVE_COPY:
use_current_dir = prefs->getBool("/dialogs/save_copy/use_current_dir", prefs->getBool("/dialogs/save_as/use_current_dir", true));
if (doc->getURI() && use_current_dir) {
path = Glib::path_get_dirname(doc->getURI());
} else {
path = prefs->getString("/dialogs/save_copy/path");
}
break;
case FILE_SAVE_METHOD_INKSCAPE_SVG:
if (doc->getURI()) {
path = Glib::path_get_dirname(doc->getURI());
} else {
// FIXME: should we use the save_as path here or something else? Maybe we should
// leave this as a choice to the user.
path = prefs->getString("/dialogs/save_as/path");
}
break;
case FILE_SAVE_METHOD_EXPORT:
/// \todo no default path set for Export?
// defaults to g_get_home_dir()
break;
}
if(path.empty()) {
path = g_get_home_dir(); // Is this the most sensible solution? Note that we should avoid
// g_get_current_dir because this leads to problems on OS X where
// Inkscape opens the dialog inside application bundle when it is
// invoked for the first teim.
}
return path;
}
static void sp_zoom_context_setup(SPEventContext *ec)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/zoom/selcue")) {
ec->enableSelectionCue();
}
if (prefs->getBool("/tools/zoom/gradientdrag")) {
ec->enableGrDrag();
}
if (((SPEventContextClass *) parent_class)->setup) {
((SPEventContextClass *) parent_class)->setup(ec);
}
}
static void
sp_repr_save_writer(Document *doc, Inkscape::IO::Writer *out,
gchar const *default_ns,
gchar const *old_href_abs_base,
gchar const *new_href_abs_base)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool inlineattrs = prefs->getBool("/options/svgoutput/inlineattrs");
int indent = prefs->getInt("/options/svgoutput/indent", 2);
/* fixme: do this The Right Way */
out->writeString( "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n" );
const gchar *str = static_cast<Node *>(doc)->attribute("doctype");
if (str) {
out->writeString( str );
}
for (Node *repr = sp_repr_document_first_child(doc);
repr; repr = sp_repr_next(repr))
{
Inkscape::XML::NodeType const node_type = repr->type();
if ( node_type == Inkscape::XML::ELEMENT_NODE ) {
sp_repr_write_stream_root_element(repr, *out, TRUE, default_ns, inlineattrs, indent,
old_href_abs_base, new_href_abs_base);
} else {
sp_repr_write_stream(repr, *out, 0, TRUE, GQuark(0), inlineattrs, indent,
old_href_abs_base, new_href_abs_base);
if ( node_type == Inkscape::XML::COMMENT_NODE ) {
out->writeChar('\n');
}
}
}
}
/**
Applies gradient vector gr to the gradients attached to the selected dragger of drag, or if none,
to all objects in selection. If there was no previous gradient on an item, uses gradient type and
fill/stroke setting from preferences to create new default (linear: left/right; radial: centered)
gradient.
*/
void
gr_apply_gradient (Inkscape::Selection *selection, GrDrag *drag, SPGradient *gr)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
SPGradientType new_type = (SPGradientType) prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
guint new_fill = prefs->getBool("/tools/gradient/newfillorstroke", true);
// GRADIENTFIXME: make this work for multiple selected draggers.
// First try selected dragger
if (drag && drag->selected) {
GrDragger *dragger = (GrDragger*) drag->selected->data;
for (GSList const* i = dragger->draggables; i != NULL; i = i->next) { // for all draggables of dragger
GrDraggable *draggable = (GrDraggable *) i->data;
gr_apply_gradient_to_item (draggable->item, gr, new_type, new_fill, draggable->fill_or_stroke, !draggable->fill_or_stroke);
}
return;
}
// If no drag or no dragger selected, act on selection
for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
gr_apply_gradient_to_item (SP_ITEM(i->data), gr, new_type, new_fill, new_fill, !new_fill);
}
}
void LpeTool::setup() {
PenTool::setup();
Inkscape::Selection *selection = this->desktop->getSelection();
SPItem *item = selection->singleItem();
this->sel_changed_connection.disconnect();
this->sel_changed_connection =
selection->connectChanged(sigc::bind(sigc::ptr_fun(&sp_lpetool_context_selection_changed), (gpointer)this));
this->shape_editor = new ShapeEditor(this->desktop);
lpetool_context_switch_mode(this, Inkscape::LivePathEffect::INVALID_LPE);
lpetool_context_reset_limiting_bbox(this);
lpetool_create_measuring_items(this);
// TODO temp force:
this->enableSelectionCue();
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (item) {
this->shape_editor->set_item(item);
}
if (prefs->getBool("/tools/lpetool/selcue")) {
this->enableSelectionCue();
}
}
void SPObject::requestOrphanCollection() {
g_return_if_fail(document != NULL);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
// do not remove style or script elements (Bug #276244)
if (dynamic_cast<SPStyleElem *>(this)) {
// leave it
} else if (dynamic_cast<SPScript *>(this)) {
// leave it
} else if ((! prefs->getBool("/options/cleanupswatches/value", false)) && SP_IS_PAINT_SERVER(this) && static_cast<SPPaintServer*>(this)->isSwatch() ) {
// leave it
} else if (IS_COLORPROFILE(this)) {
// leave it
} else {
document->queueForOrphanCollection(this);
/** \todo
* This is a temporary hack added to make fill&stroke rebuild its
* gradient list when the defs are vacuumed. gradient-vector.cpp
* listens to the modified signal on defs, and now we give it that
* signal. Mental says that this should be made automatic by
* merging SPObjectGroup with SPObject; SPObjectGroup would issue
* this signal automatically. Or maybe just derive SPDefs from
* SPObjectGroup?
*/
this->requestModified(SP_OBJECT_CHILD_MODIFIED_FLAG);
}
}
/**
* Make the argument dialog transient to the currently active document
* window.
*/
void sp_transientize(GtkWidget *dialog)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
#ifndef WIN32 // FIXME: Temporary Win32 special code to enable transient dialogs
// _set_skip_taskbar_hint makes transient dialogs NON-transient! When dialogs
// are made transient (_set_transient_for), they are already removed from
// the taskbar in Win32.
if (prefs->getBool( "/options/dialogsskiptaskbar/value")) {
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), TRUE);
}
#endif
gint transient_policy = prefs->getIntLimited("/options/transientpolicy/value", 1, 0, 2);
#ifdef WIN32 // Win32 special code to enable transient dialogs
transient_policy = 2;
#endif
if (transient_policy) {
// if there's an active document window, attach dialog to it as a transient:
if ( SP_ACTIVE_DESKTOP )
{
SP_ACTIVE_DESKTOP->setWindowTransient (dialog, transient_policy);
}
}
} // end of sp_transientize()
static void
sp_select_context_setup(SPEventContext *ec)
{
SPSelectContext *select_context = SP_SELECT_CONTEXT(ec);
if (((SPEventContextClass *) parent_class)->setup) {
((SPEventContextClass *) parent_class)->setup(ec);
}
SPDesktop *desktop = ec->desktop;
select_context->_describer = new Inkscape::SelectionDescriber(
desktop->selection,
desktop->messageStack(),
_("Click selection to toggle scale/rotation handles"),
_("No objects selected. Click, Shift+click, or drag around objects to select.")
);
select_context->_seltrans = new Inkscape::SelTrans(desktop);
sp_event_context_read(ec, "show");
sp_event_context_read(ec, "transform");
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/select/gradientdrag")) {
ec->enableGrDrag();
}
}
// TODO: Note that currently the bbox is not user-settable; we simply use the page borders
void
lpetool_context_reset_limiting_bbox(LpeTool *lc)
{
if (lc->canvas_bbox) {
sp_canvas_item_destroy(lc->canvas_bbox);
lc->canvas_bbox = NULL;
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (!prefs->getBool("/tools/lpetool/show_bbox", true))
return;
SPDocument *document = lc->desktop->getDocument();
Geom::Point A, B;
lpetool_get_limiting_bbox_corners(document, A, B);
Geom::Affine doc2dt(lc->desktop->doc2dt());
A *= doc2dt;
B *= doc2dt;
Geom::Rect rect(A, B);
SPCurve *curve = SPCurve::new_from_rect(rect);
lc->canvas_bbox = sp_canvas_bpath_new (lc->desktop->getControls(), curve);
sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(lc->canvas_bbox), 0x0000ffff, 0.8, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT, 5, 5);
}
static void sp_node_path_edit_delete(void)
{
NodeTool *nt = get_node_tool();
if (nt) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
nt->_multipath->deleteNodes(prefs->getBool("/tools/nodes/delete_preserves_shape", true));
}
}
void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
{
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, _("Delete"),
1, _("Delete objects touched by the eraser"),
2, INKSCAPE_ICON("draw-eraser-delete-objects"),
-1 );
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter,
0, _("Cut"),
1, _("Cut out from objects"),
2, INKSCAPE_ICON("path-difference"),
-1 );
EgeSelectOneAction* act = ege_select_one_action_new( "EraserModeAction", (""), (""), 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, "eraser_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_tooltip_column( act, 1 );
/// @todo Convert to boolean?
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
gint eraserMode = prefs->getBool("/tools/eraser/mode") ? 1 : 0;
ege_select_one_action_set_active( act, eraserMode );
g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_erasertb_mode_changed), holder );
}
{
/* Width */
gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction",
_("Pen Width"), _("Width:"),
_("The width of the eraser pen (relative to the visible canvas area)"),
"/tools/eraser/width", 15,
GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-eraser",
1, 100, 1.0, 10.0,
labels, values, G_N_ELEMENTS(labels),
sp_erc_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 );
}
}
int sp_desktop_root_handler(SPCanvasItem */*item*/, GdkEvent *event, SPDesktop *desktop)
{
static bool watch = false;
static bool first = true;
if ( first ) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if ( prefs->getBool("/options/useextinput/value", true)
&& prefs->getBool("/options/switchonextinput/value") ) {
watch = true;
init_extended();
}
first = false;
}
if ( watch ) {
snoop_extended(event, desktop);
}
return sp_event_context_root_handler(desktop->event_context, event);
}
Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint const &p,
Inkscape::Snapper::SnapConstraint const &constraint,
Geom::OptRect const &bbox_to_snap) const
{
// First project the mouse pointer onto the constraint
Geom::Point pp = constraint.projection(p.getPoint());
Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(pp, p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, Geom::infinity(), 0, false, true, false);
if (!someSnapperMightSnap()) {
// Always return point on constraint
return no_snap;
}
Inkscape::SnappedPoint result = no_snap;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if ((prefs->getBool("/options/snapmousepointer/value", false)) && p.isSingleHandle()) {
// Snapping the mouse pointer instead of the constrained position of the knot allows
// to snap to things which don't intersect with the constraint line; this is basically
// then just a freesnap with the constraint applied afterwards
// We'll only do this if we're dragging a single handle, and for example not when transforming an object in the selector tool
result = freeSnap(p, bbox_to_snap);
if (result.getSnapped()) {
// only change the snap indicator if we really snapped to something
if (_snapindicator && _desktop) {
_desktop->snapindicator->set_new_snaptarget(result);
}
// Apply the constraint
result.setPoint(constraint.projection(result.getPoint()));
return result;
}
return no_snap;
}
IntermSnapResults isr;
SnapperList const snappers = getSnappers();
for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); ++i) {
(*i)->constrainedSnap(isr, p, bbox_to_snap, constraint, &_items_to_ignore, _unselected_nodes);
}
result = findBestSnap(p, isr, true);
if (result.getSnapped()) {
// only change the snap indicator if we really snapped to something
if (_snapindicator && _desktop) {
_desktop->snapindicator->set_new_snaptarget(result);
}
return result;
}
return no_snap;
}
/**
* Returns the current dropper context color.
*/
guint32 sp_dropper_context_get_color(SPEventContext *ec)
{
SPDropperContext *dc = SP_DROPPER_CONTEXT(ec);
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);
return SP_RGBA32_F_COMPOSE(dc->R, dc->G, dc->B,
(pick == SP_DROPPER_PICK_ACTUAL && setalpha) ? dc->alpha : 1.0);
}
xmlDocPtr XmlSource::readXml()
{
int parse_options = XML_PARSE_HUGE | XML_PARSE_RECOVER;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool allowNetAccess = prefs->getBool("/options/externalresources/xml/allow_net_access", false);
if (!allowNetAccess) parse_options |= XML_PARSE_NONET;
// Allow NOENT only if we're filtering out SYSTEM and PUBLIC entities
if (LoadEntities) parse_options |= XML_PARSE_NOENT;
return xmlReadIO( readCb, closeCb, this,
filename, getEncoding(), parse_options);
}
/**
* Mark the location of the snap source (not the snap target!) on the canvas by drawing a symbol.
*
* @param point_type Category of points to which the source point belongs: node, guide or bounding box
* @param p The transformed position of the source point, paired with an identifier of the type of the snap source.
*/
void SnapManager::displaySnapsource(Inkscape::SnapCandidatePoint const &p) const {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/options/snapclosestonly/value")) {
Inkscape::SnapSourceType t = p.getSourceType();
bool p_is_a_node = t & Inkscape::SNAPSOURCE_NODE_CATEGORY;
bool p_is_a_bbox = t & Inkscape::SNAPSOURCE_BBOX_CATEGORY;
bool p_is_other = (t & Inkscape::SNAPSOURCE_OTHERS_CATEGORY) || (t & Inkscape::SNAPSOURCE_DATUMS_CATEGORY);
g_assert(_desktop != NULL);
if (snapprefs.getSnapEnabledGlobally() && (p_is_other || (p_is_a_node && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_NODE_CATEGORY)) || (p_is_a_bbox && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_BBOX_CATEGORY)))) {
_desktop->snapindicator->set_new_snapsource(p);
} else {
_desktop->snapindicator->remove_snapsource();
}
}
}
/**
* Callback to setup SPPencilContext object.
*/
static void
sp_pencil_context_setup(SPEventContext *ec)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/tools/freehand/pencil/selcue")) {
ec->enableSelectionCue();
}
if (((SPEventContextClass *) pencil_parent_class)->setup) {
((SPEventContextClass *) pencil_parent_class)->setup(ec);
}
SPPencilContext *const pc = SP_PENCIL_CONTEXT(ec);
pc->is_drawing = false;
pc->anchor_statusbar = false;
}
void PowerStrokePointArrayParam::param_transform_multiply(Geom::Affine const &postmul, bool /*set*/)
{
// Check if proportional stroke-width scaling is on
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool transform_stroke = prefs ? prefs->getBool("/options/transform/stroke", true) : true;
if (transform_stroke) {
std::vector<Geom::Point> result;
result.reserve(_vector.size()); // reserve space for the points that will be added in the for loop
for (std::vector<Geom::Point>::const_iterator point_it = _vector.begin(), e = _vector.end();
point_it != e; ++point_it)
{
// scale each width knot with the average scaling in X and Y
Geom::Coord const A = (*point_it)[Geom::Y] * ((postmul.expansionX() + postmul.expansionY()) / 2);
result.push_back(Geom::Point((*point_it)[Geom::X], A));
}
param_set_and_write_new_value(result);
}
}
/**
* Public factory. Called by file.cpp, among others.
*/
FileOpenDialog *FileOpenDialog::create(Gtk::Window &parentWindow,
const Glib::ustring &path,
FileDialogType fileTypes,
const char *title)
{
#ifdef WIN32
FileOpenDialog *dialog = NULL;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool( "/options/desktopintegration/value")) {
dialog = new FileOpenDialogImplWin32(parentWindow, path, fileTypes, title);
} else {
dialog = new FileOpenDialogImplGtk(parentWindow, path, fileTypes, title);
}
#else
FileOpenDialog *dialog = new FileOpenDialogImplGtk(parentWindow, path, fileTypes, title);
#endif
return dialog;
}
void
lpetool_create_measuring_items(LpeTool *lc, Inkscape::Selection *selection)
{
if (!selection) {
selection = lc->desktop->getSelection();
}
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 = lc->desktop->getTempGroup();
gchar *arc_length;
double lengthval;
std::vector<SPItem*> items=selection->itemList();
for(std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();++i){
if (SP_IS_PATH(*i)) {
path = SP_PATH(*i);
curve = path->getCurve();
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));
Inkscape::Util::Unit const * unit = NULL;
if (prefs->getString("/tools/lpetool/unit").compare("")) {
unit = unit_table.getUnit(prefs->getString("/tools/lpetool/unit"));
} else {
unit = unit_table.getUnit("px");
}
lengthval = Geom::length(pwd2);
lengthval = Inkscape::Util::Quantity::convert(lengthval, "px", unit);
arc_length = g_strdup_printf("%.2f %s", lengthval, unit->abbr.c_str());
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_gradient_selector_edit_vector_clicked (GtkWidget */*w*/, SPGradientSelector *sel)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool("/dialogs/gradienteditor/showlegacy", false)) {
// Legacy gradient dialog
GtkWidget *dialog;
dialog = sp_gradient_vector_editor_new (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)->gr);
gtk_widget_show (dialog);
} else {
// Invoke the gradient tool
Inkscape::Verb *verb = Inkscape::Verb::get( SP_VERB_CONTEXT_GRADIENT );
if ( verb ) {
SPAction *action = verb->get_action( Inkscape::ActionContext( ( Inkscape::UI::View::View * ) SP_ACTIVE_DESKTOP ) );
if ( action ) {
sp_action_perform( action, NULL );
}
}
}
}
/**
* Public factory method. Used in file.cpp
*/
FileSaveDialog *FileSaveDialog::create(Gtk::Window& parentWindow,
const Glib::ustring &path,
FileDialogType fileTypes,
const char *title,
const Glib::ustring &default_key,
const gchar *docTitle,
const Inkscape::Extension::FileSaveMethod save_method)
{
#ifdef WIN32
FileSaveDialog *dialog = NULL;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if (prefs->getBool( "/options/desktopintegration/value")) {
dialog = new FileSaveDialogImplWin32(parentWindow, path, fileTypes, title, default_key, docTitle, save_method);
} else {
dialog = new FileSaveDialogImplGtk(parentWindow, path, fileTypes, title, default_key, docTitle, save_method);
}
#else
FileSaveDialog *dialog = new FileSaveDialogImplGtk(parentWindow, path, fileTypes, title, default_key, docTitle, save_method);
#endif
return dialog;
}
void SPGenericEllipse::position_set(gdouble x, gdouble y, gdouble rx, gdouble ry)
{
this->cx.computed = x;
this->cy.computed = y;
this->rx.computed = rx;
this->ry.computed = ry;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
// those pref values are in degrees, while we want radians
if (prefs->getDouble("/tools/shapes/arc/start", 0.0) != 0) {
this->start = Geom::Angle::from_degrees(prefs->getDouble("/tools/shapes/arc/start", 0.0)).radians0();
}
if (prefs->getDouble("/tools/shapes/arc/end", 0.0) != 0) {
this->end = Geom::Angle::from_degrees(prefs->getDouble("/tools/shapes/arc/end", 0.0)).radians0();
}
this->_closed = !prefs->getBool("/tools/shapes/arc/open");
this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
