// Create a mask element (using passed elements), add it to <defs>
const gchar *
sp_clippath_create (GSList *reprs, SPDocument *document, Geom::Matrix const* applyTransform)
{
Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (document));
Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
Inkscape::XML::Node *repr = xml_doc->createElement("svg:clipPath");
repr->setAttribute("clipPathUnits", "userSpaceOnUse");
defsrepr->appendChild(repr);
const gchar *id = repr->attribute("id");
SPObject *clip_path_object = document->getObjectById(id);
for (GSList *it = reprs; it != NULL; it = it->next) {
Inkscape::XML::Node *node = (Inkscape::XML::Node *)(it->data);
SPItem *item = SP_ITEM(clip_path_object->appendChildRepr(node));
if (NULL != applyTransform) {
Geom::Matrix transform (item->transform);
transform *= (*applyTransform);
sp_item_write_transform(item, SP_OBJECT_REPR(item), transform);
}
}
Inkscape::GC::release(repr);
return id;
}
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);
}
void
text_put_on_path()
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
if (!desktop)
return;
Inkscape::Selection *selection = sp_desktop_selection(desktop);
SPItem *text = text_or_flowtext_in_selection(selection);
SPItem *shape = shape_in_selection(selection);
Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
if (!text || !shape || g_slist_length((GSList *) selection->itemList()) != 2) {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>a text and a path</b> to put text on path."));
return;
}
if (SP_IS_TEXT_TEXTPATH(text)) {
sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("This text object is <b>already put on a path</b>. Remove it from the path first. Use <b>Shift+D</b> to look up its path."));
return;
}
if (SP_IS_RECT(shape)) {
// rect is the only SPShape which is not <path> yet, and thus SVG forbids us from putting text on it
sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("You cannot put text on a rectangle in this version. Convert rectangle to path first."));
return;
}
// if a flowed text is selected, convert it to a regular text object
if (SP_IS_FLOWTEXT(text)) {
if (!SP_FLOWTEXT(text)->layout.outputExists()) {
sp_desktop_message_stack(desktop)->
flash(Inkscape::WARNING_MESSAGE,
_("The flowed text(s) must be <b>visible</b> in order to be put on a path."));
}
Inkscape::XML::Node *repr = SP_FLOWTEXT(text)->getAsText();
if (!repr) return;
Inkscape::XML::Node *parent = SP_OBJECT_REPR(text)->parent();
parent->appendChild(repr);
SPItem *new_item = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
sp_item_write_transform(new_item, repr, text->transform);
SP_OBJECT(new_item)->updateRepr();
Inkscape::GC::release(repr);
text->deleteObject(); // delete the orignal flowtext
sp_document_ensure_up_to_date(sp_desktop_document(desktop));
selection->clear();
text = new_item; // point to the new text
}
Inkscape::Text::Layout const *layout = te_get_layout(text);
Inkscape::Text::Layout::Alignment text_alignment = layout->paragraphAlignment(layout->begin());
// remove transform from text, but recursively scale text's fontsize by the expansion
SP_TEXT(text)->_adjustFontsizeRecursive (text, NR::expansion(SP_ITEM(text)->transform));
SP_OBJECT_REPR(text)->setAttribute("transform", NULL);
// make a list of text children
GSList *text_reprs = NULL;
for (SPObject *o = SP_OBJECT(text)->children; o != NULL; o = o->next) {
text_reprs = g_slist_prepend(text_reprs, SP_OBJECT_REPR(o));
}
// create textPath and put it into the text
Inkscape::XML::Node *textpath = xml_doc->createElement("svg:textPath");
// reference the shape
textpath->setAttribute("xlink:href", g_strdup_printf("#%s", SP_OBJECT_REPR(shape)->attribute("id")));
if (text_alignment == Inkscape::Text::Layout::RIGHT)
textpath->setAttribute("startOffset", "100%");
else if (text_alignment == Inkscape::Text::Layout::CENTER)
textpath->setAttribute("startOffset", "50%");
SP_OBJECT_REPR(text)->addChild(textpath, NULL);
for ( GSList *i = text_reprs ; i ; i = i->next ) {
// Make a copy of each text child
Inkscape::XML::Node *copy = ((Inkscape::XML::Node *) i->data)->duplicate(xml_doc);
// We cannot have multiline in textpath, so remove line attrs from tspans
if (!strcmp(copy->name(), "svg:tspan")) {
copy->setAttribute("sodipodi:role", NULL);
copy->setAttribute("x", NULL);
copy->setAttribute("y", NULL);
}
// remove the old repr from under text
SP_OBJECT_REPR(text)->removeChild((Inkscape::XML::Node *) i->data);
// put its copy into under textPath
textpath->addChild(copy, NULL); // fixme: copy id
}
// x/y are useless with textpath, and confuse Batik 1.5
SP_OBJECT_REPR(text)->setAttribute("x", NULL);
SP_OBJECT_REPR(text)->setAttribute("y", NULL);
sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
_("Put text on path"));
g_slist_free(text_reprs);
}
void
flowtext_to_text()
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
Inkscape::Selection *selection = sp_desktop_selection(desktop);
if (selection->isEmpty()) {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE,
_("Select <b>flowed text(s)</b> to convert."));
return;
}
bool did = false;
GSList *reprs = NULL;
GSList *items = g_slist_copy((GSList *) selection->itemList());
for (; items != NULL; items = items->next) {
SPItem *item = (SPItem *) items->data;
if (!SP_IS_FLOWTEXT(item))
continue;
if (!SP_FLOWTEXT(item)->layout.outputExists()) {
sp_desktop_message_stack(desktop)->
flash(Inkscape::WARNING_MESSAGE,
_("The flowed text(s) must be <b>visible</b> in order to be converted."));
return;
}
Inkscape::XML::Node *repr = SP_FLOWTEXT(item)->getAsText();
if (!repr) break;
did = true;
Inkscape::XML::Node *parent = SP_OBJECT_REPR(item)->parent();
parent->addChild(repr, SP_OBJECT_REPR(item));
SPItem *new_item = (SPItem *) sp_desktop_document(desktop)->getObjectByRepr(repr);
sp_item_write_transform(new_item, repr, item->transform);
SP_OBJECT(new_item)->updateRepr();
Inkscape::GC::release(repr);
item->deleteObject();
reprs = g_slist_prepend(reprs, repr);
}
g_slist_free(items);
if (did) {
sp_document_done(sp_desktop_document(desktop),
SP_VERB_OBJECT_FLOWTEXT_TO_TEXT,
_("Convert flowed text to text"));
selection->setReprList(reprs);
} else {
sp_desktop_message_stack(desktop)->
flash(Inkscape::ERROR_MESSAGE,
_("<b>No flowed text(s)</b> to convert in the selection."));
}
g_slist_free(reprs);
}
/**
* Threaded method that does single bitmap--->path conversion
*/
void Tracer::traceThread()
{
//## Remember. NEVER leave this method without setting
//## engine back to NULL
//## Prepare our kill flag. We will watch this later to
//## see if the main thread wants us to stop
keepGoing = true;
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
if (!desktop)
{
g_warning("Trace: No active desktop\n");
return;
}
Inkscape::MessageStack *msgStack = sp_desktop_message_stack(desktop);
Inkscape::Selection *selection = sp_desktop_selection (desktop);
if (!SP_ACTIVE_DOCUMENT)
{
char *msg = _("Trace: No active document");
msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
//g_warning(msg);
engine = NULL;
return;
}
SPDocument *doc = SP_ACTIVE_DOCUMENT;
sp_document_ensure_up_to_date(doc);
SPImage *img = getSelectedSPImage();
if (!img)
{
engine = NULL;
return;
}
Glib::RefPtr<Gdk::Pixbuf> pixbuf = Glib::wrap(img->pixbuf, true);
pixbuf = sioxProcessImage(img, pixbuf);
if (!pixbuf)
{
char *msg = _("Trace: Image has no bitmap data");
msgStack->flash(Inkscape::ERROR_MESSAGE, msg);
//g_warning(msg);
engine = NULL;
return;
}
msgStack->flash(Inkscape::NORMAL_MESSAGE, _("Trace: Starting trace..."));
desktop->updateCanvasNow();
std::vector<TracingEngineResult> results =
engine->trace(pixbuf);
//printf("nrPaths:%d\n", results.size());
int nrPaths = results.size();
//### Check if we should stop
if (!keepGoing || nrPaths<1)
{
engine = NULL;
return;
}
//### Get pointers to the <image> and its parent
Inkscape::XML::Node *imgRepr = SP_OBJECT(img)->repr;
Inkscape::XML::Node *par = sp_repr_parent(imgRepr);
//### Get some information for the new transform()
double x = 0.0;
double y = 0.0;
double width = 0.0;
double height = 0.0;
double dval = 0.0;
if (sp_repr_get_double(imgRepr, "x", &dval))
x = dval;
if (sp_repr_get_double(imgRepr, "y", &dval))
y = dval;
if (sp_repr_get_double(imgRepr, "width", &dval))
width = dval;
if (sp_repr_get_double(imgRepr, "height", &dval))
height = dval;
double iwidth = (double)pixbuf->get_width();
double iheight = (double)pixbuf->get_height();
double iwscale = width / iwidth;
double ihscale = height / iheight;
Geom::Translate trans(x, y);
Geom::Scale scal(iwscale, ihscale);
//# Convolve scale, translation, and the original transform
Geom::Matrix tf(scal * trans);
tf *= img->transform;
//#OK. Now let's start making new nodes
Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
Inkscape::XML::Node *groupRepr = NULL;
//# if more than 1, make a <g>roup of <path>s
if (nrPaths > 1)
{
groupRepr = xml_doc->createElement("svg:g");
par->addChild(groupRepr, imgRepr);
}
long totalNodeCount = 0L;
for (unsigned int i=0 ; i<results.size() ; i++)
{
TracingEngineResult result = results[i];
totalNodeCount += result.getNodeCount();
Inkscape::XML::Node *pathRepr = xml_doc->createElement("svg:path");
pathRepr->setAttribute("style", result.getStyle().c_str());
pathRepr->setAttribute("d", result.getPathData().c_str());
if (nrPaths > 1)
groupRepr->addChild(pathRepr, NULL);
else
par->addChild(pathRepr, imgRepr);
//### Apply the transform from the image to the new shape
SPObject *reprobj = doc->getObjectByRepr(pathRepr);
if (reprobj)
{
SPItem *newItem = SP_ITEM(reprobj);
sp_item_write_transform(newItem, pathRepr, tf, NULL);
}
if (nrPaths == 1)
{
selection->clear();
selection->add(pathRepr);
}
Inkscape::GC::release(pathRepr);
}
// If we have a group, then focus on, then forget it
if (nrPaths > 1)
{
selection->clear();
selection->add(groupRepr);
Inkscape::GC::release(groupRepr);
}
//## inform the document, so we can undo
sp_document_done(doc, SP_VERB_SELECTION_TRACE, _("Trace bitmap"));
engine = NULL;
char *msg = g_strdup_printf(_("Trace: Done. %ld nodes created"), totalNodeCount);
msgStack->flash(Inkscape::NORMAL_MESSAGE, msg);
g_free(msg);
}
void
sp_sel_trans_ungrab (SPSelTrans * seltrans)
{
SPItem * item;
const GSList * l;
gchar tstr[80];
NRPointD p;
unsigned int updh;
g_return_if_fail (seltrans->grabbed);
updh = TRUE;
if (!seltrans->empty && seltrans->changed) {
l = sp_selection_item_list (SP_DT_SELECTION (seltrans->desktop));
tstr[79] = '\0';
while (l != NULL) {
item = SP_ITEM (l->data);
/* fixme: We do not have to set it here (Lauris) */
if (seltrans->show == SP_SELTRANS_SHOW_OUTLINE) {
NRMatrixF i2d, i2dnew;
sp_item_i2d_affine (item, &i2d);
nr_matrix_multiply_ffd (&i2dnew, &i2d, &seltrans->current);
sp_item_set_i2d_affine (item, &i2dnew);
}
if (seltrans->transform == SP_SELTRANS_TRANSFORM_OPTIMIZE) {
sp_item_write_transform (item, SP_OBJECT_REPR (item), &item->transform);
/* because item/repr affines may be out of sync, invoke reread */
/* fixme: We should test equality to avoid unnecessary rereads */
/* fixme: This probably is not needed (Lauris) */
sp_object_read_attr (SP_OBJECT (item), "transform");
} else {
if (sp_svg_transform_write (tstr, 79, &item->transform)) {
sp_repr_set_attr (SP_OBJECT (item)->repr, "transform", tstr);
} else {
sp_repr_set_attr (SP_OBJECT (item)->repr, "transform", NULL);
}
}
l = l->next;
}
p = seltrans->center;
seltrans->center.x = NR_MATRIX_DF_TRANSFORM_X (&seltrans->current, p.x, p.y);
seltrans->center.y = NR_MATRIX_DF_TRANSFORM_Y (&seltrans->current, p.x, p.y);
sp_document_done (SP_DT_DOCUMENT (seltrans->desktop));
sp_selection_changed (SP_DT_SELECTION (seltrans->desktop));
updh = FALSE;
}
if (seltrans->items) {
int i;
for (i = 0; i < seltrans->nitems; i++) sp_object_unref (SP_OBJECT (seltrans->items[i]), NULL);
nr_free (seltrans->items);
seltrans->items = NULL;
}
if (seltrans->transforms) {
nr_free (seltrans->transforms);
seltrans->transforms = NULL;
}
seltrans->nitems = 0;
seltrans->grabbed = FALSE;
seltrans->show_handles = TRUE;
sp_canvas_item_hide (seltrans->norm);
sp_canvas_item_hide (seltrans->grip);
if (seltrans->show == SP_SELTRANS_SHOW_OUTLINE) {
sp_canvas_item_hide (seltrans->l1);
sp_canvas_item_hide (seltrans->l2);
sp_canvas_item_hide (seltrans->l3);
sp_canvas_item_hide (seltrans->l4);
}
sp_sel_trans_update_volatile_state (seltrans);
if (updh) sp_sel_trans_update_handles (seltrans);
if (seltrans->stamp_cache) {
g_slist_free(seltrans->stamp_cache);
seltrans->stamp_cache = NULL;
}
}
