SPDocument *
GdkpixbufInput::open(Inkscape::Extension::Input *mod, char const *uri)
{
// Determine whether the image should be embedded
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool ask = prefs->getBool("/dialogs/import/ask");
Glib::ustring link = prefs->getString("/dialogs/import/link");
bool forcexdpi = prefs->getBool("/dialogs/import/forcexdpi");
Glib::ustring scale = prefs->getString("/dialogs/import/scale");
// std::cout << "GkdpixbufInput::open: "
// << " ask: " << ask
// << ", link: " << link
// << ", forcexdpi: " << forcexdpi
// << ", scale: " << scale << std::endl;
// std::cout << " in preferences: "
// << " ask: " << !mod->get_param_bool("do_not_ask")
// << ", link: " << mod->get_param_optiongroup("link")
// << ", mod_dpi: " << mod->get_param_optiongroup("dpi")
// << ", scale: " << mod->get_param_optiongroup("scale") << std::endl;
if( ask ) {
Glib::ustring mod_link = mod->get_param_optiongroup("link");
Glib::ustring mod_dpi = mod->get_param_optiongroup("dpi");
bool mod_forcexdpi = ( mod_dpi.compare( "from_default" ) == 0 );
Glib::ustring mod_scale = mod->get_param_optiongroup("scale");
if( link.compare( mod_link ) != 0 ) {
link = mod_link;
}
prefs->setString("/dialogs/import/link", link );
if( forcexdpi != mod_forcexdpi ) {
forcexdpi = mod_forcexdpi;
}
prefs->setBool("/dialogs/import/forcexdpi", forcexdpi );
if( scale.compare( mod_scale ) != 0 ) {
scale = mod_scale;
}
prefs->setString("/dialogs/import/scale", scale );
prefs->setBool("/dialogs/import/ask", !mod->get_param_bool("do_not_ask") );
}
bool embed = ( link.compare( "embed" ) == 0 );
SPDocument *doc = NULL;
boost::scoped_ptr<Inkscape::Pixbuf> pb(Inkscape::Pixbuf::create_from_file(uri));
// TODO: the pixbuf is created again from the base64-encoded attribute in SPImage.
// Find a way to create the pixbuf only once.
if (pb) {
doc = SPDocument::createNewDoc(NULL, TRUE, TRUE);
bool saved = DocumentUndo::getUndoSensitive(doc);
DocumentUndo::setUndoSensitive(doc, false); // no need to undo in this temporary document
double width = pb->width();
double height = pb->height();
double defaultxdpi = prefs->getDouble("/dialogs/import/defaultxdpi/value", Inkscape::Util::Quantity::convert(1, "in", "px"));
//bool forcexdpi = prefs->getBool("/dialogs/import/forcexdpi");
ImageResolution *ir = 0;
double xscale = 1;
double yscale = 1;
if (!ir && !forcexdpi) {
ir = new ImageResolution(uri);
}
if (ir && ir->ok()) {
xscale = 900.0 / floor(10.*ir->x() + .5); // round-off to 0.1 dpi
yscale = 900.0 / floor(10.*ir->y() + .5);
} else {
xscale = 90.0 / defaultxdpi;
yscale = 90.0 / defaultxdpi;
}
width *= xscale;
height *= yscale;
delete ir; // deleting NULL is safe
// Create image node
Inkscape::XML::Document *xml_doc = doc->getReprDoc();
Inkscape::XML::Node *image_node = xml_doc->createElement("svg:image");
sp_repr_set_svg_double(image_node, "width", width);
sp_repr_set_svg_double(image_node, "height", height);
// Added 11 Feb 2014 as we now honor "preserveAspectRatio" and this is
// what Inkscaper's expect.
image_node->setAttribute("preserveAspectRatio", "none");
if( scale.compare( "auto" ) != 0 ) {
SPCSSAttr *css = sp_repr_css_attr_new();
sp_repr_css_set_property(css, "image-rendering", scale.c_str());
sp_repr_css_set(image_node, css, "style");
sp_repr_css_attr_unref( css );
}
if (embed) {
sp_embed_image(image_node, pb.get());
} else {
// convert filename to uri
gchar* _uri = g_filename_to_uri(uri, NULL, NULL);
if(_uri) {
image_node->setAttribute("xlink:href", _uri);
g_free(_uri);
} else {
image_node->setAttribute("xlink:href", uri);
}
}
// Add it to the current layer
doc->getRoot()->appendChildRepr(image_node);
Inkscape::GC::release(image_node);
fit_canvas_to_drawing(doc);
// Set viewBox if it doesn't exist
if (!doc->getRoot()->viewBox_set) {
//std::cout << "Viewbox not set, setting" << std::endl;
doc->setViewBox(Geom::Rect::from_xywh(0, 0, doc->getWidth().value(doc->getDefaultUnit()), doc->getHeight().value(doc->getDefaultUnit())));
}
// restore undo, as now this document may be shown to the user if a bitmap was opened
DocumentUndo::setUndoSensitive(doc, saved);
} else {
printf("GdkPixbuf loader failed\n");
}
return doc;
}
/**
* Given a repr, this sets the data items in the path object such as
* fill & style attributes, markers, and CSS properties.
*/
static void
sp_path_build (SPObject *object, SPDocument *document, SPRepr *repr)
{
SPPath *path;
SPVersion version;
const gchar* marker_value;
path = SP_PATH (object);
version = sp_object_get_sodipodi_version (object);
/* Fixes old Sodipodi nodetype to namespaced parameter */
if (sp_version_inside_range (version, 0, 0, 0, 25)) {
const gchar *str;
str = sp_repr_attr (repr, "INKSCAPE-PATH-NODE-TYPES");
sp_repr_set_attr (repr, "sodipodi:nodetypes", str);
sp_repr_set_attr (repr, "INKSCAPE-PATH-NODE-TYPES", NULL);
}
sp_object_read_attr (object, "d");
/* Are these calls actually necessary? */
sp_object_read_attr (object, "marker");
sp_object_read_attr (object, "marker-start");
sp_object_read_attr (object, "marker-mid");
sp_object_read_attr (object, "marker-end");
if (sp_version_inside_range (version, 0, 0, 0, 25)) {
SPShape *shape;
SPCSSAttr *css;
const gchar *val;
gboolean changed;
gboolean open;
shape = (SPShape *) path;
/* Remove fill from open paths for compatibility with inkscape < 0.25 */
/* And set fill-rule of closed paths to evenodd */
/* We force style rewrite at moment (Lauris) */
changed = TRUE;
open = FALSE;
if (shape->curve && shape->curve->bpath) {
ArtBpath *bp;
for (bp = shape->curve->bpath; bp->code != ART_END; bp++) {
if (bp->code == ART_MOVETO_OPEN) {
open = TRUE;
break;
}
}
}
css = sp_repr_css_attr (repr, "style");
if (open) {
val = sp_repr_css_property (css, "fill", NULL);
if (val && strcmp (val, "none")) {
sp_repr_css_set_property (css, "fill", "none");
changed = TRUE;
}
} else {
val = sp_repr_css_property (css, "fill-rule", NULL);
if (!val) {
sp_repr_css_set_property (css, "fill-rule", "evenodd");
changed = TRUE;
}
}
if (changed) {
sp_repr_css_set (repr, css, "style");
}
sp_repr_css_attr_unref (css);
}
if (((SPObjectClass *) parent_class)->build) {
((SPObjectClass *) parent_class)->build (object, document, repr);
}
}
static void
sp_star_drag (SPStarContext * sc, double x, double y, guint state)
{
SPStar *star;
SPDesktop * desktop;
NRPointF p0, p1;
gdouble sides, dx, dy, r1, arg1;
GString * xs, * ys;
gchar status[80];
NRPointF fp;
desktop = SP_EVENT_CONTEXT (sc)->desktop;
if (!sc->item) {
SPRepr * repr, * style;
SPCSSAttr * css;
/* Create object */
repr = sp_repr_new ("polygon");
sp_repr_set_attr (repr, "sodipodi:type", "star");
/* Set style */
style = inkscape_get_repr (INKSCAPE, "tools.shapes.star");
if (style) {
css = sp_repr_css_attr_inherited (style, "style");
sp_repr_css_set (repr, css, "style");
sp_repr_css_attr_unref (css);
}
sc->item = (SPItem *) sp_document_add_repr (SP_DT_DOCUMENT (desktop), repr);
sp_repr_unref (repr);
}
/* This is bit ugly, but so we are */
/* if (state & GDK_CONTROL_MASK) { */
/* } else if (state & GDK_SHIFT_MASK) { */
/* Free movement for corner point */
sp_desktop_dt2root_xy_point (desktop, &fp, sc->center.x, sc->center.y);
p0.x = fp.x;
p0.y = fp.y;
sp_desktop_dt2root_xy_point (desktop, &fp, x, y);
p1.x = fp.x;
p1.y = fp.y;
sp_desktop_free_snap (desktop, &p1);
star = SP_STAR(sc->item);
sides = (gdouble) sc->magnitude;
dx = p1.x - p0.x;
dy = p1.y - p0.y;
r1 = hypot (dx, dy);
arg1 = atan2 (dy, dx);
#if 0
sp_star_set (star, sc->magnitude, p0.x, p0.y, r1, r1 * (sides-2.0)/sides, arg1, arg1 + M_PI/sides);
#else
sp_star_position_set (star, sc->magnitude, p0.x, p0.y, r1, r1 * sc->proportion, arg1, arg1 + M_PI / sides);
#endif
/* status text */
xs = SP_PT_TO_METRIC_STRING (fabs(p0.x), SP_DEFAULT_METRIC);
ys = SP_PT_TO_METRIC_STRING (fabs(p0.y), SP_DEFAULT_METRIC);
sprintf (status, "Draw star at (%s,%s)", xs->str, ys->str);
sp_view_set_status (SP_VIEW (desktop), status, FALSE);
g_string_free (xs, FALSE);
g_string_free (ys, FALSE);
}
static void
spdc_flush_white (SPDrawContext *dc, SPCurve *gc)
{
SPCurve *c;
if (dc->white_curves) {
g_assert (dc->white_item);
c = sp_curve_concat (dc->white_curves);
g_slist_free (dc->white_curves);
dc->white_curves = NULL;
if (gc) {
sp_curve_append (c, gc, FALSE);
}
} else if (gc) {
c = gc;
sp_curve_ref (c);
} else {
return;
}
/* Now we have to go back to item coordinates at last */
if (dc->white_item) {
NRMatrixD d2itemd;
sp_item_dt2i_affine_d (dc->white_item, SP_EVENT_CONTEXT_DESKTOP (dc), &d2itemd);
c = sp_curve_transform (c, NR_MATRIX_D_TO_DOUBLE (&d2itemd));
} else {
gdouble d2item[6];
sp_desktop_dt2root_affine (SP_EVENT_CONTEXT_DESKTOP (dc), (NRMatrixD *) d2item);
c = sp_curve_transform (c, d2item);
}
if (c && !sp_curve_empty (c)) {
SPDesktop *dt;
SPDocument *doc;
SPRepr *repr;
gchar *str;
/* We actually have something to write */
dt = SP_EVENT_CONTEXT_DESKTOP (dc);
doc = SP_DT_DOCUMENT (dt);
if (dc->white_item) {
repr = SP_OBJECT_REPR (dc->white_item);
} else {
SPRepr *style;
repr = sp_repr_new ("path");
/* fixme: Pen and pencil need separate style (Lauris) */
style = inkscape_get_repr (INKSCAPE, "tools.freehand");
if (style) {
SPCSSAttr *css;
css = sp_repr_css_attr_inherited (style, "style");
sp_repr_css_set (repr, css, "style");
sp_repr_css_attr_unref (css);
}
}
str = sp_svg_write_path (SP_CURVE_BPATH (c));
g_assert (str != NULL);
sp_repr_set_attr (repr, "d", str);
g_free (str);
if (!dc->white_item) {
/* Attach repr */
sp_document_add_repr (SP_DT_DOCUMENT (dt), repr);
sp_selection_set_repr (dc->selection, repr);
sp_repr_unref (repr);
}
sp_document_done (doc);
}
sp_curve_unref (c);
/* Flush pending updates */
sp_document_ensure_up_to_date (SP_DT_DOCUMENT (SP_EVENT_CONTEXT_DESKTOP (dc)));
}
