diff options
Diffstat (limited to '')
| -rw-r--r-- | src/style.cpp | 1797 |
1 files changed, 1797 insertions, 0 deletions
diff --git a/src/style.cpp b/src/style.cpp new file mode 100644 index 0000000..c74271e --- /dev/null +++ b/src/style.cpp @@ -0,0 +1,1797 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/** + * @file + * SVG stylesheets implementation. + */ +/* Authors: + * Lauris Kaplinski <lauris@kaplinski.com> + * Peter Moulder <pmoulder@mail.csse.monash.edu.au> + * bulia byak <buliabyak@users.sf.net> + * Abhishek Sharma + * Tavmjong Bah <tavmjong@free.fr> + * Kris De Gussem <Kris.DeGussem@gmail.com> + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * Copyright (C) 2001 Ximian, Inc. + * Copyright (C) 2005 Monash University + * Copyright (C) 2012 Kris De Gussem + * Copyright (C) 2014-2015 Tavmjong Bah + * + * Released under GNU GPL v2+, read the file 'COPYING' for more information. + */ + +#include "style.h" + +#include <cstring> +#include <string> +#include <algorithm> +#include <unordered_map> +#include <vector> + +#include <glibmm/regex.h> + +#include "attributes.h" +#include "bad-uri-exception.h" +#include "document.h" +#include "preferences.h" + +#include "3rdparty/libcroco/cr-sel-eng.h" + +#include "object/sp-paint-server.h" +#include "object/uri-references.h" +#include "object/uri.h" + +#include "svg/css-ostringstream.h" +#include "svg/svg.h" + +#include "util/units.h" + +#include "xml/croco-node-iface.h" +#include "xml/simple-document.h" + +#if !GLIB_CHECK_VERSION(2, 64, 0) +#define g_warning_once g_warning +#endif + +using Inkscape::CSSOStringStream; + +#define BMAX 8192 + +struct SPStyleEnum; + +int SPStyle::_count = 0; + +/*######################### +## FORWARD DECLARATIONS +#########################*/ +void sp_style_filter_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style); +void sp_style_fill_paint_server_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style); +void sp_style_stroke_paint_server_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style); + +static void sp_style_object_release(SPObject *object, SPStyle *style); +static CRSelEng *sp_repr_sel_eng(); + +/** + * Helper class for SPStyle property member lookup by SPAttr or + * by name, and for iterating over ordered members. + */ +class SPStylePropHelper { + SPStylePropHelper() { +#define REGISTER_PROPERTY(id, member, name) \ + g_assert(decltype(SPStyle::member)::static_id() == id); \ + _register(reinterpret_cast<SPIBasePtr>(&SPStyle::member), id) /* name unused */ + + // SVG 2: Attributes promoted to properties + REGISTER_PROPERTY(SPAttr::D, d, "d"); + + // 'color' must be before 'fill', 'stroke', 'text-decoration-color', ... + REGISTER_PROPERTY(SPAttr::COLOR, color, "color"); + + // 'font-size'/'font' must be before properties that need to know em, ex size (SPILength, + // SPILengthOrNormal) + REGISTER_PROPERTY(SPAttr::FONT_STYLE, font_style, "font-style"); + REGISTER_PROPERTY(SPAttr::FONT_VARIANT, font_variant, "font-variant"); + REGISTER_PROPERTY(SPAttr::FONT_WEIGHT, font_weight, "font-weight"); + REGISTER_PROPERTY(SPAttr::FONT_STRETCH, font_stretch, "font-stretch"); + REGISTER_PROPERTY(SPAttr::FONT_SIZE, font_size, "font-size"); + REGISTER_PROPERTY(SPAttr::LINE_HEIGHT, line_height, "line-height"); + REGISTER_PROPERTY(SPAttr::FONT_FAMILY, font_family, "font-family"); + REGISTER_PROPERTY(SPAttr::FONT, font, "font"); + REGISTER_PROPERTY(SPAttr::INKSCAPE_FONT_SPEC, font_specification, "-inkscape-font-specification"); + + // Font variants + REGISTER_PROPERTY(SPAttr::FONT_VARIANT_LIGATURES, font_variant_ligatures, "font-variant-ligatures"); + REGISTER_PROPERTY(SPAttr::FONT_VARIANT_POSITION, font_variant_position, "font-variant-position"); + REGISTER_PROPERTY(SPAttr::FONT_VARIANT_CAPS, font_variant_caps, "font-variant-caps"); + REGISTER_PROPERTY(SPAttr::FONT_VARIANT_NUMERIC, font_variant_numeric, "font-variant-numeric"); + REGISTER_PROPERTY(SPAttr::FONT_VARIANT_ALTERNATES, font_variant_alternates, "font-variant-alternates"); + REGISTER_PROPERTY(SPAttr::FONT_VARIANT_EAST_ASIAN, font_variant_east_asian, "font-variant-east-asian"); + REGISTER_PROPERTY(SPAttr::FONT_FEATURE_SETTINGS, font_feature_settings, "font-feature-settings"); + + // Variable Fonts + REGISTER_PROPERTY(SPAttr::FONT_VARIATION_SETTINGS, font_variation_settings, "font-variation-settings"); + + REGISTER_PROPERTY(SPAttr::TEXT_INDENT, text_indent, "text-indent"); + REGISTER_PROPERTY(SPAttr::TEXT_ALIGN, text_align, "text-align"); + + REGISTER_PROPERTY(SPAttr::TEXT_DECORATION, text_decoration, "text-decoration"); + REGISTER_PROPERTY(SPAttr::TEXT_DECORATION_LINE, text_decoration_line, "text-decoration-line"); + REGISTER_PROPERTY(SPAttr::TEXT_DECORATION_STYLE, text_decoration_style, "text-decoration-style"); + REGISTER_PROPERTY(SPAttr::TEXT_DECORATION_COLOR, text_decoration_color, "text-decoration-color"); + REGISTER_PROPERTY(SPAttr::TEXT_DECORATION_FILL, text_decoration_fill, "text-decoration-fill"); + REGISTER_PROPERTY(SPAttr::TEXT_DECORATION_STROKE, text_decoration_stroke, "text-decoration-stroke"); + + REGISTER_PROPERTY(SPAttr::LETTER_SPACING, letter_spacing, "letter-spacing"); + REGISTER_PROPERTY(SPAttr::WORD_SPACING, word_spacing, "word-spacing"); + REGISTER_PROPERTY(SPAttr::TEXT_TRANSFORM, text_transform, "text-transform"); + + REGISTER_PROPERTY(SPAttr::WRITING_MODE, writing_mode, "writing-mode"); + REGISTER_PROPERTY(SPAttr::DIRECTION, direction, "direction"); + REGISTER_PROPERTY(SPAttr::TEXT_ORIENTATION, text_orientation, "text-orientation"); + REGISTER_PROPERTY(SPAttr::DOMINANT_BASELINE, dominant_baseline, "dominant-baseline"); + REGISTER_PROPERTY(SPAttr::BASELINE_SHIFT, baseline_shift, "baseline-shift"); + REGISTER_PROPERTY(SPAttr::TEXT_ANCHOR, text_anchor, "text-anchor"); + REGISTER_PROPERTY(SPAttr::WHITE_SPACE, white_space, "white-space"); + + REGISTER_PROPERTY(SPAttr::SHAPE_INSIDE, shape_inside, "shape-inside"); + REGISTER_PROPERTY(SPAttr::SHAPE_SUBTRACT, shape_subtract, "shape-subtract"); + REGISTER_PROPERTY(SPAttr::SHAPE_PADDING, shape_padding, "shape-padding"); + REGISTER_PROPERTY(SPAttr::SHAPE_MARGIN, shape_margin, "shape-margin"); + REGISTER_PROPERTY(SPAttr::INLINE_SIZE, inline_size, "inline-size"); + + REGISTER_PROPERTY(SPAttr::CLIP_RULE, clip_rule, "clip-rule"); + REGISTER_PROPERTY(SPAttr::DISPLAY, display, "display"); + REGISTER_PROPERTY(SPAttr::OVERFLOW_, overflow, "overflow"); + REGISTER_PROPERTY(SPAttr::VISIBILITY, visibility, "visibility"); + REGISTER_PROPERTY(SPAttr::OPACITY, opacity, "opacity"); + + REGISTER_PROPERTY(SPAttr::ISOLATION, isolation, "isolation"); + REGISTER_PROPERTY(SPAttr::MIX_BLEND_MODE, mix_blend_mode, "mix-blend-mode"); + + REGISTER_PROPERTY(SPAttr::COLOR_INTERPOLATION, color_interpolation, "color-interpolation"); + REGISTER_PROPERTY(SPAttr::COLOR_INTERPOLATION_FILTERS, color_interpolation_filters, "color-interpolation-filters"); + + REGISTER_PROPERTY(SPAttr::SOLID_COLOR, solid_color, "solid-color"); + REGISTER_PROPERTY(SPAttr::SOLID_OPACITY, solid_opacity, "solid-opacity"); + + REGISTER_PROPERTY(SPAttr::VECTOR_EFFECT, vector_effect, "vector-effect"); + + REGISTER_PROPERTY(SPAttr::FILL, fill, "fill"); + REGISTER_PROPERTY(SPAttr::FILL_OPACITY, fill_opacity, "fill-opacity"); + REGISTER_PROPERTY(SPAttr::FILL_RULE, fill_rule, "fill-rule"); + + REGISTER_PROPERTY(SPAttr::STROKE, stroke, "stroke"); + REGISTER_PROPERTY(SPAttr::STROKE_WIDTH, stroke_width, "stroke-width"); + REGISTER_PROPERTY(SPAttr::STROKE_LINECAP, stroke_linecap, "stroke-linecap"); + REGISTER_PROPERTY(SPAttr::STROKE_LINEJOIN, stroke_linejoin, "stroke-linejoin"); + REGISTER_PROPERTY(SPAttr::STROKE_MITERLIMIT, stroke_miterlimit, "stroke-miterlimit"); + REGISTER_PROPERTY(SPAttr::STROKE_DASHARRAY, stroke_dasharray, "stroke-dasharray"); + REGISTER_PROPERTY(SPAttr::STROKE_DASHOFFSET, stroke_dashoffset, "stroke-dashoffset"); + REGISTER_PROPERTY(SPAttr::STROKE_OPACITY, stroke_opacity, "stroke-opacity"); + REGISTER_PROPERTY(SPAttr::STROKE_EXTENSIONS, stroke_extensions, "-inkscape-stroke"); + + REGISTER_PROPERTY(SPAttr::MARKER, marker, "marker"); + REGISTER_PROPERTY(SPAttr::MARKER_START, marker_start, "marker-start"); + REGISTER_PROPERTY(SPAttr::MARKER_MID, marker_mid, "marker-mid"); + REGISTER_PROPERTY(SPAttr::MARKER_END, marker_end, "marker-end"); + + REGISTER_PROPERTY(SPAttr::PAINT_ORDER, paint_order, "paint-order"); + + REGISTER_PROPERTY(SPAttr::FILTER, filter, "filter"); + + REGISTER_PROPERTY(SPAttr::COLOR_RENDERING, color_rendering, "color-rendering"); + REGISTER_PROPERTY(SPAttr::IMAGE_RENDERING, image_rendering, "image-rendering"); + REGISTER_PROPERTY(SPAttr::SHAPE_RENDERING, shape_rendering, "shape-rendering"); + REGISTER_PROPERTY(SPAttr::TEXT_RENDERING, text_rendering, "text-rendering"); + + REGISTER_PROPERTY(SPAttr::ENABLE_BACKGROUND, enable_background, "enable-background"); + + REGISTER_PROPERTY(SPAttr::STOP_COLOR, stop_color, "stop-color"); + REGISTER_PROPERTY(SPAttr::STOP_OPACITY, stop_opacity, "stop-opacity"); + } + + // this is a singleton, copy not allowed + SPStylePropHelper(SPStylePropHelper const&) = delete; +public: + + /** + * Singleton instance + */ + static SPStylePropHelper &instance() { + static SPStylePropHelper _instance; + return _instance; + } + + /** + * Get property pointer by enum + */ + SPIBase *get(SPStyle *style, SPAttr id) { + auto it = m_id_map.find(id); + if (it != m_id_map.end()) { + return _get(style, it->second); + } + return nullptr; + } + + /** + * Get property pointer by name + */ + SPIBase *get(SPStyle *style, const std::string &name) { + return get(style, sp_attribute_lookup(name.c_str())); + } + + /** + * Get a vector of property pointers + * \todo provide iterator instead + */ + std::vector<SPIBase *> get_vector(SPStyle *style) { + std::vector<SPIBase *> v; + v.reserve(m_vector.size()); + for (auto ptr : m_vector) { + v.push_back(_get(style, ptr)); + } + return v; + } + +private: + SPIBase *_get(SPStyle *style, SPIBasePtr ptr) { return &(style->*ptr); } + + void _register(SPIBasePtr ptr, SPAttr id) { + m_vector.push_back(ptr); + + if (id != SPAttr::INVALID) { + m_id_map[id] = ptr; + } + } + + std::unordered_map<SPAttr, SPIBasePtr> m_id_map; + std::vector<SPIBasePtr> m_vector; +}; + +auto &_prop_helper = SPStylePropHelper::instance(); + +// C++11 allows one constructor to call another... might be useful. The original C code +// had separate calls to create SPStyle, one with only SPDocument and the other with only +// SPObject as parameters. +SPStyle::SPStyle(SPDocument *document_in, SPObject *object_in) : + + // Unimplemented SVG 1.1: alignment-baseline, clip, clip-path, color-profile, cursor, + // dominant-baseline, flood-color, flood-opacity, font-size-adjust, + // glyph-orientation-horizontal, glyph-orientation-vertical, kerning, lighting-color, + // pointer-events, unicode-bidi + + // 'font', 'font-size', and 'font-family' must come first as other properties depend on them + // for calculated values (through 'em' and 'ex'). ('ex' is currently not read.) + // The following properties can depend on 'em' and 'ex': + // baseline-shift, kerning, letter-spacing, stroke-dash-offset, stroke-width, word-spacing, + // Non-SVG 1.1: text-indent, line-spacing + + // Hidden in SPIFontStyle: (to be refactored) + // font-family + // font-specification + + + // SVG 2 attributes promoted to properties. (When geometry properties are added, move after font.) + d( false), // SPIString Not inherited! + + // Font related properties and 'font' shorthand + font_style( SP_CSS_FONT_STYLE_NORMAL), + font_variant( SP_CSS_FONT_VARIANT_NORMAL), + font_weight( SP_CSS_FONT_WEIGHT_NORMAL), + font_stretch( SP_CSS_FONT_STRETCH_NORMAL), + font_size(), + line_height( 1.25 ), // SPILengthOrNormal + font_family( ), // SPIString w/default + font(), // SPIFont + font_specification( ), // SPIString + + // Font variants (Features) + font_variant_ligatures( ), + font_variant_position( SP_CSS_FONT_VARIANT_POSITION_NORMAL), + font_variant_caps( SP_CSS_FONT_VARIANT_CAPS_NORMAL), + font_variant_numeric( ), + font_variant_alternates(SP_CSS_FONT_VARIANT_ALTERNATES_NORMAL), + font_variant_east_asian(), + font_feature_settings( ), + + // Variable Fonts + font_variation_settings(), // SPIFontVariationSettings + + // Text related properties + text_indent( ), // SPILength + text_align( SP_CSS_TEXT_ALIGN_START), + + letter_spacing( ), // SPILengthOrNormal + word_spacing( ), // SPILengthOrNormal + text_transform( SP_CSS_TEXT_TRANSFORM_NONE), + + direction( SP_CSS_DIRECTION_LTR), + writing_mode( SP_CSS_WRITING_MODE_LR_TB), + text_orientation( SP_CSS_TEXT_ORIENTATION_MIXED), + dominant_baseline( SP_CSS_BASELINE_AUTO), + baseline_shift(), + text_anchor( SP_CSS_TEXT_ANCHOR_START), + white_space( SP_CSS_WHITE_SPACE_NORMAL), + + // SVG 2 Text Wrapping + shape_inside( ), // SPIString + shape_subtract( ), // SPIString + shape_padding( ), // SPILength for now + shape_margin( ), // SPILength for now + inline_size( ), // SPILength for now + + text_decoration(), + text_decoration_line(), + text_decoration_style(), + text_decoration_color( ), // SPIColor + text_decoration_fill( ), // SPIPaint + text_decoration_stroke( ), // SPIPaint + + // General visual properties + clip_rule( SP_WIND_RULE_NONZERO), + display( SP_CSS_DISPLAY_INLINE, false), + overflow( SP_CSS_OVERFLOW_VISIBLE, false), + visibility( SP_CSS_VISIBILITY_VISIBLE), + opacity( false), + + isolation( SP_CSS_ISOLATION_AUTO), + mix_blend_mode( SP_CSS_BLEND_NORMAL), + + paint_order(), // SPIPaintOrder + + // Color properties + color( ), // SPIColor + color_interpolation( SP_CSS_COLOR_INTERPOLATION_SRGB), + color_interpolation_filters(SP_CSS_COLOR_INTERPOLATION_LINEARRGB), + + // Solid color properties + solid_color( ), // SPIColor + solid_opacity( ), + + // Vector effects + vector_effect(), + + // Fill properties + fill( ), // SPIPaint + fill_opacity( ), + fill_rule( SP_WIND_RULE_NONZERO), + + // Stroke properties + stroke( ), // SPIPaint + stroke_width( 1.0), // SPILength + stroke_linecap( SP_STROKE_LINECAP_BUTT), + stroke_linejoin( SP_STROKE_LINEJOIN_MITER), + stroke_miterlimit( 4), // SPIFloat (only use of float!) + stroke_dasharray(), // SPIDashArray + stroke_dashoffset( ), // SPILength for now + + stroke_opacity( ), + + stroke_extensions( ), + + marker( ), // SPIString + marker_start( ), // SPIString + marker_mid( ), // SPIString + marker_end( ), // SPIString + + // Filter properties + filter(), + enable_background( SP_CSS_BACKGROUND_ACCUMULATE, false), + + // Rendering hint properties + color_rendering( SP_CSS_COLOR_RENDERING_AUTO), + image_rendering( SP_CSS_IMAGE_RENDERING_AUTO), + shape_rendering( SP_CSS_SHAPE_RENDERING_AUTO), + text_rendering( SP_CSS_TEXT_RENDERING_AUTO), + + // Stop color and opacity + stop_color( false), // SPIColor, does not inherit + stop_opacity( false) // Does not inherit +{ + // std::cout << "SPStyle::SPStyle( SPDocument ): Entrance: (" << _count << ")" << std::endl; + // std::cout << " Document: " << (document_in?"present":"null") << std::endl; + // std::cout << " Object: " + // << (object_in?(object_in->getId()?object_in->getId():"id null"):"object null") << std::endl; + + // static bool first = true; + // if( first ) { + // std::cout << "Size of SPStyle: " << sizeof(SPStyle) << std::endl; + // std::cout << " SPIBase: " << sizeof(SPIBase) << std::endl; + // std::cout << " SPIFloat: " << sizeof(SPIFloat) << std::endl; + // std::cout << " SPIScale24: " << sizeof(SPIScale24) << std::endl; + // std::cout << " SPILength: " << sizeof(SPILength) << std::endl; + // std::cout << " SPILengthOrNormal: " << sizeof(SPILengthOrNormal) << std::endl; + // std::cout << " SPIColor: " << sizeof(SPIColor) << std::endl; + // std::cout << " SPIPaint: " << sizeof(SPIPaint) << std::endl; + // std::cout << " SPITextDecorationLine" << sizeof(SPITextDecorationLine) << std::endl; + // std::cout << " Glib::ustring:" << sizeof(Glib::ustring) << std::endl; + // std::cout << " SPColor: " << sizeof(SPColor) << std::endl; + // first = false; + // } + + ++_count; // Poor man's memory leak detector + + _refcount = 1; + + cloned = false; + + object = object_in; + if( object ) { + g_assert( SP_IS_OBJECT(object) ); + document = object->document; + release_connection = + object->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_style_object_release), this)); + + cloned = object->cloned; + + } else { + document = document_in; + } + + // 'font' shorthand requires access to included properties. + font.setStylePointer( this ); + + // Properties that depend on 'font-size' for calculating lengths. + baseline_shift.setStylePointer( this ); + text_indent.setStylePointer( this ); + line_height.setStylePointer( this ); + letter_spacing.setStylePointer( this ); + word_spacing.setStylePointer( this ); + stroke_width.setStylePointer( this ); + stroke_dashoffset.setStylePointer( this ); + shape_padding.setStylePointer( this ); + shape_margin.setStylePointer( this ); + inline_size.setStylePointer( this ); + + // Properties that depend on 'color' + text_decoration_color.setStylePointer(this); + fill.setStylePointer(this); + stroke.setStylePointer(this); + color.setStylePointer(this); + stop_color.setStylePointer(this); + solid_color.setStylePointer(this); + + // 'text_decoration' shorthand requires access to included properties. + text_decoration.setStylePointer( this ); + + // SPIPaint, SPIFilter needs access to 'this' (SPStyle) + // for setting up signals... 'fill', 'stroke' already done + filter.setStylePointer( this ); + shape_inside.setStylePointer( this ); + shape_subtract.setStylePointer( this ); + + // Used to iterate over markers + marker_ptrs[SP_MARKER_LOC] = ▮ + marker_ptrs[SP_MARKER_LOC_START] = &marker_start; + marker_ptrs[SP_MARKER_LOC_MID] = &marker_mid; + marker_ptrs[SP_MARKER_LOC_END] = &marker_end; + + + // This might be too resource hungary... but for now it possible to loop over properties + _properties = _prop_helper.get_vector(this); +} + +SPStyle::~SPStyle() { + + // std::cout << "SPStyle::~SPStyle" << std::endl; + --_count; // Poor man's memory leak detector. + + // Remove connections + release_connection.disconnect(); + fill_ps_changed_connection.disconnect(); + stroke_ps_changed_connection.disconnect(); + filter_changed_connection.disconnect(); + + // The following should be moved into SPIPaint and SPIFilter + if (fill.value.href) { + fill_ps_modified_connection.disconnect(); + } + + if (stroke.value.href) { + stroke_ps_modified_connection.disconnect(); + } + + if (filter.href) { + filter_modified_connection.disconnect(); + } + + // Conjecture: all this SPStyle ref counting is not needed. SPObject creates an instance of + // SPStyle when it is constructed and deletes it when it is destructed. The refcount is + // incremented and decremented only in the files: display/drawing-item.cpp, + // display/nr-filter-primitive.cpp, and libnrtype/Layout-TNG-Input.cpp. + if( _refcount > 1 ) { + std::cerr << "SPStyle::~SPStyle: ref count greater than 1! " << _refcount << std::endl; + } + // std::cout << "SPStyle::~SPStyle(): Exit\n" << std::endl; +} + +const std::vector<SPIBase *> SPStyle::properties() { return this->_properties; } + +void +SPStyle::clear(SPAttr id) { + SPIBase *p = _prop_helper.get(this, id); + if (p) { + p->clear(); + } else { + g_warning("Unimplemented style property %d", (int)id); + } +} + +void +SPStyle::clear() { + for (auto * p : _properties) { + p->clear(); + } + + // Release connection to object, created in constructor. + release_connection.disconnect(); + + // href->detach() called in fill->clear()... + fill_ps_modified_connection.disconnect(); + if (fill.value.href) { + delete fill.value.href; + fill.value.href = nullptr; + } + stroke_ps_modified_connection.disconnect(); + if (stroke.value.href) { + delete stroke.value.href; + stroke.value.href = nullptr; + } + filter_modified_connection.disconnect(); + if (filter.href) { + delete filter.href; + filter.href = nullptr; + } + + if (document) { + filter.href = new SPFilterReference(document); + filter_changed_connection = filter.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_filter_ref_changed), this)); + + fill.value.href = new SPPaintServerReference(document); + fill_ps_changed_connection = fill.value.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_fill_paint_server_ref_changed), this)); + + stroke.value.href = new SPPaintServerReference(document); + stroke_ps_changed_connection = stroke.value.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_stroke_paint_server_ref_changed), this)); + } + + cloned = false; + +} + +// Matches void sp_style_read(SPStyle *style, SPObject *object, Inkscape::XML::Node *repr) +void +SPStyle::read( SPObject *object, Inkscape::XML::Node *repr ) { + + // std::cout << "SPStyle::read( SPObject, Inkscape::XML::Node ): Entrance: " + // << (object?(object->getId()?object->getId():"id null"):"object null") << " " + // << (repr?(repr->name()?repr->name():"no name"):"repr null") + // << std::endl; + g_assert(repr != nullptr); + g_assert(!object || (object->getRepr() == repr)); + + // // Uncomment to verify that we don't need to call clear. + // std::cout << " Creating temp style for testing" << std::endl; + // SPStyle *temp = new SPStyle(); + // if( !(*temp == *this ) ) std::cout << "SPStyle::read: Need to clear" << std::endl; + // delete temp; + + clear(); // FIXME, If this isn't here, EVERYTHING stops working! Why? + + if (object && object->cloned) { + cloned = true; + } + + /* 1. Style attribute */ + // std::cout << " MERGING STYLE ATTRIBUTE" << std::endl; + gchar const *val = repr->attribute("style"); + if( val != nullptr && *val ) { + _mergeString( val ); + } + + /* 2 Style sheet */ + if (object) { + _mergeObjectStylesheet( object ); + } + + /* 3 Presentation attributes */ + for (auto * p : _properties) { + // Shorthands are not allowed as presentation properties. Note: text-decoration and + // font-variant are converted to shorthands in CSS 3 but can still be read as a + // non-shorthand for compatibility with older renders, so they should not be in this list. + if (p->id() != SPAttr::FONT && p->id() != SPAttr::MARKER) { + p->readAttribute( repr ); + } + } + + /* 4 Cascade from parent */ + if( object ) { + if( object->parent ) { + cascade( object->parent->style ); + } + } else if( repr->parent() ) { // When does this happen? + // std::cout << "SPStyle::read(): reading via repr->parent()" << std::endl; + SPStyle *parent = new SPStyle(); + parent->read( nullptr, repr->parent() ); + cascade( parent ); + delete parent; + } +} + +/** + * Read style properties from object's repr. + * + * 1. Reset existing object style + * 2. Load current effective object style + * 3. Load i attributes from immediate parent (which has to be up-to-date) + */ +void +SPStyle::readFromObject( SPObject *object ) { + + // std::cout << "SPStyle::readFromObject: "<< (object->getId()?object->getId():"null") << std::endl; + + g_return_if_fail(object != nullptr); + g_return_if_fail(SP_IS_OBJECT(object)); + + Inkscape::XML::Node *repr = object->getRepr(); + g_return_if_fail(repr != nullptr); + + read( object, repr ); +} + +/** + * Read style properties from preferences. + * @param path Preferences directory from which the style should be read + */ +void +SPStyle::readFromPrefs(Glib::ustring const &path) { + + g_return_if_fail(!path.empty()); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + // not optimal: we reconstruct the node based on the prefs, then pass it to + // sp_style_read for actual processing. + Inkscape::XML::SimpleDocument *tempdoc = new Inkscape::XML::SimpleDocument; + Inkscape::XML::Node *tempnode = tempdoc->createElement("prefs"); + + std::vector<Inkscape::Preferences::Entry> attrs = prefs->getAllEntries(path); + for (auto & attr : attrs) { + tempnode->setAttribute(attr.getEntryName(), attr.getString()); + } + + read( nullptr, tempnode ); + + Inkscape::GC::release(tempnode); + Inkscape::GC::release(tempdoc); + delete tempdoc; +} + +// Matches sp_style_merge_property(SPStyle *style, gint id, gchar const *val) +void +SPStyle::readIfUnset(SPAttr id, gchar const *val, SPStyleSrc const &source ) { + + // std::cout << "SPStyle::readIfUnset: Entrance: " << sp_attribute_name(id) << ": " << (val?val:"null") << std::endl; + // To Do: If it is not too slow, use std::map instead of std::vector inorder to remove switch() + // (looking up SPAttr::xxxx already uses a hash). + g_return_if_fail(val != nullptr); + + switch (id) { + /* SVG */ + /* Clip/Mask */ + case SPAttr::CLIP_PATH: + /** \todo + * This is a workaround. Inkscape only supports 'clip-path' as SVG attribute, not as + * style property. By having both CSS and SVG attribute set, editing of clip-path + * will fail, since CSS always overwrites SVG attributes. + * Fixes Bug #324849 + */ + g_warning_once("attribute 'clip-path' given as CSS"); + + //XML Tree being directly used here. + if (object) { + object->setAttribute("clip-path", val); + } + return; + case SPAttr::MASK: + /** \todo + * See comment for SPAttr::CLIP_PATH + */ + g_warning_once("attribute 'mask' given as CSS"); + + //XML Tree being directly used here. + if (object) { + object->setAttribute("mask", val); + } + return; + case SPAttr::FILTER: + if( !filter.inherit ) filter.readIfUnset( val, source ); + return; + case SPAttr::COLOR_INTERPOLATION: + // We read it but issue warning + color_interpolation.readIfUnset( val, source ); + if( color_interpolation.value != SP_CSS_COLOR_INTERPOLATION_SRGB ) { + g_warning("Inkscape currently only supports color-interpolation = sRGB"); + } + return; + } + + auto p = _prop_helper.get(this, id); + if (p) { + p->readIfUnset(val, source); + } else { + g_warning("Unimplemented style property %d", (int)id); + } +} + +// return if is seted property +bool SPStyle::isSet(SPAttr id) +{ + bool set = false; + switch (id) { + case SPAttr::CLIP_PATH: + return set; + case SPAttr::MASK: + return set; + case SPAttr::FILTER: + if (!filter.inherit) + set = filter.set; + return set; + case SPAttr::COLOR_INTERPOLATION: + // We read it but issue warning + return color_interpolation.set; + } + + auto p = _prop_helper.get(this, id); + if (p) { + return p->set; + } else { + g_warning("Unimplemented style property %d", (int)id); + return set; + } +} + +/** + * Outputs the style to a CSS string. + * + * Use with SP_STYLE_FLAG_ALWAYS for copying an object's complete cascaded style to + * style_clipboard. + * + * Use with SP_STYLE_FLAG_IFDIFF and a pointer to the parent class when you need a CSS string for + * an object in the document tree. + * + * \pre flags in {IFSET, ALWAYS, IFDIFF}. + * \pre base. + * \post ret != NULL. + */ +Glib::ustring +SPStyle::write( guint const flags, SPStyleSrc const style_src_req, SPStyle const *const base ) const { + + // std::cout << "SPStyle::write: flags: " << flags << std::endl; + + // If not excluding this case, we'd end up writing all non-inheritable properties. + // Can happen when adding fallback <tspan>s to text like this: + // <text style="shape-inside:url(#x)">Hello</text> + if (base == this) { + assert((flags & SP_STYLE_FLAG_IFDIFF) && !(flags & SP_STYLE_FLAG_ALWAYS)); + return {}; + } + + Glib::ustring style_string; + for(std::vector<SPIBase*>::size_type i = 0; i != _properties.size(); ++i) { + if( base != nullptr ) { + style_string += _properties[i]->write( flags, style_src_req, base->_properties[i] ); + } else { + style_string += _properties[i]->write( flags, style_src_req, nullptr ); + } + } + + // Extended properties. Cascading not supported. + for (auto const &pair : extended_properties) { + // std::cout << "extended property: " << pair.first << " = " << pair.second << std::endl; + style_string += pair.first + ":" + pair.second + ";"; + } + + // Remove trailing ';' + if( style_string.size() > 0 ) { + style_string.erase( style_string.size() - 1 ); + } + return style_string; +} +/** + * Get CSS string for set properties, or with SP_STYLE_FLAG_ALWAYS, for all properties. + */ +Glib::ustring SPStyle::write(unsigned int flags) const +{ + assert(flags & (SP_STYLE_FLAG_IFSET | SP_STYLE_FLAG_ALWAYS)); + return write(flags, SPStyleSrc::UNSET); +} +/** + * Get CSS string for set properties from the requested source + */ +Glib::ustring SPStyle::write(SPStyleSrc style_src_req) const +{ + assert(style_src_req != SPStyleSrc::UNSET); + return write(SP_STYLE_FLAG_IFSRC | SP_STYLE_FLAG_IFSET, style_src_req); +} +/** + * Get CSS string for set properties which are different from the given + * base style. If base is NULL, all set flags are considered different. + */ +Glib::ustring SPStyle::writeIfDiff(SPStyle const *base) const +{ + return write(SP_STYLE_FLAG_IFDIFF, SPStyleSrc::UNSET, base); +} + +// Corresponds to sp_style_merge_from_parent() +/** + * Sets computed values in \a style, which may involve inheriting from (or in some other way + * calculating from) corresponding computed values of \a parent. + * + * References: http://www.w3.org/TR/SVG11/propidx.html shows what properties inherit by default. + * http://www.w3.org/TR/SVG11/styling.html#Inheritance gives general rules as to what it means to + * inherit a value. http://www.w3.org/TR/REC-CSS2/cascade.html#computed-value is more precise + * about what the computed value is (not obvious for lengths). + * + * \pre \a parent's computed values are already up-to-date. + */ +void +SPStyle::cascade( SPStyle const *const parent ) { + // std::cout << "SPStyle::cascade: " << (object->getId()?object->getId():"null") << std::endl; + for(std::vector<SPIBase*>::size_type i = 0; i != _properties.size(); ++i) { + _properties[i]->cascade( parent->_properties[i] ); + } +} + +// Corresponds to sp_style_merge_from_dying_parent() +/** + * Combine \a style and \a parent style specifications into a single style specification that + * preserves (as much as possible) the effect of the existing \a style being a child of \a parent. + * + * Called when the parent repr is to be removed (e.g. the parent is a \<use\> element that is being + * unlinked), in which case we copy/adapt property values that are explicitly set in \a parent, + * trying to retain the same visual appearance once the parent is removed. Interesting cases are + * when there is unusual interaction with the parent's value (opacity, display) or when the value + * can be specified as relative to the parent computed value (font-size, font-weight etc.). + * + * Doesn't update computed values of \a style. For correctness, you should subsequently call + * sp_style_merge_from_parent against the new parent (presumably \a parent's parent) even if \a + * style was previously up-to-date wrt \a parent. + * + * \pre \a parent's computed values are already up-to-date. + * (\a style's computed values needn't be up-to-date.) + */ +void +SPStyle::merge( SPStyle const *const parent ) { + // std::cout << "SPStyle::merge" << std::endl; + for(std::vector<SPIBase*>::size_type i = 0; i != _properties.size(); ++i) { + _properties[i]->merge( parent->_properties[i] ); + } +} + +/** + * Parses a style="..." string and merges it with an existing SPStyle. + */ +void +SPStyle::mergeString( gchar const *const p ) { + _mergeString( p ); +} + +/** + * Append an existing css statement into this style, used in css editing + * always appends declarations as STYLE_SHEET properties. + */ +void +SPStyle::mergeStatement( CRStatement *statement ) { + if (statement->type != RULESET_STMT) { + return; + } + CRDeclaration *decl_list = nullptr; + cr_statement_ruleset_get_declarations (statement, &decl_list); + if (decl_list) { + _mergeDeclList(decl_list, SPStyleSrc::STYLE_SHEET); + } +} + +// Mostly for unit testing +bool +SPStyle::operator==(const SPStyle& rhs) { + + // Uncomment for testing + // for(std::vector<SPIBase*>::size_type i = 0; i != _properties.size(); ++i) { + // if( *_properties[i] != *rhs._properties[i]) + // std::cout << _properties[i]->name << ": " + // << _properties[i]->write(SP_STYLE_FLAG_ALWAYS,NULL) << " " + // << rhs._properties[i]->write(SP_STYLE_FLAG_ALWAYS,NULL) + // << (*_properties[i] == *rhs._properties[i]) << std::endl; + // } + + for(std::vector<SPIBase*>::size_type i = 0; i != _properties.size(); ++i) { + if( *_properties[i] != *rhs._properties[i]) return false; + } + return true; +} + +void +SPStyle::_mergeString( gchar const *const p ) { + + // std::cout << "SPStyle::_mergeString: " << (p?p:"null") << std::endl; + CRDeclaration *const decl_list + = cr_declaration_parse_list_from_buf(reinterpret_cast<guchar const *>(p), CR_UTF_8); + if (decl_list) { + _mergeDeclList( decl_list, SPStyleSrc::STYLE_PROP ); + cr_declaration_destroy(decl_list); + } +} + +void +SPStyle::_mergeDeclList( CRDeclaration const *const decl_list, SPStyleSrc const &source ) { + + // std::cout << "SPStyle::_mergeDeclList" << std::endl; + + // In reverse order, as later declarations to take precedence over earlier ones. + // (Properties are only set if not previously set. See: + // Ref: http://www.w3.org/TR/REC-CSS2/cascade.html#cascading-order point 4.) + if (decl_list->next) { + _mergeDeclList( decl_list->next, source ); + } + _mergeDecl( decl_list, source ); +} + +void +SPStyle::_mergeDecl( CRDeclaration const *const decl, SPStyleSrc const &source ) { + + // std::cout << "SPStyle::_mergeDecl" << std::endl; + + auto prop_idx = sp_attribute_lookup(decl->property->stryng->str); + if (prop_idx != SPAttr::INVALID) { + /** \todo + * effic: Test whether the property is already set before trying to + * convert to string. Alternatively, set from CRTerm directly rather + * than converting to string. + */ + if (!isSet(prop_idx) || decl->important) { + guchar *const str_value_unsigned = cr_term_to_string(decl->value); + gchar *const str_value = reinterpret_cast<gchar *>(str_value_unsigned); + + // Add "!important" rule if necessary as this is not handled by cr_term_to_string(). + gchar const *important = decl->important ? " !important" : ""; + Inkscape::CSSOStringStream os; + os << str_value << important; + + readIfUnset(prop_idx, os.str().c_str(), source); + g_free(str_value); + } + } else { + gchar const *key = decl->property->stryng->str; + auto value = reinterpret_cast<gchar *>(cr_term_to_string(decl->value)); + + if (g_str_has_prefix(key, "--")) { + g_warning("Ignoring CSS variable: %s", key); + } else if (g_str_has_prefix(key, "-")) { + extended_properties[key] = value; + } else { + g_warning("Ignoring unrecognized CSS property: %s", key); + } + + g_free(value); + } +} + +void +SPStyle::_mergeProps( CRPropList *const props ) { + + // std::cout << "SPStyle::_mergeProps" << std::endl; + + // In reverse order, as later declarations to take precedence over earlier ones. + if (props) { + _mergeProps( cr_prop_list_get_next( props ) ); + CRDeclaration *decl = nullptr; + cr_prop_list_get_decl(props, &decl); + _mergeDecl( decl, SPStyleSrc::STYLE_SHEET ); + } +} + +void +SPStyle::_mergeObjectStylesheet( SPObject const *const object ) { + + // std::cout << "SPStyle::_mergeObjectStylesheet: " << (object->getId()?object->getId():"null") << std::endl; + + _mergeObjectStylesheet(object, object->document); +} + +void +SPStyle::_mergeObjectStylesheet( SPObject const *const object, SPDocument *const document ) { + + static CRSelEng *sel_eng = sp_repr_sel_eng(); + + if (auto *const parent = document->getParent()) { + _mergeObjectStylesheet(object, parent); + } else if (auto *const parent = document->get_reference_document()) { + _mergeObjectStylesheet(object, parent); + } + + CRPropList *props = nullptr; + + //XML Tree being directly used here while it shouldn't be. + CRStatus status = + cr_sel_eng_get_matched_properties_from_cascade(sel_eng, + document->getStyleCascade(), + object->getRepr(), + &props); + g_return_if_fail(status == CR_OK); + /// \todo Check what errors can occur, and handle them properly. + if (props) { + _mergeProps(props); + cr_prop_list_destroy(props); + } +} + +// Used for input into Pango. Must be computed value! +std::string +SPStyle::getFontFeatureString() { + + std::string feature_string; + if ( !(font_variant_ligatures.computed & SP_CSS_FONT_VARIANT_LIGATURES_COMMON) ) + feature_string += "liga 0, clig 0, "; + if ( font_variant_ligatures.computed & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ) + feature_string += "dlig, "; + if ( font_variant_ligatures.computed & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ) + feature_string += "hlig, "; + if ( !(font_variant_ligatures.computed & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL) ) + feature_string += "calt 0, "; + + switch (font_variant_position.computed) { + case SP_CSS_FONT_VARIANT_POSITION_SUB: + feature_string += "subs, "; + break; + case SP_CSS_FONT_VARIANT_POSITION_SUPER: + feature_string += "sups, "; + } + + switch (font_variant_caps.computed) { + case SP_CSS_FONT_VARIANT_CAPS_SMALL: + feature_string += "smcp, "; + break; + case SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL: + feature_string += "smcp, c2sc, "; + break; + case SP_CSS_FONT_VARIANT_CAPS_PETITE: + feature_string += "pcap, "; + break; + case SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE: + feature_string += "pcap, c2pc, "; + break; + case SP_CSS_FONT_VARIANT_CAPS_UNICASE: + feature_string += "unic, "; + break; + case SP_CSS_FONT_VARIANT_CAPS_TITLING: + feature_string += "titl, "; + } + + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS ) + feature_string += "lnum, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS ) + feature_string += "onum, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS ) + feature_string += "pnum, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS ) + feature_string += "tnum, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS ) + feature_string += "frac, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS ) + feature_string += "afrc, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_ORDINAL ) + feature_string += "ordn, "; + if ( font_variant_numeric.computed & SP_CSS_FONT_VARIANT_NUMERIC_SLASHED_ZERO ) + feature_string += "zero, "; + + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS78 ) + feature_string += "jp78, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS83 ) + feature_string += "jp83, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS90 ) + feature_string += "jp90, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS04 ) + feature_string += "jp04, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_SIMPLIFIED ) + feature_string += "smpl, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_TRADITIONAL ) + feature_string += "trad, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_FULL_WIDTH ) + feature_string += "fwid, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_PROPORTIONAL_WIDTH ) + feature_string += "pwid, "; + if( font_variant_east_asian.computed & SP_CSS_FONT_VARIANT_EAST_ASIAN_RUBY ) + feature_string += "ruby, "; + + char const *val = font_feature_settings.value(); + if (val[0] && strcmp(val, "normal")) { + // We do no sanity checking... + feature_string += val; + feature_string += ", "; + } + + if (feature_string.empty()) { + feature_string = "normal"; + } else { + // Remove last ", " + feature_string.resize(feature_string.size() - 2); + } + + return feature_string; +} + + +// Internal +/** + * Release callback. + */ +static void +sp_style_object_release(SPObject *object, SPStyle *style) +{ + (void)object; // TODO + style->object = nullptr; +} + +// Internal +/** + * Emit style modified signal on style's object if the filter changed. + */ +static void +sp_style_filter_ref_modified(SPObject *obj, guint flags, SPStyle *style) +{ + (void)flags; // TODO + SPFilter *filter=static_cast<SPFilter *>(obj); + if (style->getFilter() == filter) + { + if (style->object) { + style->object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG); + } + } +} + +// Internal +/** + * Gets called when the filter is (re)attached to the style + */ +void +sp_style_filter_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style) +{ + if (old_ref) { + (dynamic_cast<SPFilter *>( old_ref ))->_refcount--; + style->filter_modified_connection.disconnect(); + } + if ( SP_IS_FILTER(ref)) + { + (dynamic_cast<SPFilter *>( ref ))->_refcount++; + style->filter_modified_connection = + ref->connectModified(sigc::bind(sigc::ptr_fun(&sp_style_filter_ref_modified), style)); + } + + sp_style_filter_ref_modified(ref, 0, style); +} + +/** + * Emit style modified signal on style's object if server is style's fill + * or stroke paint server. + */ +static void +sp_style_paint_server_ref_modified(SPObject *obj, guint flags, SPStyle *style) +{ + (void)flags; // TODO + SPPaintServer *server = static_cast<SPPaintServer *>(obj); + + if ((style->fill.isPaintserver()) + && style->getFillPaintServer() == server) + { + if (style->object) { + /** \todo + * fixme: I do not know, whether it is optimal - we are + * forcing reread of everything (Lauris) + */ + /** \todo + * fixme: We have to use object_modified flag, because parent + * flag is only available downstreams. + */ + style->object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG); + } + } else if ((style->stroke.isPaintserver()) + && style->getStrokePaintServer() == server) + { + if (style->object) { + /// \todo fixme: + style->object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG); + } + } else if (server) { + g_assert_not_reached(); + } +} + +/** + * Gets called when the paintserver is (re)attached to the style + */ +void +sp_style_fill_paint_server_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style) +{ + if (old_ref) { + style->fill_ps_modified_connection.disconnect(); + } + if (SP_IS_PAINT_SERVER(ref)) { + style->fill_ps_modified_connection = + ref->connectModified(sigc::bind(sigc::ptr_fun(&sp_style_paint_server_ref_modified), style)); + } + + style->signal_fill_ps_changed.emit(old_ref, ref); + sp_style_paint_server_ref_modified(ref, 0, style); +} + +/** + * Gets called when the paintserver is (re)attached to the style + */ +void +sp_style_stroke_paint_server_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style) +{ + if (old_ref) { + style->stroke_ps_modified_connection.disconnect(); + } + if (SP_IS_PAINT_SERVER(ref)) { + style->stroke_ps_modified_connection = + ref->connectModified(sigc::bind(sigc::ptr_fun(&sp_style_paint_server_ref_modified), style)); + } + + style->signal_stroke_ps_changed.emit(old_ref, ref); + sp_style_paint_server_ref_modified(ref, 0, style); +} + +// Called in display/drawing-item.cpp, display/nr-filter-primitive.cpp, libnrtype/Layout-TNG-Input.cpp +/** + * Increase refcount of style. + */ +SPStyle * +sp_style_ref(SPStyle *style) +{ + g_return_val_if_fail(style != nullptr, NULL); + + style->style_ref(); // Increase ref count + + return style; +} + +// Called in display/drawing-item.cpp, display/nr-filter-primitive.cpp, libnrtype/Layout-TNG-Input.cpp +/** + * Decrease refcount of style with possible destruction. + */ +SPStyle * +sp_style_unref(SPStyle *style) +{ + g_return_val_if_fail(style != nullptr, NULL); + if (style->style_unref() < 1) { + delete style; + return nullptr; + } + return style; +} + +static CRSelEng * +sp_repr_sel_eng() +{ + CRSelEng *const ret = cr_sel_eng_new(&Inkscape::XML::croco_node_iface); + + /** \todo + * Check whether we need to register any pseudo-class handlers. + * libcroco has its own default handlers for first-child and lang. + * + * We probably want handlers for link and arguably visited (though + * inkscape can't visit links at the time of writing). hover etc. + * more useful in inkview than the editor inkscape. + * + * http://www.w3.org/TR/SVG11/styling.html#StylingWithCSS says that + * the following should be honoured, at least by inkview: + * :hover, :active, :focus, :visited, :link. + */ + + g_assert(ret); + return ret; +} + +// The following functions should be incorporated into SPIPaint. FIXME +// Called in: style.cpp, style-internal.cpp +void +sp_style_set_ipaint_to_uri(SPStyle *style, SPIPaint *paint, const Inkscape::URI *uri, SPDocument *document) +{ + if (!paint->value.href) { + + if (style->object) { + // Should not happen as href should have been created in SPIPaint. (TODO: Removed code duplication.) + paint->value.href = new SPPaintServerReference(style->object); + + } else if (document) { + // Used by desktop style (no object to attach to!). + paint->value.href = new SPPaintServerReference(document); + + } else { + std::cerr << "sp_style_set_ipaint_to_uri: No valid object or document!" << std::endl; + return; + } + + if (paint == &style->fill) { + style->fill_ps_changed_connection = paint->value.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_fill_paint_server_ref_changed), style)); + } else { + style->stroke_ps_changed_connection = paint->value.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_stroke_paint_server_ref_changed), style)); + } + } + + if (paint->value.href){ + if (paint->value.href->getObject()){ + paint->value.href->detach(); + } + + try { + paint->value.href->attach(*uri); + } catch (Inkscape::BadURIException &e) { + g_warning("%s", e.what()); + paint->value.href->detach(); + } + } +} + +// Called in: style.cpp, style-internal.cpp +void +sp_style_set_ipaint_to_uri_string (SPStyle *style, SPIPaint *paint, const gchar *uri) +{ + try { + const Inkscape::URI IURI(uri); + sp_style_set_ipaint_to_uri(style, paint, &IURI, style->document); + } catch (...) { + g_warning("URI failed to parse: %s", uri); + } +} + +// Called in: desktop-style.cpp +void sp_style_set_to_uri(SPStyle *style, bool isfill, Inkscape::URI const *uri) +{ + sp_style_set_ipaint_to_uri(style, style->getFillOrStroke(isfill), uri, style->document); +} + +// Called in: widgets/font-selector.cpp, widgets/text-toolbar.cpp, ui/dialog/text-edit.cpp +gchar const * +sp_style_get_css_unit_string(int unit) +{ + // specify px by default, see inkscape bug 1221626, mozilla bug 234789 + // This is a problematic fix as some properties (e.g. 'line-height') have + // different behaviour if there is no unit. + switch (unit) { + + case SP_CSS_UNIT_NONE: return "px"; + case SP_CSS_UNIT_PX: return "px"; + case SP_CSS_UNIT_PT: return "pt"; + case SP_CSS_UNIT_PC: return "pc"; + case SP_CSS_UNIT_MM: return "mm"; + case SP_CSS_UNIT_CM: return "cm"; + case SP_CSS_UNIT_IN: return "in"; + case SP_CSS_UNIT_EM: return "em"; + case SP_CSS_UNIT_EX: return "ex"; + case SP_CSS_UNIT_PERCENT: return "%"; + default: return "px"; + } + return "px"; +} + +// Called in: style-internal.cpp, widgets/text-toolbar.cpp, ui/dialog/text-edit.cpp +/* + * Convert a size in pixels into another CSS unit size + */ +double +sp_style_css_size_px_to_units(double size, int unit, double font_size) +{ + double unit_size = size; + + if (font_size == 0) { + g_warning("sp_style_get_css_font_size_units: passed in zero font_size"); + font_size = SP_CSS_FONT_SIZE_DEFAULT; + } + + switch (unit) { + + case SP_CSS_UNIT_NONE: unit_size = size; break; + case SP_CSS_UNIT_PX: unit_size = size; break; + case SP_CSS_UNIT_PT: unit_size = Inkscape::Util::Quantity::convert(size, "px", "pt"); break; + case SP_CSS_UNIT_PC: unit_size = Inkscape::Util::Quantity::convert(size, "px", "pc"); break; + case SP_CSS_UNIT_MM: unit_size = Inkscape::Util::Quantity::convert(size, "px", "mm"); break; + case SP_CSS_UNIT_CM: unit_size = Inkscape::Util::Quantity::convert(size, "px", "cm"); break; + case SP_CSS_UNIT_IN: unit_size = Inkscape::Util::Quantity::convert(size, "px", "in"); break; + case SP_CSS_UNIT_EM: unit_size = size / font_size; break; + case SP_CSS_UNIT_EX: unit_size = size * 2.0 / font_size ; break; + case SP_CSS_UNIT_PERCENT: unit_size = size * 100.0 / font_size; break; + + default: + g_warning("sp_style_get_css_font_size_units conversion to %d not implemented.", unit); + break; + } + + return unit_size; +} + +// Called in: widgets/text-toolbar.cpp, ui/dialog/text-edit.cpp +/* + * Convert a size in a CSS unit size to pixels + */ +double +sp_style_css_size_units_to_px(double size, int unit, double font_size) +{ + if (unit == SP_CSS_UNIT_PX) { + return size; + } + //g_message("sp_style_css_size_units_to_px %f %d = %f px", size, unit, out); + return size * (size / sp_style_css_size_px_to_units(size, unit, font_size));; +} + + +// FIXME: Everything below this line belongs in a different file - css-chemistry? + +void +sp_style_set_property_url (SPObject *item, gchar const *property, SPObject *linked, bool recursive) +{ + Inkscape::XML::Node *repr = item->getRepr(); + + if (repr == nullptr) return; + + SPCSSAttr *css = sp_repr_css_attr_new(); + if (linked) { + gchar *val = g_strdup_printf("url(#%s)", linked->getId()); + sp_repr_css_set_property(css, property, val); + g_free(val); + } else { + sp_repr_css_unset_property(css, "filter"); + } + + if (recursive) { + sp_repr_css_change_recursive(repr, css, "style"); + } else { + sp_repr_css_change(repr, css, "style"); + } + sp_repr_css_attr_unref(css); +} + +/** + * \pre style != NULL. + * \pre flags in {IFSET, ALWAYS}. + * Only used by sp_css_attr_from_object() and in splivarot.cpp - sp_item_path_outline(). + */ +SPCSSAttr * +sp_css_attr_from_style(SPStyle const *const style, guint const flags) +{ + g_return_val_if_fail(style != nullptr, NULL); + g_return_val_if_fail(((flags & SP_STYLE_FLAG_IFSET) || + (flags & SP_STYLE_FLAG_ALWAYS)), + NULL); + Glib::ustring style_str = style->write(flags); + SPCSSAttr *css = sp_repr_css_attr_new(); + sp_repr_css_attr_add_from_string(css, style_str.c_str()); + return css; +} + +// Called in: selection-chemistry.cpp, widgets/stroke-marker-selector.cpp, widgets/stroke-style.cpp, +// ui/tools/freehand-base.cpp +/** + * \pre object != NULL + * \pre flags in {IFSET, ALWAYS}. + */ +SPCSSAttr *sp_css_attr_from_object(SPObject *object, guint const flags) +{ + g_return_val_if_fail(((flags == SP_STYLE_FLAG_IFSET) || + (flags == SP_STYLE_FLAG_ALWAYS) ), + NULL); + SPCSSAttr * result = nullptr; + if (object->style) { + result = sp_css_attr_from_style(object->style, flags); + } + return result; +} + +// Called in: selection-chemistry.cpp, ui/dialog/inkscape-preferences.cpp +/** + * Unset any text-related properties + */ +SPCSSAttr * +sp_css_attr_unset_text(SPCSSAttr *css) +{ + sp_repr_css_set_property(css, "font", nullptr); + sp_repr_css_set_property(css, "-inkscape-font-specification", nullptr); + sp_repr_css_set_property(css, "font-size", nullptr); + sp_repr_css_set_property(css, "font-size-adjust", nullptr); // not implemented yet + sp_repr_css_set_property(css, "font-style", nullptr); + sp_repr_css_set_property(css, "font-variant", nullptr); + sp_repr_css_set_property(css, "font-weight", nullptr); + sp_repr_css_set_property(css, "font-stretch", nullptr); + sp_repr_css_set_property(css, "font-family", nullptr); + sp_repr_css_set_property(css, "text-indent", nullptr); + sp_repr_css_set_property(css, "text-align", nullptr); + sp_repr_css_set_property(css, "line-height", nullptr); + sp_repr_css_set_property(css, "letter-spacing", nullptr); + sp_repr_css_set_property(css, "word-spacing", nullptr); + sp_repr_css_set_property(css, "text-transform", nullptr); + sp_repr_css_set_property(css, "direction", nullptr); + sp_repr_css_set_property(css, "writing-mode", nullptr); + sp_repr_css_set_property(css, "text-orientation", nullptr); + sp_repr_css_set_property(css, "text-anchor", nullptr); + sp_repr_css_set_property(css, "white-space", nullptr); + sp_repr_css_set_property(css, "shape-inside", nullptr); + sp_repr_css_set_property(css, "shape-subtract", nullptr); + sp_repr_css_set_property(css, "shape-padding", nullptr); + sp_repr_css_set_property(css, "shape-margin", nullptr); + sp_repr_css_set_property(css, "inline-size", nullptr); + sp_repr_css_set_property(css, "kerning", nullptr); // not implemented yet + sp_repr_css_set_property(css, "dominant-baseline", nullptr); // not implemented yet + sp_repr_css_set_property(css, "alignment-baseline", nullptr); // not implemented yet + sp_repr_css_set_property(css, "baseline-shift", nullptr); + + sp_repr_css_set_property(css, "text-decoration", nullptr); + sp_repr_css_set_property(css, "text-decoration-line", nullptr); + sp_repr_css_set_property(css, "text-decoration-color", nullptr); + sp_repr_css_set_property(css, "text-decoration-style", nullptr); + + sp_repr_css_set_property(css, "font-variant-ligatures", nullptr); + sp_repr_css_set_property(css, "font-variant-position", nullptr); + sp_repr_css_set_property(css, "font-variant-caps", nullptr); + sp_repr_css_set_property(css, "font-variant-numeric", nullptr); + sp_repr_css_set_property(css, "font-variant-alternates", nullptr); + sp_repr_css_set_property(css, "font-variant-east-asian", nullptr); + sp_repr_css_set_property(css, "font-feature-settings", nullptr); + + return css; +} + +// ui/dialog/inkscape-preferences.cpp +/** + * Unset properties that should not be set for default tool style. + * This list needs to be reviewed. + */ +SPCSSAttr * +sp_css_attr_unset_blacklist(SPCSSAttr *css) +{ + sp_repr_css_set_property(css, "color", nullptr); + sp_repr_css_set_property(css, "clip-rule", nullptr); + sp_repr_css_set_property(css, "d", nullptr); + sp_repr_css_set_property(css, "display", nullptr); + sp_repr_css_set_property(css, "overflow", nullptr); + sp_repr_css_set_property(css, "visibility", nullptr); + sp_repr_css_set_property(css, "isolation", nullptr); + sp_repr_css_set_property(css, "mix-blend-mode", nullptr); + sp_repr_css_set_property(css, "color-interpolation", nullptr); + sp_repr_css_set_property(css, "color-interpolation-filters", nullptr); + sp_repr_css_set_property(css, "solid-color", nullptr); + sp_repr_css_set_property(css, "solid-opacity", nullptr); + sp_repr_css_set_property(css, "fill-rule", nullptr); + sp_repr_css_set_property(css, "color-rendering", nullptr); + sp_repr_css_set_property(css, "image-rendering", nullptr); + sp_repr_css_set_property(css, "shape-rendering", nullptr); + sp_repr_css_set_property(css, "text-rendering", nullptr); + sp_repr_css_set_property(css, "enable-background", nullptr); + + return css; +} + +// Called in style.cpp +static bool +is_url(char const *p) +{ + if (p == nullptr) + return false; +/** \todo + * FIXME: I'm not sure if this applies to SVG as well, but CSS2 says any URIs + * in property values must start with 'url('. + */ + return (g_ascii_strncasecmp(p, "url(", 4) == 0); +} + +// Called in: ui/dialog/inkscape-preferences.cpp, ui/tools/tweek-tool.cpp +/** + * Unset any properties that contain URI values. + * + * Used for storing style that will be reused across documents when carrying + * the referenced defs is impractical. + */ +SPCSSAttr * +sp_css_attr_unset_uris(SPCSSAttr *css) +{ +// All properties that may hold <uri> or <paint> according to SVG 1.1 + if (is_url(sp_repr_css_property(css, "clip-path", nullptr))) sp_repr_css_set_property(css, "clip-path", nullptr); + if (is_url(sp_repr_css_property(css, "color-profile", nullptr))) sp_repr_css_set_property(css, "color-profile", nullptr); + if (is_url(sp_repr_css_property(css, "cursor", nullptr))) sp_repr_css_set_property(css, "cursor", nullptr); + if (is_url(sp_repr_css_property(css, "filter", nullptr))) sp_repr_css_set_property(css, "filter", nullptr); + if (is_url(sp_repr_css_property(css, "marker", nullptr))) sp_repr_css_set_property(css, "marker", nullptr); + if (is_url(sp_repr_css_property(css, "marker-start", nullptr))) sp_repr_css_set_property(css, "marker-start", nullptr); + if (is_url(sp_repr_css_property(css, "marker-mid", nullptr))) sp_repr_css_set_property(css, "marker-mid", nullptr); + if (is_url(sp_repr_css_property(css, "marker-end", nullptr))) sp_repr_css_set_property(css, "marker-end", nullptr); + if (is_url(sp_repr_css_property(css, "mask", nullptr))) sp_repr_css_set_property(css, "mask", nullptr); + if (is_url(sp_repr_css_property(css, "fill", nullptr))) sp_repr_css_set_property(css, "fill", nullptr); + if (is_url(sp_repr_css_property(css, "stroke", nullptr))) sp_repr_css_set_property(css, "stroke", nullptr); + + return css; +} + +// Called in style.cpp +/** + * Scale a single-value property. + */ +static void +sp_css_attr_scale_property_single(SPCSSAttr *css, gchar const *property, + double ex, bool only_with_units = false) +{ + gchar const *w = sp_repr_css_property(css, property, nullptr); + if (w) { + gchar *units = nullptr; + double wd = g_ascii_strtod(w, &units) * ex; + if (w == units) {// nothing converted, non-numeric value + return; + } + if (only_with_units && (units == nullptr || *units == '\0' || *units == '%' || *units == 'e')) { + // only_with_units, but no units found, so do nothing. + // 'e' matches 'em' or 'ex' + return; + } + Inkscape::CSSOStringStream os; + os << wd << units; // reattach units + sp_repr_css_set_property(css, property, os.str().c_str()); + } +} + +// Called in style.cpp for stroke-dasharray +/** + * Scale a list-of-values property. + */ +static void +sp_css_attr_scale_property_list(SPCSSAttr *css, gchar const *property, double ex) +{ + gchar const *string = sp_repr_css_property(css, property, nullptr); + if (string) { + Inkscape::CSSOStringStream os; + gchar **a = g_strsplit(string, ",", 10000); + bool first = true; + for (gchar **i = a; i != nullptr; i++) { + gchar *w = *i; + if (w == nullptr) + break; + gchar *units = nullptr; + double wd = g_ascii_strtod(w, &units) * ex; + if (w == units) {// nothing converted, non-numeric value ("none" or "inherit"); do nothing + g_strfreev(a); + return; + } + if (!first) { + os << ","; + } + os << wd << units; // reattach units + first = false; + } + sp_repr_css_set_property(css, property, os.str().c_str()); + g_strfreev(a); + } +} + +// Called in: text-editing.cpp, +/** + * Scale any properties that may hold <length> by ex. + */ +SPCSSAttr * +sp_css_attr_scale(SPCSSAttr *css, double ex) +{ + sp_css_attr_scale_property_single(css, "baseline-shift", ex); + sp_css_attr_scale_property_single(css, "stroke-width", ex); + sp_css_attr_scale_property_list (css, "stroke-dasharray", ex); + sp_css_attr_scale_property_single(css, "stroke-dashoffset", ex); + sp_css_attr_scale_property_single(css, "font-size", ex, true); + sp_css_attr_scale_property_single(css, "kerning", ex); + sp_css_attr_scale_property_single(css, "letter-spacing", ex); + sp_css_attr_scale_property_single(css, "word-spacing", ex); + sp_css_attr_scale_property_single(css, "line-height", ex, true); + + return css; +} + + +/** + * Quote and/or escape string for writing to CSS, changing strings in place. + * See: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier + */ +void +css_quote(Glib::ustring &val) +{ + Glib::ustring out; + bool quote = false; + + // Can't wait for C++11! + for( Glib::ustring::iterator it = val.begin(); it != val.end(); ++it) { + if(g_ascii_isalnum(*it) || *it=='-' || *it=='_' || *it > 0xA0) { + out += *it; + } else if (*it == '\'') { + // Single quotes require escaping and quotes. + out += '\\'; + out += *it; + quote = true; + } else { + // Quote everything else including spaces. + // (CSS Fonts Level 3 recommends quoting with spaces.) + out += *it; + quote = true; + } + if( it == val.begin() && !g_ascii_isalpha(*it) ) { + // A non-ASCII/non-alpha initial value on any identifier needs quotes. + // (Actually it's a bit more complicated but as it never hurts to quote...) + quote = true; + } + } + if( quote ) { + out.insert( out.begin(), '\'' ); + out += '\''; + } + val = out; +} + + +/** + * Quote font names in font-family lists, changing string in place. + * We use unquoted names internally but some need to be quoted in CSS. + */ +void +css_font_family_quote(Glib::ustring &val) +{ + std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s*,\\s*", val ); + + val.erase(); + for(auto & token : tokens) { + css_quote( token ); + val += token + ", "; + } + if( val.size() > 1 ) + val.erase( val.size() - 2 ); // Remove trailing ", " +} + + +// Called in style-internal.cpp, xml/repr-css.cpp +/** + * Remove paired single and double quotes from a string, changing string in place. + */ +void +css_unquote(Glib::ustring &val) +{ + if( val.size() > 1 && + ( (val[0] == '"' && val[val.size()-1] == '"' ) || + (val[0] == '\'' && val[val.size()-1] == '\'' ) ) ) { + + val.erase( 0, 1 ); + val.erase( val.size()-1 ); + } +} + +// Called in style-internal.cpp, text-toolbar.cpp +/** + * Remove paired single and double quotes from font names in font-family lists, + * changing string in place. + * We use unquoted family names internally but CSS sometimes uses quoted names. + */ +void +css_font_family_unquote(Glib::ustring &val) +{ + std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s*,\\s*", val ); + + val.erase(); + for(auto & token : tokens) { + css_unquote( token ); + val += token + ", "; + } + if( val.size() > 1 ) + val.erase( val.size() - 2 ); // Remove trailing ", " +} + +/* + 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 : |