static void
sp_text_edit_dialog_apply( GtkButton */*button*/, GtkWidget *dlg )
{
g_object_set_data (G_OBJECT (dlg), "blocked", GINT_TO_POINTER (TRUE));
GtkWidget *apply = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "apply");
GtkWidget *def = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "default");
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
unsigned items = 0;
const GSList *item_list = sp_desktop_selection(desktop)->itemList();
SPCSSAttr *css = sp_get_text_dialog_style ();
sp_desktop_set_style(desktop, css, true);
for (; item_list != NULL; item_list = item_list->next) {
// apply style to the reprs of all text objects in the selection
if (SP_IS_TEXT (item_list->data)) {
// backwards compatibility:
SP_OBJECT_REPR(item_list->data)->setAttribute("sodipodi:linespacing", sp_repr_css_property (css, "line-height", NULL));
++items;
}
else if (SP_IS_FLOWTEXT (item_list->data))
// no need to set sodipodi:linespacing, because Inkscape never supported it on flowtext
++items;
}
if (items == 0) {
// no text objects; apply style to prefs for new objects
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
prefs->mergeStyle("/tools/text/style", css);
gtk_widget_set_sensitive (def, FALSE);
} else if (items == 1) {
/* exactly one text object; now set its text, too */
SPItem *item = sp_desktop_selection(SP_ACTIVE_DESKTOP)->singleItem();
if (SP_IS_TEXT (item) || SP_IS_FLOWTEXT(item)) {
sp_text_edit_dialog_update_object_text (item);
}
}
// complete the transaction
sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
_("Set text style"));
gtk_widget_set_sensitive (apply, FALSE);
sp_repr_css_attr_unref (css);
g_object_set_data (G_OBJECT (dlg), "blocked", GINT_TO_POINTER (FALSE));
}
//FIXME: must work with text selection
void
text_remove_all_kerns()
{
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>text(s)</b> to remove kerns from."));
return;
}
bool did = false;
for (GSList *items = g_slist_copy((GSList *) selection->itemList());
items != NULL;
items = items->next) {
SPObject *obj = SP_OBJECT(items->data);
if (!SP_IS_TEXT(obj) && !SP_IS_TSPAN(obj) && !SP_IS_FLOWTEXT(obj)) {
continue;
}
text_remove_all_kerns_recursively(obj);
obj->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_TEXT_LAYOUT_MODIFIED_FLAG);
did = true;
}
if (!did) {
sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("Select <b>text(s)</b> to remove kerns from."));
} else {
sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
_("Remove manual kerns"));
}
}
void SPUsePath::refresh_source()
{
sourceDirty = false;
delete originalPath;
originalPath = NULL;
// le mauvais cas: pas d'attribut d => il faut verifier que c'est une SPShape puis prendre le contour
// [tr: The bad case: no d attribute. Must check that it's a SPShape and then take the outline.]
SPObject *refobj = sourceObject;
if ( refobj == NULL ) return;
SPItem *item = SP_ITEM(refobj);
SPCurve *curve = NULL;
if (SP_IS_SHAPE(item))
{
curve = SP_SHAPE(item)->getCurve();
}
else if (SP_IS_TEXT(item))
{
curve = SP_TEXT(item)->getNormalizedBpath();
}
else
{
return;
}
if (curve == NULL)
return;
originalPath = new Path;
originalPath->LoadPathVector(curve->get_pathvector(), item->transform, true);
curve->unref();
}
Inkscape::XML::Node* SPUse::write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
repr = xml_doc->createElement("svg:use");
}
SPItem::write(xml_doc, repr, flags);
sp_repr_set_svg_double(repr, "x", this->x.computed);
sp_repr_set_svg_double(repr, "y", this->y.computed);
repr->setAttribute("width", sp_svg_length_write_with_units(this->width).c_str());
repr->setAttribute("height", sp_svg_length_write_with_units(this->height).c_str());
if (this->ref->getURI()) {
gchar *uri_string = this->ref->getURI()->toString();
repr->setAttribute("xlink:href", uri_string);
g_free(uri_string);
}
if (SP_IS_SHAPE(this->child)) {
SP_SHAPE(this->child)->set_shape(); // evaluate SPCurve of child
} else if (SP_IS_TEXT(this->child)) {
SP_TEXT(this->child)->rebuildLayout(); // refresh Layout, LP Bug 1339305
} else if (SP_IS_FLOWTEXT(this->child)) {
if (SP_IS_FLOWREGION(SP_FLOWTEXT(this->child)->firstChild()))
SP_FLOWREGION(SP_FLOWTEXT(this->child)->firstChild())->UpdateComputed();
SP_FLOWTEXT(this->child)->rebuildLayout();
}
return repr;
}
Geom::OptRect SPTRef::bbox(Geom::Affine const &transform, SPItem::BBoxType type) const {
Geom::OptRect bbox;
// find out the ancestor text which holds our layout
SPObject const *parent_text = this;
while ( parent_text && !SP_IS_TEXT(parent_text) ) {
parent_text = parent_text->parent;
}
if (parent_text == NULL) {
return bbox;
}
// get the bbox of our portion of the layout
bbox = SP_TEXT(parent_text)->layout.bounds(transform,
sp_text_get_length_upto(parent_text, this), sp_text_get_length_upto(this, NULL) - 1);
// Add stroke width
// FIXME this code is incorrect
if (bbox && type == SPItem::VISUAL_BBOX && !this->style->stroke.isNone()) {
double scale = transform.descrim();
bbox->expandBy(0.5 * this->style->stroke_width.computed * scale);
}
return bbox;
}
static void sp_tspan_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const /*flags*/)
{
// find out the ancestor text which holds our layout
SPObject *parent_text = SP_OBJECT(item);
for (; parent_text != NULL && !SP_IS_TEXT(parent_text); parent_text = SP_OBJECT_PARENT (parent_text)){};
if (parent_text == NULL) return;
// get the bbox of our portion of the layout
SP_TEXT(parent_text)->layout.getBoundingBox(bbox, transform, sp_text_get_length_upto(parent_text, item), sp_text_get_length_upto(item, NULL) - 1);
// Add stroke width
SPStyle* style=SP_OBJECT_STYLE (item);
if (!style->stroke.isNone()) {
double const scale = transform.descrim();
if ( fabs(style->stroke_width.computed * scale) > 0.01 ) { // sinon c'est 0=oon veut pas de bord
double const width = MAX(0.125, style->stroke_width.computed * scale);
if ( fabs(bbox->x1 - bbox->x0) > -0.00001 && fabs(bbox->y1 - bbox->y0) > -0.00001 ) {
bbox->x0-=0.5*width;
bbox->x1+=0.5*width;
bbox->y0-=0.5*width;
bbox->y1+=0.5*width;
}
}
}
}
SPItem *
text_or_flowtext_in_selection(Inkscape::Selection *selection)
{
for (GSList *items = (GSList *) selection->itemList();
items != NULL;
items = items->next) {
if (SP_IS_TEXT(items->data) || SP_IS_FLOWTEXT(items->data))
return ((SPItem *) items->data);
}
return NULL;
}
static SPText *
sp_ted_get_selected_text_item (void)
{
const GSList *item;
if (!SP_ACTIVE_DESKTOP) return NULL;
item = sp_selection_item_list(SP_DT_SELECTION (SP_ACTIVE_DESKTOP));
for (; item != NULL; item = item->next) {
if (SP_IS_TEXT(item->data)) return SP_TEXT (item->data);
}
return NULL;
}
static unsigned
sp_ted_get_selected_text_count (void)
{
const GSList *item;
unsigned items;
if (!SP_ACTIVE_DESKTOP) return 0;
items = 0;
item = sp_selection_item_list(SP_DT_SELECTION (SP_ACTIVE_DESKTOP));
for (; item != NULL; item = item->next) {
if (SP_IS_TEXT(item->data)) ++items;
}
return items;
}
static SPItem *
sp_ted_get_selected_text_item (void)
{
if (!SP_ACTIVE_DESKTOP)
return NULL;
for (const GSList *item = sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList();
item != NULL;
item = item->next)
{
if (SP_IS_TEXT(item->data) || SP_IS_FLOWTEXT(item->data))
return SP_ITEM (item->data);
}
return NULL;
}
static unsigned
sp_ted_get_selected_text_count (void)
{
if (!SP_ACTIVE_DESKTOP)
return 0;
unsigned int items = 0;
for (const GSList *item = sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList();
item != NULL;
item = item->next)
{
if (SP_IS_TEXT(item->data) || SP_IS_FLOWTEXT(item->data))
++items;
}
return items;
}
void
sp_help_about (void)
{
SPDocument *doc;
SPObject *title;
GtkWidget *v;
gint width, height;
if (!w) {
doc = sp_document_new (INKSCAPE_PIXMAPDIR "/about.svg", FALSE, TRUE);
g_return_if_fail (doc != NULL);
title = sp_document_lookup_id (doc, "title");
if (title && SP_IS_TEXT (title)) {
gchar *t;
t = g_strdup_printf ("Inkscape %s", INKSCAPE_VERSION);
sp_text_set_repr_text_multiline (SP_TEXT (title), t);
g_free (t);
}
sp_document_ensure_up_to_date (doc);
w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (w), _("About Inkscape"));
width = INK_STATIC_CAST( gint, CLAMP( sp_document_width(doc), WINDOW_MIN, WINDOW_MAX ) );
height = INK_STATIC_CAST( gint, CLAMP( sp_document_height(doc), WINDOW_MIN, WINDOW_MAX ) );
gtk_window_set_default_size (GTK_WINDOW (w), width, height );
gtk_window_set_position(GTK_WINDOW(w), GTK_WIN_POS_CENTER);
#if 1
gtk_window_set_policy (GTK_WINDOW (w), TRUE, TRUE, FALSE);
#endif
gtk_signal_connect (GTK_OBJECT (w), "delete_event", GTK_SIGNAL_FUNC (sp_help_about_delete), NULL);
v = sp_svg_view_widget_new (doc);
sp_svg_view_widget_set_resize (SP_SVG_VIEW_WIDGET (v), FALSE, sp_document_width (doc), sp_document_height (doc));
sp_document_unref (doc);
gtk_widget_show (v);
gtk_container_add (GTK_CONTAINER (w), v);
}
gtk_window_present ((GtkWindow *) w);
}
Gtk::Widget *build_splash_widget() {
/* TRANSLATORS: This is the filename of the `About Inkscape' picture in
the `screens' directory. Thus the translation of "about.svg" should be
the filename of its translated version, e.g. about.zh.svg for Chinese.
N.B. about.svg changes once per release. (We should probably rename
the original to about-0.40.svg etc. as soon as we have a translation.
If we do so, then add an item to release-checklist saying that the
string here should be changed.) */
// FIXME? INKSCAPE_SCREENSDIR and "about.svg" are in UTF-8, not the
// native filename encoding... and the filename passed to sp_document_new
// should be in UTF-*8..
char *about=g_build_filename(INKSCAPE_SCREENSDIR, _("about.svg"), NULL);
SPDocument *doc=SPDocument::createNewDoc (about, TRUE);
g_free(about);
g_return_val_if_fail(doc != NULL, NULL);
SPObject *version = doc->getObjectById("version");
if ( version && SP_IS_TEXT(version) ) {
sp_te_set_repr_text_multiline (SP_TEXT (version), Inkscape::version_string);
}
doc->ensureUpToDate();
GtkWidget *v=sp_svg_view_widget_new(doc);
double width=doc->getWidth().value("px");
double height=doc->getHeight().value("px");
doc->doUnref();
SP_SVG_VIEW_WIDGET(v)->setResize(false, static_cast<int>(width), static_cast<int>(height));
Gtk::AspectFrame *frame=new Gtk::AspectFrame();
frame->unset_label();
frame->set_shadow_type(Gtk::SHADOW_NONE);
frame->property_ratio() = width / height;
frame->add(*manage(Glib::wrap(v)));
return frame;
}
static void GetDest(SPObject* child,Shape **computed)
{
if ( child == NULL ) return;
SPCurve *curve=NULL;
Geom::Matrix tr_mat;
SPObject* u_child=child;
if ( SP_IS_USE(u_child) ) {
u_child=SP_USE(u_child)->child;
tr_mat = SP_ITEM(u_child)->getRelativeTransform(SP_OBJECT_PARENT(child));
} else {
tr_mat = SP_ITEM(u_child)->transform;
}
if ( SP_IS_SHAPE (u_child) ) {
curve = sp_shape_get_curve (SP_SHAPE (u_child));
} else if ( SP_IS_TEXT (u_child) ) {
curve = SP_TEXT (u_child)->getNormalizedBpath ();
}
if ( curve ) {
Path* temp=new Path;
temp->LoadPathVector(curve->get_pathvector(), tr_mat, true);
Shape* n_shp=new Shape;
temp->Convert(0.25);
temp->Fill(n_shp,0);
Shape* uncross=new Shape;
SPStyle* style=SP_OBJECT_STYLE(u_child);
if ( style && style->fill_rule.computed == SP_WIND_RULE_EVENODD ) {
uncross->ConvertToShape(n_shp,fill_oddEven);
} else {
uncross->ConvertToShape(n_shp,fill_nonZero);
}
UnionShape(computed, uncross);
delete uncross;
delete n_shp;
delete temp;
curve->unref();
} else {
// printf("no curve\n");
}
}
bool
item_text_match (SPItem *item, const gchar *text, bool exact)
{
if (SP_OBJECT_REPR (item) == NULL)
return false;
if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) {
const gchar *item_text = sp_te_get_string_multiline (item);
if (item_text == NULL)
return false;
bool ret;
if (exact) {
ret = ((bool) !strcasecmp(item_text, text));
} else {
//FIXME: strcasestr
ret = ((bool) (strstr(item_text, text) != NULL));
}
g_free ((void*) item_text);
return ret;
}
return false;
}
static void
sp_text_edit_dialog_apply (GtkButton *button, GtkWidget *dlg)
{
GtkWidget *apply, *def;
SPText *text;
SPRepr *repr;
const GSList *item;
unsigned items;
g_object_set_data (G_OBJECT (dlg), "blocked", GINT_TO_POINTER (TRUE));
apply = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "apply");
def = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "default");
text = NULL;
items = 0;
item = sp_selection_item_list(SP_DT_SELECTION (SP_ACTIVE_DESKTOP));
for (; item != NULL; item = item->next) {
if (!SP_IS_TEXT (item->data)) continue;
text = SP_TEXT(item->data);
repr = SP_OBJECT_REPR (text);
sp_text_edit_dialog_update_object (NULL, repr);
++items;
}
if (items == 1) {
sp_text_edit_dialog_update_object (text, NULL);
} else if (items == 0) {
repr = inkscape_get_repr (INKSCAPE, "tools.text");
sp_text_edit_dialog_update_object (NULL, repr);
gtk_widget_set_sensitive (def, FALSE);
}
gtk_widget_set_sensitive (apply, FALSE);
g_object_set_data (G_OBJECT (dlg), "blocked", NULL);
}
bool
item_type_match (SPItem *item, GtkWidget *widget)
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
if (SP_IS_RECT(item)) {
return (type_checkbox (widget, "shapes") || type_checkbox (widget, "rects"));
} else if (SP_IS_GENERICELLIPSE(item) || SP_IS_ELLIPSE(item) || SP_IS_ARC(item) || SP_IS_CIRCLE(item)) {
return (type_checkbox (widget, "shapes") || type_checkbox (widget, "ellipses"));
} else if (SP_IS_STAR(item) || SP_IS_POLYGON(item)) {
return (type_checkbox (widget, "shapes") || type_checkbox (widget, "stars"));
} else if (SP_IS_SPIRAL(item)) {
return (type_checkbox (widget, "shapes") || type_checkbox (widget, "spirals"));
} else if (SP_IS_PATH(item) || SP_IS_LINE(item) || SP_IS_POLYLINE(item)) {
return (type_checkbox (widget, "paths"));
} else if (SP_IS_TEXT(item) || SP_IS_TSPAN(item) || SP_IS_TREF(item) || SP_IS_STRING(item)) {
return (type_checkbox (widget, "texts"));
} else if (SP_IS_GROUP(item) && !desktop->isLayer(item) ) { // never select layers!
return (type_checkbox (widget, "groups"));
} else if (SP_IS_USE(item)) {
return (type_checkbox (widget, "clones"));
} else if (SP_IS_IMAGE(item)) {
return (type_checkbox (widget, "images"));
} else if (SP_IS_OFFSET(item)) {
return (type_checkbox (widget, "offsets"));
}
return false;
}
void
OriginalPathParam::linked_modified_callback(SPObject *linked_obj, guint /*flags*/)
{
SPCurve *curve = NULL;
if (SP_IS_SHAPE(linked_obj)) {
curve = SP_SHAPE(linked_obj)->getCurveBeforeLPE();
}
if (SP_IS_TEXT(linked_obj)) {
curve = SP_TEXT(linked_obj)->getNormalizedBpath();
}
if (curve == NULL) {
// curve invalid, set empty pathvector
_pathvector = Geom::PathVector();
} else {
_pathvector = curve->get_pathvector();
curve->unref();
}
must_recalculate_pwd2 = true;
emit_changed();
SP_OBJECT(param_effect->getLPEObj())->requestModified(SP_OBJECT_MODIFIED_FLAG);
}
/*
* Find all the fonts that are in the document but not available on the users system
* and have been substituted for other fonts
*
* Return a list of SPItems where fonts have been substituted.
*
* Walk thru all the objects ...
* a. Build up a list of the objects with fonts defined in the style attribute
* b. Build up a list of the objects rendered fonts - taken for the objects layout/spans
* If there are fonts in a. that are not in b. then those fonts have been substituted.
*/
GSList * FontSubstitution::getFontReplacedItems(SPDocument* doc, Glib::ustring *out)
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
GSList *allList = NULL;
GSList *outList = NULL;
std::set<Glib::ustring> setErrors;
std::set<Glib::ustring> setFontSpans;
std::map<SPItem *, Glib::ustring> mapFontStyles;
allList = get_all_items(NULL, doc->getRoot(), desktop, false, false, true, NULL);
for (GSList *i = allList; i != NULL; i = i->next) {
SPItem *item = SP_ITEM(i->data);
SPStyle *style = item->style;
Glib::ustring family = "";
if (is_top_level_text_object (item)) {
// Should only need to check the first span, since the others should be covered by TSPAN's etc
family = te_get_layout(item)->getFontFamily(0);
setFontSpans.insert(family);
}
else if (SP_IS_TEXTPATH(item)) {
SPTextPath const *textpath = SP_TEXTPATH(item);
if (textpath->originalPath != NULL) {
family = SP_TEXT(item->parent)->layout.getFontFamily(0);
setFontSpans.insert(family);
}
}
else if (SP_IS_TSPAN(item) || SP_IS_FLOWTSPAN(item)) {
// is_part_of_text_subtree (item)
// TSPAN layout comes from the parent->layout->_spans
SPObject *parent_text = item;
while (parent_text && !SP_IS_TEXT(parent_text)) {
parent_text = parent_text->parent;
}
if (parent_text != NULL) {
family = SP_TEXT(parent_text)->layout.getFontFamily(0);
// Add all the spans fonts to the set
gint ii = 0;
for (SPObject *child = parent_text->firstChild() ; child ; child = child->getNext() ) {
family = SP_TEXT(parent_text)->layout.getFontFamily(ii);
setFontSpans.insert(family);
ii++;
}
}
}
if (style) {
gchar const *style_font = NULL;
if (style->font_family.set)
style_font = style->font_family.value;
else if (style->font_specification.set)
style_font = style->font_specification.value;
else if (style->font_family.value)
style_font = style->font_family.value;
else if (style->font_specification.value)
style_font = style->font_specification.value;
if (style_font) {
if (has_visible_text(item)) {
mapFontStyles.insert(std::make_pair (item, style_font));
}
}
}
}
// Check if any document styles are not in the actual layout
std::map<SPItem *, Glib::ustring>::const_iterator mapIter;
for (mapIter = mapFontStyles.begin(); mapIter != mapFontStyles.end(); ++mapIter) {
SPItem *item = mapIter->first;
Glib::ustring fonts = mapIter->second;
// CSS font fallbacks can have more that one font listed, split the font list
std::vector<Glib::ustring> vFonts = Glib::Regex::split_simple("," , fonts);
bool fontFound = false;
for(size_t i=0; i<vFonts.size(); i++) {
Glib::ustring font = vFonts[i];
// trim whitespace
size_t startpos = font.find_first_not_of(" \n\r\t");
size_t endpos = font.find_last_not_of(" \n\r\t");
if(( std::string::npos == startpos ) || ( std::string::npos == endpos)) {
continue; // empty font name
}
font = font.substr( startpos, endpos-startpos+1 );
std::set<Glib::ustring>::const_iterator iter = setFontSpans.find(font);
if (iter != setFontSpans.end() ||
font == Glib::ustring("sans-serif") ||
font == Glib::ustring("Sans") ||
font == Glib::ustring("serif") ||
font == Glib::ustring("Serif") ||
font == Glib::ustring("monospace") ||
font == Glib::ustring("Monospace")) {
fontFound = true;
break;
}
}
if (fontFound == false) {
Glib::ustring subName = getSubstituteFontName(fonts);
Glib::ustring err = Glib::ustring::compose(
_("Font '%1' substituted with '%2'"), fonts.c_str(), subName.c_str());
setErrors.insert(err);
outList = g_slist_prepend (outList, item);
}
}
std::set<Glib::ustring>::const_iterator setIter;
for (setIter = setErrors.begin(); setIter != setErrors.end(); ++setIter) {
Glib::ustring err = (*setIter);
out->append(err + "\n");
g_warning("%s", err.c_str());
}
return outList;
}
Inkscape::XML::Node *
sp_selected_item_to_curved_repr(SPItem *item, guint32 /*text_grouping_policy*/)
{
if (!item)
return NULL;
Inkscape::XML::Document *xml_doc = SP_OBJECT_REPR(item)->document();
if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) {
// Special treatment for text: convert each glyph to separate path, then group the paths
Inkscape::XML::Node *g_repr = xml_doc->createElement("svg:g");
g_repr->setAttribute("transform", SP_OBJECT_REPR(item)->attribute("transform"));
/* Mask */
gchar *mask_str = (gchar *) SP_OBJECT_REPR(item)->attribute("mask");
if ( mask_str )
g_repr->setAttribute("mask", mask_str);
/* Clip path */
gchar *clip_path_str = (gchar *) SP_OBJECT_REPR(item)->attribute("clip-path");
if ( clip_path_str )
g_repr->setAttribute("clip-path", clip_path_str);
/* Rotation center */
g_repr->setAttribute("inkscape:transform-center-x", SP_OBJECT_REPR(item)->attribute("inkscape:transform-center-x"), false);
g_repr->setAttribute("inkscape:transform-center-y", SP_OBJECT_REPR(item)->attribute("inkscape:transform-center-y"), false);
/* Whole text's style */
gchar *style_str = sp_style_write_difference(SP_OBJECT_STYLE(item),
SP_OBJECT_STYLE(SP_OBJECT_PARENT(item)));
g_repr->setAttribute("style", style_str);
g_free(style_str);
Inkscape::Text::Layout::iterator iter = te_get_layout(item)->begin();
do {
Inkscape::Text::Layout::iterator iter_next = iter;
iter_next.nextGlyph(); // iter_next is one glyph ahead from iter
if (iter == iter_next)
break;
/* This glyph's style */
SPObject const *pos_obj = 0;
void *rawptr = 0;
te_get_layout(item)->getSourceOfCharacter(iter, &rawptr);
if (!rawptr || !SP_IS_OBJECT(rawptr)) // no source for glyph, abort
break;
pos_obj = SP_OBJECT(rawptr);
while (SP_IS_STRING(pos_obj) && SP_OBJECT_PARENT(pos_obj)) {
pos_obj = SP_OBJECT_PARENT(pos_obj); // SPStrings don't have style
}
gchar *style_str = sp_style_write_difference(SP_OBJECT_STYLE(pos_obj),
SP_OBJECT_STYLE(SP_OBJECT_PARENT(pos_obj)));
// get path from iter to iter_next:
SPCurve *curve = te_get_layout(item)->convertToCurves(iter, iter_next);
iter = iter_next; // shift to next glyph
if (!curve) { // error converting this glyph
g_free (style_str);
continue;
}
if (curve->is_empty()) { // whitespace glyph?
curve->unref();
g_free (style_str);
continue;
}
Inkscape::XML::Node *p_repr = xml_doc->createElement("svg:path");
gchar *def_str = sp_svg_write_path(curve->get_pathvector());
p_repr->setAttribute("d", def_str);
g_free(def_str);
curve->unref();
p_repr->setAttribute("style", style_str);
g_free(style_str);
g_repr->appendChild(p_repr);
Inkscape::GC::release(p_repr);
if (iter == te_get_layout(item)->end())
break;
} while (true);
return g_repr;
}
SPCurve *curve = NULL;
if (SP_IS_SHAPE(item)) {
curve = sp_shape_get_curve(SP_SHAPE(item));
}
if (!curve)
return NULL;
// Prevent empty paths from being added to the document
// otherwise we end up with zomby markup in the SVG file
if(curve->is_empty())
{
curve->unref();
return NULL;
}
Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
/* Transformation */
repr->setAttribute("transform", SP_OBJECT_REPR(item)->attribute("transform"));
/* Style */
gchar *style_str = sp_style_write_difference(SP_OBJECT_STYLE(item),
SP_OBJECT_STYLE(SP_OBJECT_PARENT(item)));
repr->setAttribute("style", style_str);
g_free(style_str);
/* Mask */
gchar *mask_str = (gchar *) SP_OBJECT_REPR(item)->attribute("mask");
if ( mask_str )
repr->setAttribute("mask", mask_str);
/* Clip path */
gchar *clip_path_str = (gchar *) SP_OBJECT_REPR(item)->attribute("clip-path");
if ( clip_path_str )
repr->setAttribute("clip-path", clip_path_str);
/* Rotation center */
repr->setAttribute("inkscape:transform-center-x", SP_OBJECT_REPR(item)->attribute("inkscape:transform-center-x"), false);
repr->setAttribute("inkscape:transform-center-y", SP_OBJECT_REPR(item)->attribute("inkscape:transform-center-y"), false);
/* Definition */
gchar *def_str = sp_svg_write_path(curve->get_pathvector());
repr->setAttribute("d", def_str);
g_free(def_str);
curve->unref();
return repr;
}
/// @todo investigate why Geom::Point p is passed in but ignored.
void Inkscape::ObjectSnapper::_collectPaths(Geom::Point /*p*/,
SnapSourceType const source_type,
bool const &first_point) const
{
// Now, let's first collect all paths to snap to. If we have a whole bunch of points to snap,
// e.g. when translating an item using the selector tool, then we will only do this for the
// first point and store the collection for later use. This significantly improves the performance
if (first_point) {
_clear_paths();
// Determine the type of bounding box we should snap to
SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX;
bool p_is_a_node = source_type & SNAPSOURCE_NODE_CATEGORY;
bool p_is_a_bbox = source_type & SNAPSOURCE_BBOX_CATEGORY;
bool p_is_other = (source_type & SNAPSOURCE_OTHERS_CATEGORY) || (source_type & SNAPSOURCE_DATUMS_CATEGORY);
if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_EDGE)) {
Preferences *prefs = Preferences::get();
int prefs_bbox = prefs->getBool("/tools/bounding_box", 0);
bbox_type = !prefs_bbox ?
SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX;
}
// Consider the page border for snapping
if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PAGE_BORDER) && _snapmanager->snapprefs.isAnyCategorySnappable()) {
Geom::PathVector *border_path = _getBorderPathv();
if (border_path != NULL) {
_paths_to_snap_to->push_back(SnapCandidatePath(border_path, SNAPTARGET_PAGE_BORDER, Geom::OptRect()));
}
}
for (std::vector<SnapCandidateItem>::const_iterator i = _candidates->begin(); i != _candidates->end(); ++i) {
/* Transform the requested snap point to this item's coordinates */
Geom::Affine i2doc(Geom::identity());
SPItem *root_item = NULL;
/* We might have a clone at hand, so make sure we get the root item */
if (SP_IS_USE((*i).item)) {
i2doc = SP_USE((*i).item)->get_root_transform();
root_item = SP_USE((*i).item)->root();
g_return_if_fail(root_item);
} else {
i2doc = (*i).item->i2doc_affine();
root_item = (*i).item;
}
//Build a list of all paths considered for snapping to
//Add the item's path to snap to
if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION, SNAPTARGET_TEXT_BASELINE)) {
if (p_is_other || p_is_a_node || (!_snapmanager->snapprefs.getStrictSnapping() && p_is_a_bbox)) {
if (SP_IS_TEXT(root_item) || SP_IS_FLOWTEXT(root_item)) {
if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_TEXT_BASELINE)) {
// Snap to the text baseline
Text::Layout const *layout = te_get_layout(static_cast<SPItem *>(root_item));
if (layout != NULL && layout->outputExists()) {
Geom::PathVector *pv = new Geom::PathVector();
pv->push_back(layout->baseline() * root_item->i2dt_affine() * (*i).additional_affine * _snapmanager->getDesktop()->doc2dt());
_paths_to_snap_to->push_back(SnapCandidatePath(pv, SNAPTARGET_TEXT_BASELINE, Geom::OptRect()));
}
}
} else {
// Snapping for example to a traced bitmap is very stressing for
// the CPU, so we'll only snap to paths having no more than 500 nodes
// This also leads to a lag of approx. 500 msec (in my lousy test set-up).
bool very_complex_path = false;
if (SP_IS_PATH(root_item)) {
very_complex_path = SP_PATH(root_item)->nodesInPath() > 500;
}
if (!very_complex_path && root_item && _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION)) {
SPCurve *curve = NULL;
if (SP_IS_SHAPE(root_item)) {
curve = SP_SHAPE(root_item)->getCurve();
}/* else if (SP_IS_TEXT(root_item) || SP_IS_FLOWTEXT(root_item)) {
curve = te_get_layout(root_item)->convertToCurves();
}*/
if (curve) {
// We will get our own copy of the pathvector, which must be freed at some point
// Geom::PathVector *pv = pathvector_for_curve(root_item, curve, true, true, Geom::identity(), (*i).additional_affine);
Geom::PathVector *pv = new Geom::PathVector(curve->get_pathvector());
(*pv) *= root_item->i2dt_affine() * (*i).additional_affine * _snapmanager->getDesktop()->doc2dt(); // (_edit_transform * _i2d_transform);
_paths_to_snap_to->push_back(SnapCandidatePath(pv, SNAPTARGET_PATH, Geom::OptRect())); // Perhaps for speed, get a reference to the Geom::pathvector, and store the transformation besides it.
curve->unref();
}
}
}
}
}
//Add the item's bounding box to snap to
if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_EDGE)) {
if (p_is_other || p_is_a_bbox || (!_snapmanager->snapprefs.getStrictSnapping() && p_is_a_node)) {
// Discard the bbox of a clipped path / mask, because we don't want to snap to both the bbox
// of the item AND the bbox of the clipping path at the same time
if (!(*i).clip_or_mask) {
Geom::OptRect rect = root_item->bounds(bbox_type, i2doc);
if (rect) {
Geom::PathVector *path = _getPathvFromRect(*rect);
rect = root_item->desktopBounds(bbox_type);
_paths_to_snap_to->push_back(SnapCandidatePath(path, SNAPTARGET_BBOX_EDGE, rect));
}
}
}
}
}
}
}
void
text_flow_into_shape()
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
if (!desktop)
return;
SPDocument *doc = sp_desktop_document (desktop);
Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
Inkscape::Selection *selection = sp_desktop_selection(desktop);
SPItem *text = text_or_flowtext_in_selection(selection);
SPItem *shape = shape_in_selection(selection);
if (!text || !shape || g_slist_length((GSList *) selection->itemList()) < 2) {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>a text</b> and one or more <b>paths or shapes</b> to flow text into frame."));
return;
}
if (SP_IS_TEXT(text)) {
// 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);
}
Inkscape::XML::Node *root_repr = xml_doc->createElement("svg:flowRoot");
root_repr->setAttribute("xml:space", "preserve"); // we preserve spaces in the text objects we create
root_repr->setAttribute("style", SP_OBJECT_REPR(text)->attribute("style")); // fixme: transfer style attrs too
SP_OBJECT_REPR(SP_OBJECT_PARENT(shape))->appendChild(root_repr);
SPObject *root_object = doc->getObjectByRepr(root_repr);
g_return_if_fail(SP_IS_FLOWTEXT(root_object));
Inkscape::XML::Node *region_repr = xml_doc->createElement("svg:flowRegion");
root_repr->appendChild(region_repr);
SPObject *object = doc->getObjectByRepr(region_repr);
g_return_if_fail(SP_IS_FLOWREGION(object));
/* Add clones */
for (GSList *items = (GSList *) selection->itemList();
items != NULL;
items = items->next) {
SPItem *item = SP_ITEM(items->data);
if (SP_IS_SHAPE(item)){
Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
clone->setAttribute("x", "0");
clone->setAttribute("y", "0");
clone->setAttribute("xlink:href", g_strdup_printf("#%s", SP_OBJECT_REPR(item)->attribute("id")));
// add the new clone to the region
region_repr->appendChild(clone);
}
}
if (SP_IS_TEXT(text)) { // flow from text, as string
Inkscape::XML::Node *para_repr = xml_doc->createElement("svg:flowPara");
root_repr->appendChild(para_repr);
object = doc->getObjectByRepr(para_repr);
g_return_if_fail(SP_IS_FLOWPARA(object));
Inkscape::Text::Layout const *layout = te_get_layout(text);
Glib::ustring text_ustring = sp_te_get_string_multiline(text, layout->begin(), layout->end());
Inkscape::XML::Node *text_repr = xml_doc->createTextNode(text_ustring.c_str()); // FIXME: transfer all formatting! and convert newlines into flowParas!
para_repr->appendChild(text_repr);
Inkscape::GC::release(para_repr);
Inkscape::GC::release(text_repr);
} else { // reflow an already flowed text, preserving paras
for (SPObject *o = SP_OBJECT(text)->children; o != NULL; o = o->next) {
if (SP_IS_FLOWPARA(o)) {
Inkscape::XML::Node *para_repr = SP_OBJECT_REPR(o)->duplicate(xml_doc);
root_repr->appendChild(para_repr);
object = doc->getObjectByRepr(para_repr);
g_return_if_fail(SP_IS_FLOWPARA(object));
Inkscape::GC::release(para_repr);
}
}
}
SP_OBJECT(text)->deleteObject (true);
sp_document_done(doc, SP_VERB_CONTEXT_TEXT,
_("Flow text into shape"));
sp_desktop_selection(desktop)->set(SP_ITEM(root_object));
Inkscape::GC::release(root_repr);
Inkscape::GC::release(region_repr);
}