summaryrefslogtreecommitdiffstats
path: root/src/text-editing.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/text-editing.cpp2186
1 files changed, 2186 insertions, 0 deletions
diff --git a/src/text-editing.cpp b/src/text-editing.cpp
new file mode 100644
index 0000000..2050584
--- /dev/null
+++ b/src/text-editing.cpp
@@ -0,0 +1,2186 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Parent class for text and flowtext
+ *
+ * Authors:
+ * bulia byak
+ * Richard Hughes
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
+ *
+ * Copyright (C) 2004-5 authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+#endif
+
+#include <cstring>
+#include <string>
+#include <glibmm/i18n.h>
+
+#include "desktop.h"
+#include "document.h"
+#include "inkscape.h"
+#include "message-stack.h"
+#include "text-editing.h"
+
+#include "object/sp-textpath.h"
+#include "object/sp-flowtext.h"
+#include "object/sp-flowdiv.h"
+#include "object/sp-flowregion.h"
+#include "object/sp-item-group.h"
+#include "object/sp-tref.h"
+#include "object/sp-tspan.h"
+#include "style.h"
+
+#include "util/units.h"
+
+#include "xml/attribute-record.h"
+#include "xml/sp-css-attr.h"
+
+static const gchar *tref_edit_message = _("You cannot edit <b>cloned character data</b>.");
+static void move_child_nodes(Inkscape::XML::Node *from_repr, Inkscape::XML::Node *to_repr, bool prepend = false);
+
+static bool tidy_xml_tree_recursively(SPObject *root, bool has_text_decoration);
+
+Inkscape::Text::Layout const * te_get_layout (SPItem const *item)
+{
+ if (SP_IS_TEXT(item)) {
+ return &(SP_TEXT(item)->layout);
+ } else if (SP_IS_FLOWTEXT (item)) {
+ return &(SP_FLOWTEXT(item)->layout);
+ }
+ return nullptr;
+}
+
+static void te_update_layout_now (SPItem *item)
+{
+ if (SP_IS_TEXT(item))
+ SP_TEXT(item)->rebuildLayout();
+ else if (SP_IS_FLOWTEXT (item))
+ SP_FLOWTEXT(item)->rebuildLayout();
+ item->updateRepr();
+}
+
+void te_update_layout_now_recursive(SPItem *item)
+{
+ if (SP_IS_GROUP(item)) {
+ std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(item));
+ for(auto list_item : item_list){
+ te_update_layout_now_recursive(list_item);
+ }
+ } else if (SP_IS_TEXT(item))
+ SP_TEXT(item)->rebuildLayout();
+ else if (SP_IS_FLOWTEXT (item))
+ SP_FLOWTEXT(item)->rebuildLayout();
+ item->updateRepr();
+}
+
+bool sp_te_output_is_empty(SPItem const *item)
+{
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+ return layout->begin() == layout->end();
+}
+
+bool sp_te_input_is_empty(SPObject const *item)
+{
+ bool empty = true;
+ if (SP_IS_STRING(item)) {
+ empty = SP_STRING(item)->string.empty();
+ } else {
+ for (auto& child: item->children) {
+ if (!sp_te_input_is_empty(&child)) {
+ empty = false;
+ break;
+ }
+ }
+ }
+ return empty;
+}
+
+Inkscape::Text::Layout::iterator
+sp_te_get_position_by_coords (SPItem const *item, Geom::Point const &i_p)
+{
+ Geom::Affine im (item->i2dt_affine ());
+ im = im.inverse();
+
+ Geom::Point p = i_p * im;
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+ return layout->getNearestCursorPositionTo(p);
+}
+
+std::vector<Geom::Point> sp_te_create_selection_quads(SPItem const *item, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, Geom::Affine const &transform)
+{
+ if (start == end)
+ return std::vector<Geom::Point>();
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+ if (layout == nullptr)
+ return std::vector<Geom::Point>();
+
+ return layout->createSelectionShape(start, end, transform);
+}
+
+void
+sp_te_get_cursor_coords (SPItem const *item, Inkscape::Text::Layout::iterator const &position, Geom::Point &p0, Geom::Point &p1)
+{
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+ double height, rotation;
+ layout->queryCursorShape(position, p0, height, rotation);
+ p1 = Geom::Point(p0[Geom::X] + height * sin(rotation), p0[Geom::Y] - height * cos(rotation)); // valgrind warns that rotation is not initialized here. Why is to be seen in queryCursorShape
+}
+
+SPStyle const * sp_te_style_at_position(SPItem const *text, Inkscape::Text::Layout::iterator const &position)
+{
+ SPObject const *pos_obj = sp_te_object_at_position(text, position);
+ SPStyle *result = (pos_obj) ? pos_obj->style : nullptr;
+ return result;
+}
+
+SPObject const * sp_te_object_at_position(SPItem const *text, Inkscape::Text::Layout::iterator const &position)
+{
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+ if (layout == nullptr) {
+ return nullptr;
+ }
+ SPObject *rawptr = nullptr;
+ layout->getSourceOfCharacter(position, &rawptr);
+ SPObject const *pos_obj = rawptr;
+ if (pos_obj == nullptr) {
+ pos_obj = text;
+ }
+ while (pos_obj->style == nullptr) {
+ pos_obj = pos_obj->parent; // not interested in SPStrings
+ }
+ return pos_obj;
+}
+
+/*
+ * for debugging input
+ *
+char * dump_hexy(const gchar * utf8)
+{
+ static char buffer[1024];
+
+ buffer[0]='\0';
+ for (const char *ptr=utf8; *ptr; ptr++) {
+ sprintf(buffer+strlen(buffer),"x%02X",(unsigned char)*ptr);
+ }
+ return buffer;
+}
+*/
+
+Inkscape::Text::Layout::iterator sp_te_replace(SPItem *item, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, gchar const *utf8)
+{
+ iterator_pair pair;
+ sp_te_delete(item, start, end, pair);
+ return sp_te_insert(item, pair.first, utf8);
+}
+
+
+/* ***************************************************************************************************/
+// I N S E R T I N G T E X T
+
+static bool is_line_break_object(SPObject const *object)
+{
+ bool is_line_break = false;
+
+ if (object) {
+ if (SP_IS_TEXT(object)
+ || (SP_IS_TSPAN(object) && SP_TSPAN(object)->role != SP_TSPAN_ROLE_UNSPECIFIED)
+ || SP_IS_TEXTPATH(object)
+ || SP_IS_FLOWDIV(object)
+ || SP_IS_FLOWPARA(object)
+ || SP_IS_FLOWLINE(object)
+ || SP_IS_FLOWREGIONBREAK(object)) {
+
+ is_line_break = true;
+ }
+ }
+
+ return is_line_break;
+}
+
+/** returns the attributes for an object, or NULL if it isn't a text,
+tspan, tref, or textpath. */
+static TextTagAttributes* attributes_for_object(SPObject *object)
+{
+ if (SP_IS_TSPAN(object))
+ return &SP_TSPAN(object)->attributes;
+ if (SP_IS_TEXT(object))
+ return &SP_TEXT(object)->attributes;
+ if (SP_IS_TREF(object))
+ return &SP_TREF(object)->attributes;
+ if (SP_IS_TEXTPATH(object))
+ return &SP_TEXTPATH(object)->attributes;
+ return nullptr;
+}
+
+static const char * span_name_for_text_object(SPObject const *object)
+{
+ if (SP_IS_TEXT(object)) return "svg:tspan";
+ else if (SP_IS_FLOWTEXT(object)) return "svg:flowSpan";
+ return nullptr;
+}
+
+unsigned sp_text_get_length(SPObject const *item)
+{
+ unsigned length = 0;
+
+ if (SP_IS_STRING(item)) {
+ length = SP_STRING(item)->string.length();
+ } else {
+ if (is_line_break_object(item)) {
+ length++;
+ }
+
+ for (auto& child: item->children) {
+ if (SP_IS_STRING(&child)) {
+ length += SP_STRING(&child)->string.length();
+ } else {
+ length += sp_text_get_length(&child);
+ }
+ }
+ }
+
+ return length;
+}
+
+unsigned sp_text_get_length_upto(SPObject const *item, SPObject const *upto)
+{
+ unsigned length = 0;
+
+ // The string is the lowest level and the length can be counted directly.
+ if (SP_IS_STRING(item)) {
+ return SP_STRING(item)->string.length();
+ }
+
+ // Take care of new lines...
+ if (is_line_break_object(item) && !SP_IS_TEXT(item)) {
+ if (item != item->parent->firstChild()) {
+ // add 1 for each newline
+ length++;
+ }
+ }
+
+ // Count the length of the children
+ for (auto& child: item->children) {
+ if (upto && &child == upto) {
+ // hit upto, return immediately
+ return length;
+ }
+ if (SP_IS_STRING(&child)) {
+ length += SP_STRING(&child)->string.length();
+ }
+ else {
+ if (upto && child.isAncestorOf(upto)) {
+ // upto is below us, recurse and break loop
+ length += sp_text_get_length_upto(&child, upto);
+ return length;
+ } else {
+ // recurse and go to the next sibling
+ length += sp_text_get_length_upto(&child, upto);
+ }
+ }
+ }
+ return length;
+}
+
+static Inkscape::XML::Node* duplicate_node_without_children(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node const *old_node)
+{
+ switch (old_node->type()) {
+ case Inkscape::XML::NodeType::ELEMENT_NODE: {
+ Inkscape::XML::Node *new_node = xml_doc->createElement(old_node->name());
+ GQuark const id_key = g_quark_from_string("id");
+ for ( const auto & attr: old_node->attributeList() ) {
+ if (attr.key == id_key) continue;
+ new_node->setAttribute(g_quark_to_string(attr.key), attr.value);
+ }
+ return new_node;
+ }
+
+ case Inkscape::XML::NodeType::TEXT_NODE:
+ return xml_doc->createTextNode(old_node->content());
+
+ case Inkscape::XML::NodeType::COMMENT_NODE:
+ return xml_doc->createComment(old_node->content());
+
+ case Inkscape::XML::NodeType::PI_NODE:
+ return xml_doc->createPI(old_node->name(), old_node->content());
+
+ case Inkscape::XML::NodeType::DOCUMENT_NODE:
+ return nullptr; // this had better never happen
+ }
+ return nullptr;
+}
+
+/** returns the sum of the (recursive) lengths of all the SPStrings prior
+to \a item at the same level. */
+static unsigned sum_sibling_text_lengths_before(SPObject const *item)
+{
+ unsigned char_index = 0;
+ for (auto& sibling: item->parent->children) {
+ if (&sibling == item) {
+ break;
+ }
+ char_index += sp_text_get_length(&sibling);
+ }
+ return char_index;
+}
+
+/** splits the attributes for the first object at the given \a char_index
+and moves the ones after that point into \a second_item. */
+static void split_attributes(SPObject *first_item, SPObject *second_item, unsigned char_index)
+{
+ TextTagAttributes *first_attrs = attributes_for_object(first_item);
+ TextTagAttributes *second_attrs = attributes_for_object(second_item);
+ if (first_attrs && second_attrs)
+ first_attrs->split(char_index, second_attrs);
+}
+
+/** recursively divides the XML node tree into two objects: the original will
+contain all objects up to and including \a split_obj and the returned value
+will be the new leaf which represents the copy of \a split_obj and extends
+down the tree with new elements all the way to the common root which is the
+parent of the first line break node encountered.
+*/
+static SPObject* split_text_object_tree_at(SPObject *split_obj, unsigned char_index)
+{
+ Inkscape::XML::Document *xml_doc = split_obj->document->getReprDoc();
+ if (is_line_break_object(split_obj)) {
+ Inkscape::XML::Node *new_node = duplicate_node_without_children(xml_doc, split_obj->getRepr());
+ split_obj->parent->getRepr()->addChild(new_node, split_obj->getRepr());
+ Inkscape::GC::release(new_node);
+ split_attributes(split_obj, split_obj->getNext(), char_index);
+ return split_obj->getNext();
+ } else if (!SP_IS_TSPAN(split_obj) &&
+ !SP_IS_FLOWTSPAN(split_obj) &&
+ !SP_IS_STRING(split_obj)) {
+ std::cerr << "split_text_object_tree_at: Illegal split object type! (Illegal document structure.)" << std::endl;
+ return nullptr;
+ }
+
+ unsigned char_count_before = sum_sibling_text_lengths_before(split_obj);
+ SPObject *duplicate_obj = split_text_object_tree_at(split_obj->parent, char_index + char_count_before);
+
+ if (duplicate_obj == nullptr) {
+ // Illegal document structure (no line break object).
+ return nullptr;
+ }
+
+ // copy the split node
+ Inkscape::XML::Node *new_node = duplicate_node_without_children(xml_doc, split_obj->getRepr());
+ duplicate_obj->getRepr()->appendChild(new_node);
+ Inkscape::GC::release(new_node);
+
+ // sort out the copied attributes (x/y/dx/dy/rotate)
+ split_attributes(split_obj, duplicate_obj->firstChild(), char_index);
+
+ // then move all the subsequent nodes
+ split_obj = split_obj->getNext();
+ while (split_obj) {
+ Inkscape::XML::Node *move_repr = split_obj->getRepr();
+ SPObject *next_obj = split_obj->getNext(); // this is about to become invalidated by removeChild()
+ Inkscape::GC::anchor(move_repr);
+ split_obj->parent->getRepr()->removeChild(move_repr);
+ duplicate_obj->getRepr()->appendChild(move_repr);
+ Inkscape::GC::release(move_repr);
+
+ split_obj = next_obj;
+ }
+ return duplicate_obj->firstChild();
+}
+
+/** inserts a new line break at the given position in a text or flowtext
+object. If the position is in the middle of a span, the XML tree must be
+chopped in two such that the line can be created at the root of the text
+element. Returns an iterator pointing just after the inserted break. */
+Inkscape::Text::Layout::iterator sp_te_insert_line (SPItem *item, Inkscape::Text::Layout::iterator &position)
+{
+ // Disable newlines in a textpath; TODO: maybe on Enter in a textpath, separate it into two
+ // texpaths attached to the same path, with a vertical shift
+ if (SP_IS_TEXT_TEXTPATH (item) || SP_IS_TREF(item))
+ return position;
+
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+
+ // If this is plain SVG 1.1 text object without a tspan with sodipodi:role="line", we need
+ // to wrap it or our custom line breaking code won't work!
+ bool need_to_wrap = false;
+ SPText* text_object = dynamic_cast<SPText *>(item);
+ if (text_object && !text_object->has_shape_inside() && !text_object->has_inline_size()) {
+
+ need_to_wrap = true;
+ for (auto child : item->childList(false)) {
+ auto tspan = dynamic_cast<SPTSpan *>(child);
+ if (tspan && tspan->role == SP_TSPAN_ROLE_LINE) {
+ // Already wrapped
+ need_to_wrap = false;
+ break;
+ }
+ }
+
+ if (need_to_wrap) {
+
+ // We'll need to rebuild layout, so store character position:
+ int char_index = layout->iteratorToCharIndex(position);
+
+ // Create wrapping tspan.
+ Inkscape::XML::Node *text_repr = text_object->getRepr();
+ Inkscape::XML::Document *xml_doc = text_repr->document();
+ Inkscape::XML::Node *new_tspan_repr = xml_doc->createElement("svg:tspan");
+ new_tspan_repr->setAttribute("sodipodi:role", "line");
+
+ // Move text content to tspan and add tspan to text object.
+ // To do: This moves <desc> and <title> too.
+ move_child_nodes(text_repr, new_tspan_repr);
+ text_repr->appendChild(new_tspan_repr);
+
+ // Need to find new iterator.
+ text_object->rebuildLayout();
+ position = layout->charIndexToIterator(char_index);
+ }
+ }
+
+ SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+ SPObject *split_obj = nullptr;
+ Glib::ustring::iterator split_text_iter;
+ if (position != layout->end()) {
+ layout->getSourceOfCharacter(position, &split_obj, &split_text_iter);
+ }
+
+ if (split_obj == nullptr || is_line_break_object(split_obj)) {
+
+ if (split_obj == nullptr) split_obj = item->lastChild();
+
+ if (SP_IS_TREF(split_obj)) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, tref_edit_message);
+ return position;
+ }
+
+ if (split_obj) {
+ Inkscape::XML::Document *xml_doc = split_obj->document->getReprDoc();
+ Inkscape::XML::Node *new_node = duplicate_node_without_children(xml_doc, split_obj->getRepr());
+ // if we finally go to a text element without TSpan we mist set content to none
+ // new_node->setContent("");
+ split_obj->parent->getRepr()->addChild(new_node, split_obj->getRepr());
+ Inkscape::GC::release(new_node);
+ }
+
+ } else if (SP_IS_STRING(split_obj)) {
+
+ // If the parent is a tref, editing on this particular string is disallowed.
+ if (SP_IS_TREF(split_obj->parent)) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, tref_edit_message);
+ return position;
+ }
+
+ Glib::ustring *string = &SP_STRING(split_obj)->string;
+ unsigned char_index = 0;
+ for (Glib::ustring::iterator it = string->begin() ; it != split_text_iter ; ++it)
+ char_index++;
+ // we need to split the entire text tree into two
+
+ SPObject *object = split_text_object_tree_at(split_obj, char_index);
+ if (object == nullptr) {
+ // Illegal document structure
+ return position;
+ }
+
+ SPString *new_string = SP_STRING(object);
+ new_string->getRepr()->setContent(&*split_text_iter.base()); // a little ugly
+ string->erase(split_text_iter, string->end());
+ split_obj->getRepr()->setContent(string->c_str());
+ // TODO: if the split point was at the beginning of a span we have a whole load of empty elements to clean up
+ } else {
+ // TODO
+ // I think the only case to put here is arbitrary gaps, which nobody uses yet
+ }
+
+ unsigned char_index = layout->iteratorToCharIndex(position);
+ te_update_layout_now(item);
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+ return layout->charIndexToIterator(char_index + 1);
+}
+
+/** finds the first SPString after the given position, including children, excluding parents */
+static SPString* sp_te_seek_next_string_recursive(SPObject *start_obj)
+{
+ while (start_obj) {
+ if (start_obj->hasChildren()) {
+ SPString *found_string = sp_te_seek_next_string_recursive(start_obj->firstChild());
+ if (found_string) {
+ return found_string;
+ }
+ }
+ if (SP_IS_STRING(start_obj)) {
+ return SP_STRING(start_obj);
+ }
+ start_obj = start_obj->getNext();
+ if (is_line_break_object(start_obj)) {
+ break; // don't cross line breaks
+ }
+ }
+ return nullptr;
+}
+
+/** inserts the given characters into the given string and inserts
+corresponding new x/y/dx/dy/rotate attributes into all its parents. */
+static void insert_into_spstring(SPString *string_item, Glib::ustring::iterator iter_at, gchar const *utf8)
+{
+ unsigned char_index = 0;
+ unsigned char_count = g_utf8_strlen(utf8, -1);
+ Glib::ustring *string = &string_item->string;
+
+ for (Glib::ustring::iterator it = string->begin() ; it != iter_at ; ++it)
+ char_index++;
+ string->replace(iter_at, iter_at, utf8);
+
+ SPObject *parent_item = string_item;
+ for ( ; ; ) {
+ char_index += sum_sibling_text_lengths_before(parent_item);
+ parent_item = parent_item->parent;
+ TextTagAttributes *attributes = attributes_for_object(parent_item);
+ if (!attributes) break;
+ attributes->insert(char_index, char_count);
+ }
+}
+
+/** Inserts the given text into a text or flowroot object. Line breaks
+cannot be inserted using this function, see sp_te_insert_line(). Returns
+an iterator pointing just after the inserted text. */
+Inkscape::Text::Layout::iterator
+sp_te_insert(SPItem *item, Inkscape::Text::Layout::iterator const &position, gchar const *utf8)
+{
+ if (!g_utf8_validate(utf8,-1,nullptr)) {
+ g_warning("Trying to insert invalid utf8");
+ return position;
+ }
+
+ SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+ Glib::ustring::iterator iter_text;
+ // we want to insert after the previous char, not before the current char.
+ // it makes a difference at span boundaries
+ Inkscape::Text::Layout::iterator it_prev_char = position;
+ bool cursor_at_start = !it_prev_char.prevCharacter();
+ bool cursor_at_end = position == layout->end();
+ SPObject *source_obj = nullptr;
+ layout->getSourceOfCharacter(it_prev_char, &source_obj, &iter_text);
+ if (SP_IS_STRING(source_obj)) {
+ // If the parent is a tref, editing on this particular string is disallowed.
+ if (SP_IS_TREF(source_obj->parent)) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, tref_edit_message);
+ return position;
+ }
+
+ // Now the simple case can begin...
+ if (!cursor_at_start){
+ ++iter_text;
+ }
+ SPString *string_item = SP_STRING(source_obj);
+ insert_into_spstring(string_item, cursor_at_end ? string_item->string.end() : iter_text, utf8);
+ } else {
+ // the not-so-simple case where we're at a line break or other control char; add to the next child/sibling SPString
+ Inkscape::XML::Document *xml_doc = item->getRepr()->document();
+ if (cursor_at_start) {
+ source_obj = item;
+ if (source_obj->hasChildren()) {
+ source_obj = source_obj->firstChild();
+ if (SP_IS_FLOWTEXT(item)) {
+ while (SP_IS_FLOWREGION(source_obj) || SP_IS_FLOWREGIONEXCLUDE(source_obj)) {
+ source_obj = source_obj->getNext();
+ }
+ if (source_obj == nullptr) {
+ source_obj = item;
+ }
+ }
+ }
+ if (source_obj == item && SP_IS_FLOWTEXT(item)) {
+ Inkscape::XML::Node *para = xml_doc->createElement("svg:flowPara");
+ item->getRepr()->appendChild(para);
+ source_obj = item->lastChild();
+ }
+ } else
+ source_obj = source_obj->getNext();
+
+ if (source_obj) { // never fails
+ SPString *string_item = sp_te_seek_next_string_recursive(source_obj);
+ if (string_item == nullptr) {
+ // need to add an SPString in this (pathological) case
+ Inkscape::XML::Node *rstring = xml_doc->createTextNode("");
+ source_obj->getRepr()->addChild(rstring, nullptr);
+ Inkscape::GC::release(rstring);
+ g_assert(SP_IS_STRING(source_obj->firstChild()));
+ string_item = SP_STRING(source_obj->firstChild());
+ }
+ // If the parent is a tref, editing on this particular string is disallowed.
+ if (SP_IS_TREF(string_item->parent)) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, tref_edit_message);
+ return position;
+ }
+
+ insert_into_spstring(string_item, cursor_at_end ? string_item->string.end() : string_item->string.begin(), utf8);
+ }
+ }
+
+ unsigned char_index = layout->iteratorToCharIndex(position);
+ te_update_layout_now(item);
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+ return layout->charIndexToIterator(char_index + g_utf8_strlen(utf8, -1));
+}
+
+
+/* ***************************************************************************************************/
+// D E L E T I N G T E X T
+
+/** moves all the children of \a from_repr to \a to_repr, either before
+the existing children or after them. Order is maintained. The empty
+\a from_repr is not deleted. */
+static void move_child_nodes(Inkscape::XML::Node *from_repr, Inkscape::XML::Node *to_repr, bool prepend)
+{
+ while (from_repr->childCount()) {
+ Inkscape::XML::Node *child = prepend ? from_repr->lastChild() : from_repr->firstChild();
+ Inkscape::GC::anchor(child);
+ from_repr->removeChild(child);
+ if (prepend) to_repr->addChild(child, nullptr);
+ else to_repr->appendChild(child);
+ Inkscape::GC::release(child);
+ }
+}
+
+/** returns the object in the tree which is the closest ancestor of both
+\a one and \a two. It will never return anything higher than \a text. */
+static SPObject* get_common_ancestor(SPObject *text, SPObject *one, SPObject *two)
+{
+ if (one == nullptr || two == nullptr)
+ return text;
+ SPObject *common_ancestor = one;
+ if (SP_IS_STRING(common_ancestor))
+ common_ancestor = common_ancestor->parent;
+ while (!(common_ancestor == two || common_ancestor->isAncestorOf(two))) {
+ g_assert(common_ancestor != text);
+ common_ancestor = common_ancestor->parent;
+ }
+ return common_ancestor;
+}
+
+/** positions \a para_obj and \a text_iter to be pointing at the end
+of the last string in the last leaf object of \a para_obj. If the last
+leaf is not an SPString then \a text_iter will be unchanged. */
+static void move_to_end_of_paragraph(SPObject **para_obj, Glib::ustring::iterator *text_iter)
+{
+ while ((*para_obj)->hasChildren())
+ *para_obj = (*para_obj)->lastChild();
+ if (SP_IS_STRING(*para_obj))
+ *text_iter = SP_STRING(*para_obj)->string.end();
+}
+
+/** delete the line break pointed to by \a item by merging its children into
+the next suitable object and deleting \a item. Returns the object after the
+ones that have just been moved and sets \a next_is_sibling accordingly. */
+static SPObject* delete_line_break(SPObject *root, SPObject *item, bool *next_is_sibling)
+{
+ Inkscape::XML::Node *this_repr = item->getRepr();
+ SPObject *next_item = nullptr;
+ unsigned moved_char_count = sp_text_get_length(item) - 1; // the -1 is because it's going to count the line break
+
+ /* some sample cases (the div is the item to be deleted, the * represents where to put the new span):
+ <div></div><p>*text</p>
+ <p><div></div>*text</p>
+ <p><div></div></p><p>*text</p>
+ */
+ Inkscape::XML::Document *xml_doc = item->getRepr()->document();
+ Inkscape::XML::Node *new_span_repr = xml_doc->createElement(span_name_for_text_object(root));
+
+ new_span_repr->setAttributeOrRemoveIfEmpty("dx", this_repr->attribute("dx"));
+ new_span_repr->setAttributeOrRemoveIfEmpty("dy", this_repr->attribute("dy"));
+ new_span_repr->setAttributeOrRemoveIfEmpty("rotate", this_repr->attribute("rotate"));
+
+ SPObject *following_item = item;
+ while (following_item->getNext() == nullptr) {
+ following_item = following_item->parent;
+ g_assert(following_item != root);
+ }
+ following_item = following_item->getNext();
+
+ SPObject *new_parent_item;
+ if (SP_IS_STRING(following_item)) {
+ new_parent_item = following_item->parent;
+ new_parent_item->getRepr()->addChild(new_span_repr, following_item->getPrev() ? following_item->getPrev()->getRepr() : nullptr);
+ next_item = following_item;
+ *next_is_sibling = true;
+ } else {
+ new_parent_item = following_item;
+ next_item = new_parent_item->firstChild();
+ *next_is_sibling = true;
+ if (next_item == nullptr) {
+ next_item = new_parent_item;
+ *next_is_sibling = false;
+ }
+ new_parent_item->getRepr()->addChild(new_span_repr, nullptr);
+ }
+
+ // work around a bug in sp_style_write_difference() which causes the difference
+ // not to be written if the second param has a style set which the first does not
+ // by causing the first param to have everything set
+ SPCSSAttr *dest_node_attrs = sp_repr_css_attr(new_parent_item->getRepr(), "style");
+ SPCSSAttr *this_node_attrs = sp_repr_css_attr(this_repr, "style");
+ SPCSSAttr *this_node_attrs_inherited = sp_repr_css_attr_inherited(this_repr, "style");
+ for ( const auto & attr :dest_node_attrs->attributeList()) {
+ gchar const *key = g_quark_to_string(attr.key);
+ gchar const *this_attr = this_node_attrs_inherited->attribute(key);
+ if ((this_attr == nullptr || strcmp(attr.value, this_attr)) && this_node_attrs->attribute(key) == nullptr)
+ this_node_attrs->setAttribute(key, this_attr);
+ }
+ sp_repr_css_attr_unref(this_node_attrs_inherited);
+ sp_repr_css_attr_unref(this_node_attrs);
+ sp_repr_css_attr_unref(dest_node_attrs);
+ sp_repr_css_change(new_span_repr, this_node_attrs, "style");
+
+ TextTagAttributes *attributes = attributes_for_object(new_parent_item);
+ if (attributes)
+ attributes->insert(0, moved_char_count);
+ move_child_nodes(this_repr, new_span_repr);
+ this_repr->parent()->removeChild(this_repr);
+ return next_item;
+}
+
+/** erases the given characters from the given string and deletes the
+corresponding x/y/dx/dy/rotate attributes from all its parents. */
+static void erase_from_spstring(SPString *string_item, Glib::ustring::iterator iter_from, Glib::ustring::iterator iter_to)
+{
+ unsigned char_index = 0;
+ unsigned char_count = 0;
+ Glib::ustring *string = &string_item->string;
+
+ for (Glib::ustring::iterator it = string->begin() ; it != iter_from ; ++it){
+ char_index++;
+ }
+ for (Glib::ustring::iterator it = iter_from ; it != iter_to ; ++it){
+ char_count++;
+ }
+ string->erase(iter_from, iter_to);
+ string_item->getRepr()->setContent(string->c_str());
+
+ SPObject *parent_item = string_item;
+ for ( ; ; ) {
+ char_index += sum_sibling_text_lengths_before(parent_item);
+ parent_item = parent_item->parent;
+ TextTagAttributes *attributes = attributes_for_object(parent_item);
+ if (attributes == nullptr) {
+ break;
+ }
+
+ attributes->erase(char_index, char_count);
+ attributes->writeTo(parent_item->getRepr());
+ }
+}
+
+/* Deletes the given characters from a text or flowroot object. This is
+quite a complicated operation, partly due to the cleanup that is done if all
+the text in a subobject has been deleted, and partly due to the difficulty
+of figuring out what is a line break and how to delete one. Returns the
+real start and ending iterators based on the situation. */
+bool
+sp_te_delete (SPItem *item, Inkscape::Text::Layout::iterator const &start,
+ Inkscape::Text::Layout::iterator const &end, iterator_pair &iter_pair)
+{
+ bool success = false;
+
+ iter_pair.first = start;
+ iter_pair.second = end;
+
+ if (start == end) return success;
+
+ if (start > end) {
+ iter_pair.first = end;
+ iter_pair.second = start;
+ }
+
+ SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+ Inkscape::Text::Layout const *layout = te_get_layout(item);
+ SPObject *start_item = nullptr, *end_item = nullptr;
+ Glib::ustring::iterator start_text_iter, end_text_iter;
+ layout->getSourceOfCharacter(iter_pair.first, &start_item, &start_text_iter);
+ layout->getSourceOfCharacter(iter_pair.second, &end_item, &end_text_iter);
+ if (start_item == nullptr) {
+ return success; // start is at end of text
+ }
+ if (is_line_break_object(start_item)) {
+ move_to_end_of_paragraph(&start_item, &start_text_iter);
+ }
+ if (end_item == nullptr) {
+ end_item = item->lastChild();
+ move_to_end_of_paragraph(&end_item, &end_text_iter);
+ } else if (is_line_break_object(end_item)) {
+ move_to_end_of_paragraph(&end_item, &end_text_iter);
+ }
+
+ SPObject *common_ancestor = get_common_ancestor(item, start_item, end_item);
+
+ bool has_text_decoration = false;
+ gchar const *root_style = (item)->getRepr()->attribute("style");
+ if(root_style && strstr(root_style,"text-decoration"))has_text_decoration = true;
+
+ if (start_item == end_item) {
+ // the quick case where we're deleting stuff all from the same string
+ if (SP_IS_STRING(start_item)) { // always true (if it_start != it_end anyway)
+ // If the parent is a tref, editing on this particular string is disallowed.
+ if (SP_IS_TREF(start_item->parent)) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, tref_edit_message);
+ } else {
+ erase_from_spstring(SP_STRING(start_item), start_text_iter, end_text_iter);
+ success = true;
+ }
+ }
+ } else {
+ SPObject *sub_item = start_item;
+ // walk the tree from start_item to end_item, deleting as we go
+ while (sub_item != item) {
+ if (sub_item == end_item) {
+ if (SP_IS_STRING(sub_item)) {
+ // If the parent is a tref, editing on this particular string is disallowed.
+ if (SP_IS_TREF(sub_item->parent)) {
+ desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, tref_edit_message);
+ break;
+ }
+
+ Glib::ustring *string = &SP_STRING(sub_item)->string;
+ erase_from_spstring(SP_STRING(sub_item), string->begin(), end_text_iter);
+ success = true;
+ }
+ break;
+ }
+ if (SP_IS_STRING(sub_item)) {
+ SPString *string = SP_STRING(sub_item);
+ if (sub_item == start_item)
+ erase_from_spstring(string, start_text_iter, string->string.end());
+ else
+ erase_from_spstring(string, string->string.begin(), string->string.end());
+ success = true;
+ }
+ // walk to the next item in the tree
+ if (sub_item->hasChildren())
+ sub_item = sub_item->firstChild();
+ else {
+ SPObject *next_item;
+ do {
+ bool is_sibling = true;
+ next_item = sub_item->getNext();
+ if (next_item == nullptr) {
+ next_item = sub_item->parent;
+ is_sibling = false;
+ }
+
+ if (is_line_break_object(sub_item))
+ next_item = delete_line_break(item, sub_item, &is_sibling);
+
+ sub_item = next_item;
+ if (is_sibling) break;
+ // no more siblings, go up a parent
+ } while (sub_item != item && sub_item != end_item);
+ }
+ }
+ }
+
+ while (tidy_xml_tree_recursively(common_ancestor, has_text_decoration)){};
+ te_update_layout_now(item);
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+ layout->validateIterator(&iter_pair.first);
+ layout->validateIterator(&iter_pair.second);
+ return success;
+}
+
+
+/* ***************************************************************************************************/
+// P L A I N T E X T F U N C T I O N S
+
+/** Gets a text-only representation of the given text or flowroot object,
+replacing line break elements with '\n'. */
+static void sp_te_get_ustring_multiline(SPObject const *root, Glib::ustring *string, bool *pending_line_break)
+{
+ if (*pending_line_break) {
+ *string += '\n';
+ *pending_line_break = false;
+ }
+ for (auto& child: root->children) {
+ if (SP_IS_STRING(&child)) {
+ *string += SP_STRING(&child)->string;
+ } else if (is_part_of_text_subtree(&child)) {
+ sp_te_get_ustring_multiline(&child, string, pending_line_break);
+ }
+ }
+ if (!SP_IS_TEXT(root) && !SP_IS_TEXTPATH(root) && is_line_break_object(root)) {
+ *pending_line_break = true;
+ }
+}
+
+/** Gets a text-only representation of the given text or flowroot object,
+replacing line break elements with '\n'. The return value must be free()d. */
+Glib::ustring
+sp_te_get_string_multiline (SPItem const *text)
+{
+ Glib::ustring string;
+ bool pending_line_break = false;
+
+ if (SP_IS_TEXT(text) || SP_IS_FLOWTEXT(text)) {
+ sp_te_get_ustring_multiline(text, &string, &pending_line_break);
+ }
+ return string;
+}
+
+/** Gets a text-only representation of the characters in a text or flowroot
+object from \a start to \a end only. Line break elements are replaced with
+'\n'. */
+Glib::ustring
+sp_te_get_string_multiline (SPItem const *text, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end)
+{
+ if (start == end) return "";
+ Inkscape::Text::Layout::iterator first, last;
+ if (start < end) {
+ first = start;
+ last = end;
+ } else {
+ first = end;
+ last = start;
+ }
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+ Glib::ustring result;
+ // not a particularly fast piece of code. I'll optimise it if people start to notice.
+ for ( ; first < last ; first.nextCharacter()) {
+ SPObject *char_item = nullptr;
+ Glib::ustring::iterator text_iter;
+ layout->getSourceOfCharacter(first, &char_item, &text_iter);
+ if (SP_IS_STRING(char_item)) {
+ result += *text_iter;
+ } else {
+ result += '\n';
+ }
+ }
+ return result;
+}
+
+void
+sp_te_set_repr_text_multiline(SPItem *text, gchar const *str)
+{
+ g_return_if_fail (text != nullptr);
+ g_return_if_fail (SP_IS_TEXT(text) || SP_IS_FLOWTEXT(text));
+
+ Inkscape::XML::Document *xml_doc = text->getRepr()->document();
+ Inkscape::XML::Node *repr;
+ SPObject *object;
+ bool is_textpath = false;
+ if (SP_IS_TEXT_TEXTPATH (text)) {
+ repr = text->firstChild()->getRepr();
+ object = text->firstChild();
+ is_textpath = true;
+ } else {
+ repr = text->getRepr();
+ object = text;
+ }
+
+ if (!str) {
+ str = "";
+ }
+ gchar *content = g_strdup (str);
+
+ repr->setContent("");
+ for (auto& child: object->childList(false)) {
+ if (!SP_IS_FLOWREGION(child) && !SP_IS_FLOWREGIONEXCLUDE(child)) {
+ repr->removeChild(child->getRepr());
+ }
+ }
+
+ if (is_textpath) {
+ gchar *p = content;
+ while (*p != '\0') {
+ if (*p == '\n') {
+ *p = ' '; // No lines for textpath, replace newlines with spaces.
+ }
+ ++p;
+ }
+ Inkscape::XML::Node *rstr = xml_doc->createTextNode(content);
+ repr->addChild(rstr, nullptr);
+ Inkscape::GC::release(rstr);
+ } else {
+ SPText* sptext = dynamic_cast<SPText *>(text);
+ if (sptext && (sptext->has_inline_size() || sptext->has_shape_inside())) {
+ // Do nothing... we respect newlines (and assume CSS already set to do so).
+ Inkscape::XML::Node *rstr = xml_doc->createTextNode(content);
+ repr->addChild(rstr, nullptr);
+ Inkscape::GC::release(rstr);
+ } else {
+ // Break into tspans with sodipodi:role="line".
+ gchar *p = content;
+ while (p) {
+ gchar *e = strchr (p, '\n');
+ if (e) *e = '\0';
+ Inkscape::XML::Node *rtspan;
+ if (SP_IS_TEXT(text)) { // create a tspan for each line
+ rtspan = xml_doc->createElement("svg:tspan");
+ rtspan->setAttribute("sodipodi:role", "line");
+ } else { // create a flowPara for each line
+ rtspan = xml_doc->createElement("svg:flowPara");
+ }
+ Inkscape::XML::Node *rstr = xml_doc->createTextNode(p);
+ rtspan->addChild(rstr, nullptr);
+ Inkscape::GC::release(rstr);
+ repr->appendChild(rtspan);
+ Inkscape::GC::release(rtspan);
+
+ p = (e) ? e + 1 : nullptr;
+ }
+ }
+ }
+ g_free (content);
+}
+
+/* ***************************************************************************************************/
+// K E R N I N G A N D S P A C I N G
+
+/** Returns the attributes block and the character index within that block
+which represents the iterator \a position. */
+TextTagAttributes*
+text_tag_attributes_at_position(SPItem *item, Inkscape::Text::Layout::iterator const &position, unsigned *char_index)
+{
+ if (item == nullptr || char_index == nullptr || !SP_IS_TEXT(item)) {
+ return nullptr; // flowtext doesn't support kerning yet
+ }
+ SPText *text = SP_TEXT(item);
+
+ SPObject *source_item = nullptr;
+ Glib::ustring::iterator source_text_iter;
+ text->layout.getSourceOfCharacter(position, &source_item, &source_text_iter);
+
+ if (!SP_IS_STRING(source_item)) {
+ return nullptr;
+ }
+ Glib::ustring *string = &SP_STRING(source_item)->string;
+ *char_index = sum_sibling_text_lengths_before(source_item);
+ for (Glib::ustring::iterator it = string->begin() ; it != source_text_iter ; ++it) {
+ ++*char_index;
+ }
+
+ return attributes_for_object(source_item->parent);
+}
+
+void
+sp_te_adjust_kerning_screen (SPItem *item, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop *desktop, Geom::Point by)
+{
+ // divide increment by zoom
+ // divide increment by matrix expansion
+ gdouble factor = 1 / desktop->current_zoom();
+ Geom::Affine t (item->i2doc_affine());
+ factor = factor / t.descrim();
+ by = factor * by;
+
+ unsigned char_index;
+ TextTagAttributes *attributes = text_tag_attributes_at_position(item, std::min(start, end), &char_index);
+ if (attributes) attributes->addToDxDy(char_index, by);
+ if (start != end) {
+ attributes = text_tag_attributes_at_position(item, std::max(start, end), &char_index);
+ if (attributes) attributes->addToDxDy(char_index, -by);
+ }
+
+ item->updateRepr();
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+void sp_te_adjust_dx(SPItem *item, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop * /*desktop*/, double delta)
+{
+ unsigned char_index = 0;
+ TextTagAttributes *attributes = text_tag_attributes_at_position(item, std::min(start, end), &char_index);
+ if (attributes) {
+ attributes->addToDx(char_index, delta);
+ }
+ if (start != end) {
+ attributes = text_tag_attributes_at_position(item, std::max(start, end), &char_index);
+ if (attributes) {
+ attributes->addToDx(char_index, -delta);
+ }
+ }
+
+ item->updateRepr();
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+void sp_te_adjust_dy(SPItem *item, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop * /*desktop*/, double delta)
+{
+ unsigned char_index = 0;
+ TextTagAttributes *attributes = text_tag_attributes_at_position(item, std::min(start, end), &char_index);
+ if (attributes) {
+ attributes->addToDy(char_index, delta);
+ }
+ if (start != end) {
+ attributes = text_tag_attributes_at_position(item, std::max(start, end), &char_index);
+ if (attributes) {
+ attributes->addToDy(char_index, -delta);
+ }
+ }
+
+ item->updateRepr();
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+void
+sp_te_adjust_rotation_screen(SPItem *text, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop *desktop, gdouble pixels)
+{
+ // divide increment by zoom
+ // divide increment by matrix expansion
+ gdouble factor = 1 / desktop->current_zoom();
+ Geom::Affine t (text->i2doc_affine());
+ factor = factor / t.descrim();
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+ if (layout == nullptr) return;
+ SPObject *source_item = nullptr;
+ layout->getSourceOfCharacter(std::min(start, end), &source_item);
+ if (source_item == nullptr) {
+ return;
+ }
+ gdouble degrees = (180/M_PI) * atan2(pixels, source_item->parent->style->font_size.computed / factor);
+
+ sp_te_adjust_rotation(text, start, end, desktop, degrees);
+}
+
+void
+sp_te_adjust_rotation(SPItem *text, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop */*desktop*/, gdouble degrees)
+{
+ unsigned char_index;
+ TextTagAttributes *attributes = text_tag_attributes_at_position(text, std::min(start, end), &char_index);
+ if (attributes == nullptr) return;
+
+ if (start != end) {
+ for (Inkscape::Text::Layout::iterator it = std::min(start, end) ; it != std::max(start, end) ; it.nextCharacter()) {
+ attributes = text_tag_attributes_at_position(text, it, &char_index);
+ if (attributes) attributes->addToRotate(char_index, degrees);
+ }
+ } else
+ attributes->addToRotate(char_index, degrees);
+
+ text->updateRepr();
+ text->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+void sp_te_set_rotation(SPItem *text, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop */*desktop*/, gdouble degrees)
+{
+ unsigned char_index = 0;
+ TextTagAttributes *attributes = text_tag_attributes_at_position(text, std::min(start, end), &char_index);
+ if (attributes != nullptr) {
+ if (start != end) {
+ for (Inkscape::Text::Layout::iterator it = std::min(start, end) ; it != std::max(start, end) ; it.nextCharacter()) {
+ attributes = text_tag_attributes_at_position(text, it, &char_index);
+ if (attributes) {
+ attributes->setRotate(char_index, degrees);
+ }
+ }
+ } else {
+ attributes->setRotate(char_index, degrees);
+ }
+
+ text->updateRepr();
+ text->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+ }
+}
+
+void
+sp_te_adjust_tspan_letterspacing_screen(SPItem *text, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPDesktop *desktop, gdouble by)
+{
+ g_return_if_fail (text != nullptr);
+ g_return_if_fail (SP_IS_TEXT(text) || SP_IS_FLOWTEXT(text));
+
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+
+ gdouble val;
+ SPObject *source_obj = nullptr;
+ unsigned nb_let;
+ layout->getSourceOfCharacter(std::min(start, end), &source_obj);
+
+ if (source_obj == nullptr) { // end of text
+ source_obj = text->lastChild();
+ }
+ if (SP_IS_STRING(source_obj)) {
+ source_obj = source_obj->parent;
+ }
+
+ SPStyle *style = source_obj->style;
+
+ // calculate real value
+ /* TODO: Consider calculating val unconditionally, i.e. drop the first `if' line, and
+ get rid of the `else val = 0.0'. Similarly below and in sp-string.cpp. */
+ if (style->letter_spacing.value != 0 && style->letter_spacing.computed == 0) { // set in em or ex
+ if (style->letter_spacing.unit == SP_CSS_UNIT_EM) {
+ val = style->font_size.computed * style->letter_spacing.value;
+ } else if (style->letter_spacing.unit == SP_CSS_UNIT_EX) {
+ val = style->font_size.computed * style->letter_spacing.value * 0.5;
+ } else { // unknown unit - should not happen
+ val = 0.0;
+ }
+ } else { // there's a real value in .computed, or it's zero
+ val = style->letter_spacing.computed;
+ }
+
+ if (start == end) {
+ while (!is_line_break_object(source_obj)) { // move up the tree so we apply to the closest paragraph
+ source_obj = source_obj->parent;
+ }
+ nb_let = sp_text_get_length(source_obj);
+ } else {
+ nb_let = abs(layout->iteratorToCharIndex(end) - layout->iteratorToCharIndex(start));
+ }
+
+ // divide increment by zoom and by the number of characters in the line,
+ // so that the entire line is expanded by by pixels, no matter what its length
+ gdouble const zoom = desktop->current_zoom();
+ gdouble const zby = (by
+ / (zoom * (nb_let > 1 ? nb_let - 1 : 1))
+ / SP_ITEM(source_obj)->i2doc_affine().descrim());
+ val += zby;
+
+ if (start == end) {
+ // set back value to entire paragraph
+ style->letter_spacing.normal = FALSE;
+ if (style->letter_spacing.value != 0 && style->letter_spacing.computed == 0) { // set in em or ex
+ if (style->letter_spacing.unit == SP_CSS_UNIT_EM) {
+ style->letter_spacing.value = val / style->font_size.computed;
+ } else if (style->letter_spacing.unit == SP_CSS_UNIT_EX) {
+ style->letter_spacing.value = val / style->font_size.computed * 2;
+ }
+ } else {
+ style->letter_spacing.computed = val;
+ }
+
+ style->letter_spacing.set = TRUE;
+ } else {
+ // apply to selection only
+ SPCSSAttr *css = sp_repr_css_attr_new();
+ char string_val[40];
+ g_snprintf(string_val, sizeof(string_val), "%f", val);
+ sp_repr_css_set_property(css, "letter-spacing", string_val);
+ sp_te_apply_style(text, start, end, css);
+ sp_repr_css_attr_unref(css);
+ }
+
+ text->updateRepr();
+ text->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_TEXT_LAYOUT_MODIFIED_FLAG);
+}
+
+// Only used for page-up and page-down and sp_te_adjust_linespacing_screen
+double
+sp_te_get_average_linespacing (SPItem *text)
+{
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+ if (!layout)
+ return 0;
+
+ unsigned line_count = layout->lineIndex(layout->end());
+ auto mode = text->style->writing_mode.computed;
+ bool horizontal = (mode == SP_CSS_WRITING_MODE_LR_TB || mode == SP_CSS_WRITING_MODE_RL_TB);
+ auto index = horizontal ? Geom::Y : Geom::X;
+ double all_lines_height = layout->characterAnchorPoint(layout->end())[index] - layout->characterAnchorPoint(layout->begin())[index];
+ double average_line_height = all_lines_height / (line_count == 0 ? 1 : line_count);
+ if (mode == SP_CSS_WRITING_MODE_TB_RL) {
+ average_line_height = -average_line_height;
+ }
+ return average_line_height;
+}
+
+/** Adjust the line height by 'amount'.
+ * If top_level is true then 'line-height' will be set where possible,
+ * otherwise objects that inherit line-height will not be touched.
+ */
+void
+sp_te_adjust_line_height (SPObject *object, double amount, double average, bool top_level = true) {
+
+ SPStyle *style = object->style;
+
+ // Always set if top level true.
+ // Also set if line_height is set to a non-zero value.
+ if (top_level ||
+ (style->line_height.set && !style->line_height.inherit && style->line_height.computed != 0)){
+
+ // Scale default values
+ if (!style->line_height.set || style->line_height.inherit || style->line_height.normal) {
+ style->line_height.set = TRUE;
+ style->line_height.inherit = FALSE;
+ style->line_height.normal = FALSE;
+ style->line_height.unit = SP_CSS_UNIT_NONE;
+ style->line_height.value = style->line_height.computed = Inkscape::Text::Layout::LINE_HEIGHT_NORMAL;
+ }
+
+ switch (style->line_height.unit) {
+
+ case SP_CSS_UNIT_NONE:
+ default:
+ // Multiplier-type units, stored in computed
+ if (fabs(style->line_height.computed) < 0.001) {
+ style->line_height.computed = amount < 0.0 ? -0.001 : 0.001;
+ // the formula below could get stuck at zero
+ } else {
+ style->line_height.computed *= (average + amount) / average;
+ }
+ style->line_height.value = style->line_height.computed;
+ break;
+
+
+ // Relative units, stored in value
+ case SP_CSS_UNIT_EM:
+ case SP_CSS_UNIT_EX:
+ case SP_CSS_UNIT_PERCENT:
+ if (fabs(style->line_height.value) < 0.001) {
+ style->line_height.value = amount < 0.0 ? -0.001 : 0.001;
+ } else {
+ style->line_height.value *= (average + amount) / average;
+ }
+ break;
+
+
+ // Absolute units
+ case SP_CSS_UNIT_PX:
+ style->line_height.computed += amount;
+ style->line_height.value = style->line_height.computed;
+ break;
+ case SP_CSS_UNIT_PT:
+ style->line_height.computed += Inkscape::Util::Quantity::convert(amount, "px", "pt");
+ style->line_height.value = style->line_height.computed;
+ break;
+ case SP_CSS_UNIT_PC:
+ style->line_height.computed += Inkscape::Util::Quantity::convert(amount, "px", "pc");
+ style->line_height.value = style->line_height.computed;
+ break;
+ case SP_CSS_UNIT_MM:
+ style->line_height.computed += Inkscape::Util::Quantity::convert(amount, "px", "mm");
+ style->line_height.value = style->line_height.computed;
+ break;
+ case SP_CSS_UNIT_CM:
+ style->line_height.computed += Inkscape::Util::Quantity::convert(amount, "px", "cm");
+ style->line_height.value = style->line_height.computed;
+ break;
+ case SP_CSS_UNIT_IN:
+ style->line_height.computed += Inkscape::Util::Quantity::convert(amount, "px", "in");
+ style->line_height.value = style->line_height.computed;
+ break;
+ }
+ object->updateRepr();
+ }
+
+ std::vector<SPObject*> children = object->childList(false);
+ for (auto child: children) {
+ sp_te_adjust_line_height (child, amount, average, false);
+ }
+}
+
+void
+sp_te_adjust_linespacing_screen (SPItem *text, Inkscape::Text::Layout::iterator const &/*start*/, Inkscape::Text::Layout::iterator const &/*end*/, SPDesktop *desktop, gdouble by)
+{
+ // TODO: use start and end iterators to delineate the area to be affected
+ g_return_if_fail (text != nullptr);
+ g_return_if_fail (SP_IS_TEXT(text) || SP_IS_FLOWTEXT(text));
+
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+
+ double average_line_height = sp_te_get_average_linespacing (text);
+ if (fabs(average_line_height) < 0.001) average_line_height = 0.001;
+
+ // divide increment by zoom and by the number of lines,
+ // so that the entire object is expanded by by pixels
+ unsigned line_count = layout->lineIndex(layout->end());
+ gdouble zby = by / (desktop->current_zoom() * (line_count == 0 ? 1 : line_count));
+
+ // divide increment by matrix expansion
+ Geom::Affine t(text->i2doc_affine());
+ zby = zby / t.descrim();
+
+ sp_te_adjust_line_height (text, zby, average_line_height, false);
+
+ text->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_TEXT_LAYOUT_MODIFIED_FLAG);
+}
+
+
+/* ***************************************************************************************************/
+// S T Y L E A P P L I C A T I O N
+
+
+/** converts an iterator to a character index, mainly because ustring::substr()
+doesn't have a version that takes iterators as parameters. */
+static unsigned char_index_of_iterator(Glib::ustring const &string, Glib::ustring::const_iterator text_iter)
+{
+ unsigned n = 0;
+ for (Glib::ustring::const_iterator it = string.begin() ; it != string.end() && it != text_iter ; ++it)
+ n++;
+ return n;
+}
+
+// Move to style.h?
+/** applies the given style string on top of the existing styles for \a item,
+as opposed to sp_style_merge_from_style_string which merges its parameter
+underneath the existing styles (ie ignoring already set properties). */
+static void overwrite_style_with_string(SPObject *item, gchar const *style_string)
+{
+ SPStyle style(item->document);
+ style.mergeString(style_string);
+ gchar const *item_style_string = item->getRepr()->attribute("style");
+ if (item_style_string && *item_style_string) {
+ style.mergeString(item_style_string);
+ }
+ Glib::ustring new_style_string = style.write();
+ item->setAttributeOrRemoveIfEmpty("style", new_style_string);
+}
+
+// Move to style.h?
+/** Returns true if the style of \a parent and the style of \a child are
+equivalent (and hence the children of both will appear the same). It is a
+limitation of the current implementation that \a parent must be a (not
+necessarily immediate) ancestor of \a child. */
+static bool objects_have_equal_style(SPObject const *parent, SPObject const *child)
+{
+ // the obvious implementation of strcmp(style_write_all(parent), style_write_all(child))
+ // will not work. Firstly because of an inheritance bug in style.cpp that has
+ // implications too large for me to feel safe fixing, but mainly because the css spec
+ // requires that the computed value is inherited, not the specified value.
+ g_assert(parent->isAncestorOf(child));
+
+ Glib::ustring parent_style = parent->style->write( SP_STYLE_FLAG_ALWAYS );
+
+ // we have to write parent_style then read it again, because some properties format their values
+ // differently depending on whether they're set or not (*cough*dash-offset*cough*)
+ SPStyle parent_spstyle(parent->document);
+ parent_spstyle.mergeString(parent_style.c_str());
+ parent_style = parent_spstyle.write(SP_STYLE_FLAG_ALWAYS);
+
+ Glib::ustring child_style_construction;
+ while (child != parent) {
+ // FIXME: this assumes that child's style is only in style= whereas it can also be in css attributes!
+ char const *style_text = child->getRepr()->attribute("style");
+ if (style_text && *style_text) {
+ child_style_construction.insert(0, style_text);
+ child_style_construction.insert(0, 1, ';');
+ }
+ child = child->parent;
+ }
+ child_style_construction.insert(0, parent_style);
+
+ SPStyle child_spstyle(parent->document);
+ child_spstyle.mergeString(child_style_construction.c_str());
+ Glib::ustring child_style = child_spstyle.write(SP_STYLE_FLAG_ALWAYS);
+
+ bool equal = (child_style == parent_style); // Glib::ustring overloads == operator
+ return equal;
+}
+
+/** returns true if \a first and \a second contain all the same attributes
+with the same values as each other. Note that we have to compare both
+forwards and backwards to make sure we don't miss any attributes that are
+in one but not the other. */
+static bool css_attrs_are_equal(SPCSSAttr const *first, SPCSSAttr const *second)
+{
+ for ( const auto & attr : first->attributeList()) {
+ gchar const *other_attr = second->attribute(g_quark_to_string(attr.key));
+ if (other_attr == nullptr || strcmp(attr.value, other_attr))
+ return false;
+ }
+ for (const auto & attr : second->attributeList()) {
+ gchar const *other_attr = first->attribute(g_quark_to_string(attr.key));
+ if (other_attr == nullptr || strcmp(attr.value, other_attr))
+ return false;
+ }
+ return true;
+}
+
+/** sets the given css attribute on this object and all its descendants.
+Annoyingly similar to sp_desktop_apply_css_recursive(), except without the
+transform stuff. */
+static void apply_css_recursive(SPObject *o, SPCSSAttr const *css)
+{
+ sp_repr_css_change(o->getRepr(), const_cast<SPCSSAttr*>(css), "style");
+
+ for (auto& child: o->children) {
+ if (sp_repr_css_property(const_cast<SPCSSAttr*>(css), "opacity", nullptr) != nullptr) {
+ // Unset properties which are accumulating and thus should not be set recursively.
+ // For example, setting opacity 0.5 on a group recursively would result in the visible opacity of 0.25 for an item in the group.
+ SPCSSAttr *css_recurse = sp_repr_css_attr_new();
+ sp_repr_css_merge(css_recurse, const_cast<SPCSSAttr*>(css));
+ sp_repr_css_set_property(css_recurse, "opacity", nullptr);
+ apply_css_recursive(&child, css_recurse);
+ sp_repr_css_attr_unref(css_recurse);
+ } else {
+ apply_css_recursive(&child, const_cast<SPCSSAttr*>(css));
+ }
+ }
+}
+
+/** applies the given style to all the objects at the given level and below
+which are between \a start_item and \a end_item, creating spans as necessary.
+If \a start_item or \a end_item are NULL then the style is applied to all
+objects to the beginning or end respectively. \a span_object_name is the
+name of the xml for a text span (ie tspan or flowspan). */
+static void recursively_apply_style(SPObject *common_ancestor, SPCSSAttr const *css, SPObject *start_item, Glib::ustring::iterator start_text_iter, SPObject *end_item, Glib::ustring::iterator end_text_iter, char const *span_object_name)
+{
+ bool passed_start = start_item == nullptr ? true : false;
+ Inkscape::XML::Document *xml_doc = common_ancestor->document->getReprDoc();
+
+ for (SPObject *child = common_ancestor->firstChild() ; child ; child = child->getNext()) {
+ if (start_item == child) {
+ passed_start = true;
+ }
+
+ if (passed_start) {
+ if (end_item && child->isAncestorOf(end_item)) {
+ recursively_apply_style(child, css, nullptr, start_text_iter, end_item, end_text_iter, span_object_name);
+ break;
+ }
+ // apply style
+
+ // note that when adding stuff we must make sure that 'child' stays valid so the for loop keeps working.
+ // often this means that new spans are created before child and child is modified only
+ if (SP_IS_STRING(child)) {
+ SPString *string_item = SP_STRING(child);
+ bool surround_entire_string = true;
+
+ Inkscape::XML::Node *child_span = xml_doc->createElement(span_object_name);
+ sp_repr_css_set(child_span, const_cast<SPCSSAttr*>(css), "style"); // better hope that prototype wasn't nonconst for a good reason
+ SPObject *prev_item = child->getPrev();
+ Inkscape::XML::Node *prev_repr = prev_item ? prev_item->getRepr() : nullptr;
+
+ if (child == start_item || child == end_item) {
+ surround_entire_string = false;
+ if (start_item == end_item && start_text_iter != string_item->string.begin()) {
+ // eg "abcDEFghi" -> "abc"<span>"DEF"</span>"ghi"
+ unsigned start_char_index = char_index_of_iterator(string_item->string, start_text_iter);
+ unsigned end_char_index = char_index_of_iterator(string_item->string, end_text_iter);
+
+ Inkscape::XML::Node *text_before = xml_doc->createTextNode(string_item->string.substr(0, start_char_index).c_str());
+ common_ancestor->getRepr()->addChild(text_before, prev_repr);
+ common_ancestor->getRepr()->addChild(child_span, text_before);
+ Inkscape::GC::release(text_before);
+ Inkscape::XML::Node *text_in_span = xml_doc->createTextNode(string_item->string.substr(start_char_index, end_char_index - start_char_index).c_str());
+ child_span->appendChild(text_in_span);
+ Inkscape::GC::release(text_in_span);
+ child->getRepr()->setContent(string_item->string.substr(end_char_index).c_str());
+ } else if (child == end_item) {
+ // eg "ABCdef" -> <span>"ABC"</span>"def"
+ // (includes case where start_text_iter == begin())
+ // NB: we might create an empty string here. Doesn't matter, it'll get cleaned up later
+ unsigned end_char_index = char_index_of_iterator(string_item->string, end_text_iter);
+
+ common_ancestor->getRepr()->addChild(child_span, prev_repr);
+ Inkscape::XML::Node *text_in_span = xml_doc->createTextNode(string_item->string.substr(0, end_char_index).c_str());
+ child_span->appendChild(text_in_span);
+ Inkscape::GC::release(text_in_span);
+ child->getRepr()->setContent(string_item->string.substr(end_char_index).c_str());
+ } else if (start_text_iter != string_item->string.begin()) {
+ // eg "abcDEF" -> "abc"<span>"DEF"</span>
+ unsigned start_char_index = char_index_of_iterator(string_item->string, start_text_iter);
+
+ Inkscape::XML::Node *text_before = xml_doc->createTextNode(string_item->string.substr(0, start_char_index).c_str());
+ common_ancestor->getRepr()->addChild(text_before, prev_repr);
+ common_ancestor->getRepr()->addChild(child_span, text_before);
+ Inkscape::GC::release(text_before);
+ Inkscape::XML::Node *text_in_span = xml_doc->createTextNode(string_item->string.substr(start_char_index).c_str());
+ child_span->appendChild(text_in_span);
+ Inkscape::GC::release(text_in_span);
+ child->deleteObject();
+ child = common_ancestor->get_child_by_repr(child_span);
+
+ } else
+ surround_entire_string = true;
+ }
+ if (surround_entire_string) {
+ Inkscape::XML::Node *child_repr = child->getRepr();
+ common_ancestor->getRepr()->addChild(child_span, child_repr);
+ Inkscape::GC::anchor(child_repr);
+ common_ancestor->getRepr()->removeChild(child_repr);
+ child_span->appendChild(child_repr);
+ Inkscape::GC::release(child_repr);
+ child = common_ancestor->get_child_by_repr(child_span);
+ }
+ Inkscape::GC::release(child_span);
+
+ } else if (child != end_item) { // not a string and we're applying to the entire object. This is easy
+ apply_css_recursive(child, css);
+ }
+
+ } else { // !passed_start
+ if (child->isAncestorOf(start_item)) {
+ recursively_apply_style(child, css, start_item, start_text_iter, end_item, end_text_iter, span_object_name);
+ if (end_item && child->isAncestorOf(end_item))
+ break; // only happens when start_item == end_item (I think)
+ passed_start = true;
+ }
+ }
+
+ if (end_item == child)
+ break;
+ }
+}
+
+/* if item is at the beginning of a tree it doesn't matter which element
+it points to so for neatness we would like it to point to the highest
+possible child of \a common_ancestor. There is no iterator return because
+a string can never be an ancestor.
+
+eg: <span><span>*ABC</span>DEFghi</span> where * is the \a item. We would
+like * to point to the inner span because we can apply style to that whole
+span. */
+static SPObject* ascend_while_first(SPObject *item, Glib::ustring::iterator text_iter, SPObject *common_ancestor)
+{
+ if (item == common_ancestor)
+ return item;
+ if (SP_IS_STRING(item))
+ if (text_iter != SP_STRING(item)->string.begin())
+ return item;
+ for ( ; ; ) {
+ SPObject *parent = item->parent;
+ if (parent == common_ancestor) {
+ break;
+ }
+ if (item != parent->firstChild()) {
+ break;
+ }
+ item = parent;
+ }
+ return item;
+}
+
+
+/** empty spans: abc<span></span>def
+ -> abcdef */
+static bool tidy_operator_empty_spans(SPObject **item, bool /*has_text_decoration*/)
+{
+ bool result = false;
+ if ( !(*item)->hasChildren()
+ && !is_line_break_object(*item)
+ && !(SP_IS_STRING(*item) && !SP_STRING(*item)->string.empty())
+ ) {
+ SPObject *next = (*item)->getNext();
+ (*item)->deleteObject();
+ *item = next;
+ result = true;
+ }
+ return result;
+}
+
+/** inexplicable spans: abc<span style="">def</span>ghi
+ -> "abc""def""ghi"
+the repeated strings will be merged by another operator. */
+static bool tidy_operator_inexplicable_spans(SPObject **item, bool /*has_text_decoration*/)
+{
+ //XML Tree being directly used here while it shouldn't be.
+ if (*item && sp_repr_is_meta_element((*item)->getRepr())) {
+ return false;
+ }
+ if (SP_IS_STRING(*item)) {
+ return false;
+ }
+ if (is_line_break_object(*item)) {
+ return false;
+ }
+ TextTagAttributes *attrs = attributes_for_object(*item);
+ if (attrs && attrs->anyAttributesSet()) {
+ return false;
+ }
+ if (!objects_have_equal_style((*item)->parent, *item)) {
+ return false;
+ }
+ SPObject *next = *item;
+ while ((*item)->hasChildren()) {
+ Inkscape::XML::Node *repr = (*item)->firstChild()->getRepr();
+ Inkscape::GC::anchor(repr);
+ (*item)->getRepr()->removeChild(repr);
+ (*item)->parent->getRepr()->addChild(repr, next->getRepr());
+ Inkscape::GC::release(repr);
+ next = next->getNext();
+ }
+ (*item)->deleteObject();
+ *item = next;
+ return true;
+}
+
+/** repeated spans: <font a>abc</font><font a>def</font>
+ -> <font a>abcdef</font> */
+static bool tidy_operator_repeated_spans(SPObject **item, bool /*has_text_decoration*/)
+{
+ SPObject *first = *item;
+ SPObject *second = first->getNext();
+ if (second == nullptr) return false;
+
+ Inkscape::XML::Node *first_repr = first->getRepr();
+ Inkscape::XML::Node *second_repr = second->getRepr();
+
+ if (first_repr->type() != second_repr->type()) return false;
+
+ if (SP_IS_STRING(first) && SP_IS_STRING(second)) {
+ // also amalgamate consecutive SPStrings into one
+ Glib::ustring merged_string = SP_STRING(first)->string + SP_STRING(second)->string;
+ first->getRepr()->setContent(merged_string.c_str());
+ second_repr->parent()->removeChild(second_repr);
+ return true;
+ }
+
+ // merge consecutive spans with identical styles into one
+ if (first_repr->type() != Inkscape::XML::NodeType::ELEMENT_NODE) return false;
+ if (strcmp(first_repr->name(), second_repr->name()) != 0) return false;
+ if (is_line_break_object(second)) return false;
+ gchar const *first_style = first_repr->attribute("style");
+ gchar const *second_style = second_repr->attribute("style");
+ if (!((first_style == nullptr && second_style == nullptr)
+ || (first_style != nullptr && second_style != nullptr && !strcmp(first_style, second_style))))
+ return false;
+
+ // all our tests passed: do the merge
+ TextTagAttributes *attributes_first = attributes_for_object(first);
+ TextTagAttributes *attributes_second = attributes_for_object(second);
+ if (attributes_first && attributes_second && attributes_second->anyAttributesSet()) {
+ TextTagAttributes attributes_first_copy = *attributes_first;
+ attributes_first->join(attributes_first_copy, *attributes_second, sp_text_get_length(first));
+ }
+ move_child_nodes(second_repr, first_repr);
+ second_repr->parent()->removeChild(second_repr);
+ return true;
+ // *item is still the next object to process
+}
+
+/** redundant nesting: <font a><font b>abc</font></font>
+ -> <font b>abc</font>
+ excessive nesting: <font a><size 1>abc</size></font>
+ -> <font a,size 1>abc</font> */
+static bool tidy_operator_excessive_nesting(SPObject **item, bool /*has_text_decoration*/)
+{
+ if (!(*item)->hasChildren()) {
+ return false;
+ }
+ if ((*item)->firstChild() != (*item)->lastChild()) {
+ return false;
+ }
+ if (SP_IS_FLOWREGION((*item)->firstChild()) || SP_IS_FLOWREGIONEXCLUDE((*item)->firstChild())) {
+ return false;
+ }
+ if (SP_IS_STRING((*item)->firstChild())) {
+ return false;
+ }
+ if (is_line_break_object((*item)->firstChild())) {
+ return false;
+ }
+ TextTagAttributes *attrs = attributes_for_object((*item)->firstChild());
+ if (attrs && attrs->anyAttributesSet()) {
+ return false;
+ }
+ gchar const *child_style = (*item)->firstChild()->getRepr()->attribute("style");
+ if (child_style && *child_style) {
+ overwrite_style_with_string(*item, child_style);
+ }
+ move_child_nodes((*item)->firstChild()->getRepr(), (*item)->getRepr());
+ (*item)->firstChild()->deleteObject();
+ return true;
+}
+
+/** helper for tidy_operator_redundant_double_nesting() */
+static bool redundant_double_nesting_processor(SPObject **item, SPObject *child, bool prepend)
+{
+ if (SP_IS_FLOWREGION(child) || SP_IS_FLOWREGIONEXCLUDE(child)) {
+ return false;
+ }
+ if (SP_IS_STRING(child)) {
+ return false;
+ }
+ if (is_line_break_object(child)) {
+ return false;
+ }
+ if (is_line_break_object(*item)) {
+ return false;
+ }
+ TextTagAttributes *attrs = attributes_for_object(child);
+ if (attrs && attrs->anyAttributesSet()) {
+ return false;
+ }
+ if (!objects_have_equal_style((*item)->parent, child)) {
+ return false;
+ }
+
+ Inkscape::XML::Node *insert_after_repr = nullptr;
+ if (!prepend) {
+ insert_after_repr = (*item)->getRepr();
+ } else if ((*item)->getPrev()) {
+ insert_after_repr = (*item)->getPrev()->getRepr();
+ }
+ while (child->getRepr()->childCount()) {
+ Inkscape::XML::Node *move_repr = child->getRepr()->firstChild();
+ Inkscape::GC::anchor(move_repr);
+ child->getRepr()->removeChild(move_repr);
+ (*item)->parent->getRepr()->addChild(move_repr, insert_after_repr);
+ Inkscape::GC::release(move_repr);
+ insert_after_repr = move_repr; // I think this will stay valid long enough. It's garbage collected these days.
+ }
+ child->deleteObject();
+ return true;
+}
+
+/** redundant double nesting: <font b><font a><font b>abc</font>def</font>ghi</font>
+ -> <font b>abc<font a>def</font>ghi</font>
+this function does its work when the parameter is the <font a> tag in the
+example. You may note that this only does its work when the doubly-nested
+child is the first or last. The other cases are called 'style inversion'
+below, and I'm not yet convinced that the result of that operation will be
+tidier in all cases. */
+static bool tidy_operator_redundant_double_nesting(SPObject **item, bool /*has_text_decoration*/)
+{
+ if (!(*item)->hasChildren()) return false;
+ if ((*item)->firstChild() == (*item)->lastChild()) return false; // this is excessive nesting, done above
+ if (redundant_double_nesting_processor(item, (*item)->firstChild(), true))
+ return true;
+ if (redundant_double_nesting_processor(item, (*item)->lastChild(), false))
+ return true;
+ return false;
+}
+
+/** helper for tidy_operator_redundant_semi_nesting(). Checks a few things,
+then compares the styles for item+child versus just child. If they're equal,
+tidying is possible. */
+static bool redundant_semi_nesting_processor(SPObject **item, SPObject *child, bool prepend)
+{
+ if (SP_IS_FLOWREGION(child) || SP_IS_FLOWREGIONEXCLUDE(child))
+ return false;
+ if (SP_IS_STRING(child)) return false;
+ if (is_line_break_object(child)) return false;
+ if (is_line_break_object(*item)) return false;
+ TextTagAttributes *attrs = attributes_for_object(child);
+ if (attrs && attrs->anyAttributesSet()) return false;
+ attrs = attributes_for_object(*item);
+ if (attrs && attrs->anyAttributesSet()) return false;
+
+ SPCSSAttr *css_child_and_item = sp_repr_css_attr_new();
+ SPCSSAttr *css_child_only = sp_repr_css_attr_new();
+ gchar const *item_style = (*item)->getRepr()->attribute("style");
+ if (item_style && *item_style) {
+ sp_repr_css_attr_add_from_string(css_child_and_item, item_style);
+ }
+ gchar const *child_style = child->getRepr()->attribute("style");
+ if (child_style && *child_style) {
+ sp_repr_css_attr_add_from_string(css_child_and_item, child_style);
+ sp_repr_css_attr_add_from_string(css_child_only, child_style);
+ }
+ bool equal = css_attrs_are_equal(css_child_only, css_child_and_item);
+ sp_repr_css_attr_unref(css_child_and_item);
+ sp_repr_css_attr_unref(css_child_only);
+ if (!equal) return false;
+
+ Inkscape::XML::Document *xml_doc = (*item)->getRepr()->document();
+ Inkscape::XML::Node *new_span = xml_doc->createElement((*item)->getRepr()->name());
+ if (prepend) {
+ SPObject *prev = (*item)->getPrev();
+ (*item)->parent->getRepr()->addChild(new_span, prev ? prev->getRepr() : nullptr);
+ } else {
+ (*item)->parent->getRepr()->addChild(new_span, (*item)->getRepr());
+ }
+ new_span->setAttribute("style", child->getRepr()->attribute("style"));
+ move_child_nodes(child->getRepr(), new_span);
+ Inkscape::GC::release(new_span);
+ child->deleteObject();
+ return true;
+}
+
+/** redundant semi-nesting: <font a><font b>abc</font>def</font>
+ -> <font b>abc</font><font>def</font>
+test this by applying a colour to a region, then a different colour to
+a partially-overlapping region. */
+static bool tidy_operator_redundant_semi_nesting(SPObject **item, bool /*has_text_decoration*/)
+{
+ if (!(*item)->hasChildren()) return false;
+ if ((*item)->firstChild() == (*item)->lastChild()) return false; // this is redundant nesting, done above
+ if (redundant_semi_nesting_processor(item, (*item)->firstChild(), true))
+ return true;
+ if (redundant_semi_nesting_processor(item, (*item)->lastChild(), false))
+ return true;
+ return false;
+}
+
+
+/* tidy_operator_styled_whitespace commented out: not only did it have bugs,
+ * but it did *not* preserve the rendering: spaces in different font sizes,
+ * for instance, have different width, so moving them out of tspans changes
+ * the document. cf https://bugs.launchpad.net/inkscape/+bug/1477723
+*/
+
+#if 0
+/** helper for tidy_operator_styled_whitespace(), finds the last string object
+in a paragraph which is not \a not_obj. */
+static SPString* find_last_string_child_not_equal_to(SPObject *root, SPObject *not_obj)
+{
+ for (SPObject *child = root->lastChild() ; child ; child = child->getPrev())
+ {
+ if (child == not_obj) continue;
+ if (child->hasChildren()) {
+ SPString *ret = find_last_string_child_not_equal_to(child, not_obj);
+ if (ret) return ret;
+ } else if (SP_IS_STRING(child))
+ return SP_STRING(child);
+ }
+ return NULL;
+}
+
+/** whitespace-only spans:
+ abc<font> </font>def
+ -> abc<font></font> def
+ abc<b><i>def</i> </b>ghi
+ -> abc<b><i>def</i></b> ghi
+
+ visible text-decoration changes on white spaces should not be subject
+ to this sort of processing. So
+ abc<text-decoration-color> </text-decoration-color>def
+ is unchanged.
+*/
+static bool tidy_operator_styled_whitespace(SPObject **item, bool has_text_decoration)
+{
+ // any type of visible text decoration is OK as pure spaces, so do nothing here in that case.
+ if (!SP_IS_STRING(*item) || has_text_decoration ) {
+ return false;
+ }
+ Glib::ustring const &str = SP_STRING(*item)->string;
+ for (Glib::ustring::const_iterator it = str.begin() ; it != str.end() ; ++it) {
+ if (!g_unichar_isspace(*it)) {
+ return false;
+ }
+ }
+
+
+ SPObject *test_item = *item;
+ SPString *next_string;
+ for ( ; ; ) { // find the next string
+ next_string = sp_te_seek_next_string_recursive(test_item->getNext());
+ if (next_string) {
+ next_string->string.insert(0, str);
+ break;
+ }
+ for ( ; ; ) { // go up one item in the xml
+ test_item = test_item->parent;
+ if (is_line_break_object(test_item)) {
+ break;
+ }
+ if (SP_IS_FLOWTEXT(test_item)) {
+ return false;
+ }
+ SPObject *next = test_item->getNext();
+ if (next) {
+ test_item = next;
+ break;
+ }
+ }
+ if (is_line_break_object(test_item)) { // no next string, see if there's a prev string
+ next_string = find_last_string_child_not_equal_to(test_item, *item);
+ if (next_string == NULL) {
+ return false; // an empty paragraph
+ }
+ next_string->string = str + next_string->string;
+ break;
+ }
+ }
+ next_string->getRepr()->setContent(next_string->string.c_str());
+ SPObject *delete_obj = *item;
+ *item = (*item)->getNext();
+ delete_obj->deleteObject();
+ return true;
+}
+#endif
+
+/* possible tidy operators that are not yet implemented, either because
+they are difficult, occur infrequently, or because I'm not sure that the
+output is tidier in all cases:
+ duplicate styles in line break elements: <div italic><para italic>abc</para></div>
+ -> <div italic><para>abc</para></div>
+ style inversion: <font a>abc<font b>def<font a>ghi</font>jkl</font>mno</font>
+ -> <font a>abc<font b>def</font>ghi<font b>jkl</font>mno</font>
+ mistaken precedence: <font a,size 1>abc</font><size 1>def</size>
+ -> <size 1><font a>abc</font>def</size>
+*/
+
+/** Recursively walks the xml tree calling a set of cleanup operations on
+every child. Returns true if any changes were made to the tree.
+
+All the tidy operators return true if they made changes, and alter their
+parameter to point to the next object that should be processed, or NULL.
+They must not significantly alter (ie delete) any ancestor elements of the
+one they are passed.
+
+It may be that some of the later tidy operators that I wrote are actually
+general cases of the earlier operators, and hence the special-case-only
+versions can be removed. I haven't analysed my work in detail to figure
+out if this is so. */
+static bool tidy_xml_tree_recursively(SPObject *root, bool has_text_decoration)
+{
+ gchar const *root_style = (root)->getRepr()->attribute("style");
+ if(root_style && strstr(root_style,"text-decoration"))has_text_decoration = true;
+ static bool (* const tidy_operators[])(SPObject**, bool) = {
+ tidy_operator_empty_spans,
+ tidy_operator_inexplicable_spans,
+ tidy_operator_repeated_spans,
+ tidy_operator_excessive_nesting,
+ tidy_operator_redundant_double_nesting,
+ tidy_operator_redundant_semi_nesting
+ };
+ bool changes = false;
+
+ for (SPObject *child = root->firstChild() ; child != nullptr ; ) {
+ if (SP_IS_FLOWREGION(child) || SP_IS_FLOWREGIONEXCLUDE(child) || SP_IS_TREF(child)) {
+ child = child->getNext();
+ continue;
+ }
+ if (child->hasChildren()) {
+ changes |= tidy_xml_tree_recursively(child, has_text_decoration);
+ }
+
+ unsigned i;
+ for (i = 0 ; i < sizeof(tidy_operators) / sizeof(tidy_operators[0]) ; i++) {
+ if (tidy_operators[i](&child, has_text_decoration)) {
+ changes = true;
+ break;
+ }
+ }
+ if (i == sizeof(tidy_operators) / sizeof(tidy_operators[0])) {
+ child = child->getNext();
+ }
+ }
+ return changes;
+}
+
+/** Applies the given CSS fragment to the characters of the given text or
+flowtext object between \a start and \a end, creating or removing span
+elements as necessary and optimal. */
+void sp_te_apply_style(SPItem *text, Inkscape::Text::Layout::iterator const &start, Inkscape::Text::Layout::iterator const &end, SPCSSAttr const *css)
+{
+ // in the comments in the code below, capital letters are inside the application region, lowercase are outside
+ if (start == end) return;
+ Inkscape::Text::Layout::iterator first, last;
+ if (start < end) {
+ first = start;
+ last = end;
+ } else {
+ first = end;
+ last = start;
+ }
+ Inkscape::Text::Layout const *layout = te_get_layout(text);
+ SPObject *start_item = nullptr, *end_item = nullptr;
+ Glib::ustring::iterator start_text_iter, end_text_iter;
+ layout->getSourceOfCharacter(first, &start_item, &start_text_iter);
+ layout->getSourceOfCharacter(last, &end_item, &end_text_iter);
+ if (start_item == nullptr) {
+ return; // start is at end of text
+ }
+ if (is_line_break_object(start_item)) {
+ start_item = start_item->getNext();
+ }
+ if (is_line_break_object(end_item)) {
+ end_item = end_item->getNext();
+ }
+ if (end_item == nullptr) {
+ end_item = text;
+ }
+
+
+ /* Special case: With a tref, we only want to change its style when the whole
+ * string is selected, in which case the style can be applied directly to the
+ * tref node. If only part of the tref's string child is selected, just return. */
+
+ if (!sp_tref_fully_contained(start_item, start_text_iter, end_item, end_text_iter)) {
+
+ return;
+ }
+
+ /* stage 1: applying the style. Go up to the closest common ancestor of
+ start and end and then semi-recursively apply the style to all the
+ objects in between. The semi-recursion is because it's only necessary
+ at the beginning and end; the style can just be applied to the root
+ child in the middle.
+ eg: <span>abcDEF</span><span>GHI</span><span>JKLmno</span>
+ The recursion may involve creating new spans.
+ */
+ SPObject *common_ancestor = get_common_ancestor(text, start_item, end_item);
+
+ // bug #168370 (consider parent transform and viewBox)
+ // snipplet copied from desktop-style.cpp sp_desktop_apply_css_recursive(...)
+ SPCSSAttr *css_set = sp_repr_css_attr_new();
+ sp_repr_css_merge(css_set, const_cast<SPCSSAttr*>(css));
+ {
+ Geom::Affine const local(SP_ITEM(common_ancestor)->i2doc_affine());
+ double const ex(local.descrim());
+ if ( ( ex != 0. )
+ && ( ex != 1. ) ) {
+ sp_css_attr_scale(css_set, 1/ex);
+ }
+ }
+
+ start_item = ascend_while_first(start_item, start_text_iter, common_ancestor);
+ end_item = ascend_while_first(end_item, end_text_iter, common_ancestor);
+ recursively_apply_style(common_ancestor, css_set, start_item, start_text_iter, end_item, end_text_iter, span_name_for_text_object(text));
+ sp_repr_css_attr_unref(css_set);
+
+ /* stage 2: cleanup the xml tree (of which there are multiple passes) */
+ /* discussion: this stage requires a certain level of inventiveness because
+ it's not clear what the best representation is in many cases. An ideal
+ implementation would provide some sort of scoring function to rate the
+ ugliness of a given xml tree and try to reduce said function, but providing
+ the various possibilities to be rated is non-trivial. Instead, I have opted
+ for a multi-pass technique which simply recognises known-ugly patterns and
+ has matching routines for optimising the patterns it finds. It's reasonably
+ easy to add new pattern matching processors. If everything gets disastrous
+ and neither option can be made to work, a fallback could be to reduce
+ everything to a single level of nesting and drop all pretense of
+ roundtrippability. */
+ bool has_text_decoration = false;
+ gchar const *root_style = (text)->getRepr()->attribute("style");
+ if(root_style && strstr(root_style,"text-decoration")) has_text_decoration = true;
+ while (tidy_xml_tree_recursively(common_ancestor, has_text_decoration)){};
+
+ // if we only modified subobjects this won't have been automatically sent
+ text->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+}
+
+bool is_part_of_text_subtree (SPObject const *obj)
+{
+ return (SP_IS_TSPAN(obj)
+ || SP_IS_TEXT(obj)
+ || SP_IS_FLOWTEXT(obj)
+ || SP_IS_FLOWTSPAN(obj)
+ || SP_IS_FLOWDIV(obj)
+ || SP_IS_FLOWPARA(obj)
+ || SP_IS_FLOWLINE(obj)
+ || SP_IS_FLOWREGIONBREAK(obj));
+}
+
+bool is_top_level_text_object (SPObject const *obj)
+{
+ return (SP_IS_TEXT(obj)
+ || SP_IS_FLOWTEXT(obj));
+}
+
+bool has_visible_text(SPObject const *obj)
+{
+ bool hasVisible = false;
+
+ if (SP_IS_STRING(obj) && !SP_STRING(obj)->string.empty()) {
+ hasVisible = true; // maybe we should also check that it's not all whitespace?
+ } else if (is_part_of_text_subtree(obj)) {
+ for (auto& child: obj->children) {
+ if (has_visible_text(&child)) {
+ hasVisible = true;
+ break;
+ }
+ }
+ }
+
+ return hasVisible;
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :