summaryrefslogtreecommitdiffstats
path: root/src/style-internal.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
commitcca66b9ec4e494c1d919bff0f71a820d8afab1fa (patch)
tree146f39ded1c938019e1ed42d30923c2ac9e86789 /src/style-internal.cpp
parentInitial commit. (diff)
downloadinkscape-upstream/1.2.2.tar.xz
inkscape-upstream/1.2.2.zip
Adding upstream version 1.2.2.upstream/1.2.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/style-internal.cpp3321
1 files changed, 3321 insertions, 0 deletions
diff --git a/src/style-internal.cpp b/src/style-internal.cpp
new file mode 100644
index 0000000..56c93e4
--- /dev/null
+++ b/src/style-internal.cpp
@@ -0,0 +1,3321 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * SVG stylesheets implementation - Classes used by SPStyle class.
+ */
+
+/* Authors:
+ * C++ conversion:
+ * Tavmjong Bah <tavmjong@free.fr>
+ * Legacy C implementation:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Peter Moulder <pmoulder@mail.csse.monash.edu.au>
+ * bulia byak <buliabyak@users.sf.net>
+ * Abhishek Sharma
+ * 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, 2018 Tavmjong Bah
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/regex.h>
+
+#include "style-internal.h"
+#include "style.h"
+
+#include "bad-uri-exception.h"
+#include "extract-uri.h"
+#include "inkscape.h"
+#include "preferences.h"
+#include "streq.h"
+#include "strneq.h"
+
+#include "object/sp-text.h"
+#include "object/object-set.h"
+
+#include "svg/svg.h"
+#include "svg/svg-color.h"
+#include "svg/css-ostringstream.h"
+
+#include "util/units.h"
+
+// TODO REMOVE OR MAKE MEMBER FUNCTIONS
+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);
+void sp_style_filter_ref_changed( SPObject *old_ref, SPObject *ref, SPStyle *style);
+void sp_style_set_ipaint_to_uri(SPStyle *style, SPIPaint *paint, const Inkscape::URI *uri, SPDocument *document);
+void sp_style_set_ipaint_to_uri_string (SPStyle *style, SPIPaint *paint, const gchar *uri);
+
+using Inkscape::CSSOStringStream;
+
+// SPIBase --------------------------------------------------------------
+
+Glib::ustring const &SPIBase::name() const
+{
+ static Glib::ustring names[(int)SPAttr::SPAttr_SIZE];
+ auto &name = names[(int)id()];
+ if (name.empty()) {
+ auto const *namecstr = sp_attribute_name(id());
+ name = namecstr ? namecstr : "anonymous";
+ }
+ return name;
+}
+
+/**
+ * Check if this property should be written. This function won't do any writing so can
+ * be used as a quick way to check if specific kinds of style attrs have been changed.
+ *
+ * @param flags Conditions bitmask of `SP_STYLE_FLAG_*` bits
+ * @param style_src_req For `SP_STYLE_FLAG_IFSRC`
+ * @param base Parent node style for `SP_STYLE_FLAG_IFDIFF`, can be NULL
+ *
+ * @return True if property should be written, false otherwise
+ */
+bool SPIBase::shall_write(guint const flags, SPStyleSrc const &style_src_req, SPIBase const *const base) const
+{
+ // flags SP_STYLE_FLAG_IFSET and SP_STYLE_FLAG_IFDIFF are ignored, their
+ // information is redundant FIXME remove those flags
+
+ // pointer equality handled in SPStyle::write, not expected here
+ assert(base != this);
+
+ if ((flags & SP_STYLE_FLAG_ALWAYS)) {
+ assert(!(flags & SP_STYLE_FLAG_IFSRC));
+ assert(!base);
+ return true;
+ }
+
+ if (!set) {
+ return false;
+ }
+
+ if ((flags & SP_STYLE_FLAG_IFSRC) && style_src_req != style_src) {
+ return false;
+ }
+
+ if (base && inherits && *base == *this) {
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * Compile this style conditionally into a 'name: value' string suitable for css attrs.
+ * see shall_write for details on conditional flags.
+ *
+ * @param flags Conditions bitmask of `SP_STYLE_FLAG_*` bits
+ * @param style_src_req For `SP_STYLE_FLAG_IFSRC`
+ * @param base Parent node style for `SP_STYLE_FLAG_IFDIFF`, can be NULL
+ *
+ * @return completed css string or empty string if conditions not met.
+ */
+const Glib::ustring SPIBase::write(guint const flags, SPStyleSrc const &style_src_req, SPIBase const *const base) const
+{
+ if (shall_write(flags, style_src_req, base)) {
+ auto value = this->get_value();
+ if ( !value.empty() ) {
+ return (name() + ":" + value + important_str() + ";");
+ }
+ }
+ return Glib::ustring("");
+}
+
+
+/**
+ * If str.endswith("!important") then assign stripped = str[:-10].rstrip() and return true.
+ * Otherwise, leave stripped unmodified and return false.
+ */
+static bool strip_important(gchar const *str, std::string &stripped)
+{
+ assert(str != nullptr);
+
+ constexpr size_t N = 10; // strlen("!important")
+ auto pos = strlen(str);
+
+ if (pos >= N && strncmp(str + pos - N, "!important", N) == 0) {
+ pos -= N;
+
+ // strip whitespace from the right
+ while (pos > 0 && g_ascii_isspace(str[pos - 1])) {
+ --pos;
+ }
+
+ stripped.assign(str, pos);
+ return true;
+ }
+
+ return false;
+}
+
+void SPIBase::readIfUnset(gchar const *str, SPStyleSrc source)
+{
+ if (!str)
+ return;
+
+ if (source == SPStyleSrc::ATTRIBUTE && id() == SPAttr::D) {
+ return;
+ }
+
+ bool has_important = false;
+ std::string stripped;
+
+ // '!important' is invalid on attributes
+ if (source != SPStyleSrc::ATTRIBUTE) {
+ has_important = strip_important(str, stripped);
+ if (has_important) {
+ str = stripped.c_str();
+ }
+ }
+
+ if (!set || (has_important && !important)) {
+ read(str); // clears style_src
+ style_src = source;
+ if (set) {
+ if (has_important) {
+ important = true;
+ }
+ }
+ }
+}
+
+
+// SPIFloat -------------------------------------------------------------
+
+void
+SPIFloat::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if ( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else {
+ gfloat value_tmp;
+ if (sp_svg_number_read_f(str, &value_tmp)) {
+ set = true;
+ inherit = false;
+ value = value_tmp;
+ }
+ }
+}
+
+const Glib::ustring SPIFloat::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ return Glib::ustring::format(this->value);
+}
+
+void
+SPIFloat::cascade( const SPIBase* const parent ) {
+ if( const SPIFloat* p = dynamic_cast<const SPIFloat*>(parent) ) {
+ if( (inherits && !set) || inherit ) value = p->value;
+ } else {
+ std::cerr << "SPIFloat::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIFloat::merge( const SPIBase* const parent ) {
+ if( const SPIFloat* p = dynamic_cast<const SPIFloat*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ value = p->value;
+ }
+ }
+ } else {
+ std::cerr << "SPIFloat::merge(): Incorrect parent type" << std::endl;
+ }
+}
+
+bool
+SPIFloat::operator==(const SPIBase& rhs) const {
+ if( const SPIFloat* r = dynamic_cast<const SPIFloat*>(&rhs) ) {
+ return (value == r->value && SPIBase::operator==(rhs));
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIScale24 -----------------------------------------------------------
+
+void
+SPIScale24::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if ( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else {
+ gfloat value_in;
+ if (sp_svg_number_read_f(str, &value_in)) {
+ set = true;
+ inherit = false;
+ value_in = CLAMP(value_in, 0.0, 1.0);
+ value = SP_SCALE24_FROM_FLOAT( value_in );
+ }
+ }
+}
+
+const Glib::ustring SPIScale24::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ return Glib::ustring::format(SP_SCALE24_TO_FLOAT(this->value));
+}
+
+void
+SPIScale24::cascade( const SPIBase* const parent ) {
+ if( const SPIScale24* p = dynamic_cast<const SPIScale24*>(parent) ) {
+ if( (inherits && !set) || inherit ) value = p->value;
+ } else {
+ std::cerr << "SPIScale24::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIScale24::merge( const SPIBase* const parent ) {
+ if( const SPIScale24* p = dynamic_cast<const SPIScale24*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ value = p->value;
+ }
+ } else {
+ // Needed only for 'opacity' and 'stop-opacity' which do not inherit. See comment at bottom of file.
+ if (id() != SPAttr::OPACITY && id() != SPAttr::STOP_OPACITY)
+ std::cerr << "SPIScale24::merge: unhandled property: " << name() << std::endl;
+ if( !set || (!inherit && value == SP_SCALE24_MAX) ) {
+ value = p->value;
+ set = (value != SP_SCALE24_MAX);
+ } else {
+ if( inherit ) value = p->value; // Insures child is up-to-date
+ value = SP_SCALE24_MUL( value, p->value );
+ inherit = (inherit && p->inherit && (p->value == 0 || p->value == SP_SCALE24_MAX) );
+ set = (inherit || value < SP_SCALE24_MAX);
+ }
+ }
+ } else {
+ std::cerr << "SPIScale24::merge(): Incorrect parent type" << std::endl;
+ }
+}
+
+bool
+SPIScale24::operator==(const SPIBase& rhs) const {
+ if( const SPIScale24* r = dynamic_cast<const SPIScale24*>(&rhs) ) {
+ return (value == r->value && SPIBase::operator==(rhs));
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPILength ------------------------------------------------------------
+
+void
+SPILength::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ unit = SP_CSS_UNIT_NONE;
+ value = computed = 0.0;
+ } else {
+ gdouble value_tmp;
+ gchar *e;
+ /** \todo fixme: Move this to standard place (Lauris) */
+ value_tmp = g_ascii_strtod(str, &e);
+ if ( !std::isfinite(value_tmp) ) { // fix for bug lp:935157
+ return;
+ }
+ if ((gchar const *) e != str) {
+
+ value = value_tmp;
+ if (!*e) {
+ /* Userspace */
+ unit = SP_CSS_UNIT_NONE;
+ computed = value;
+ } else if (!strcmp(e, "px")) {
+ /* Userspace */
+ unit = SP_CSS_UNIT_PX;
+ computed = value;
+ } else if (!strcmp(e, "pt")) {
+ /* Userspace / DEVICESCALE */
+ unit = SP_CSS_UNIT_PT;
+ computed = Inkscape::Util::Quantity::convert(value, "pt", "px");
+ } else if (!strcmp(e, "pc")) {
+ unit = SP_CSS_UNIT_PC;
+ computed = Inkscape::Util::Quantity::convert(value, "pc", "px");
+ } else if (!strcmp(e, "mm")) {
+ unit = SP_CSS_UNIT_MM;
+ computed = Inkscape::Util::Quantity::convert(value, "mm", "px");
+ } else if (!strcmp(e, "cm")) {
+ unit = SP_CSS_UNIT_CM;
+ computed = Inkscape::Util::Quantity::convert(value, "cm", "px");
+ } else if (!strcmp(e, "in")) {
+ unit = SP_CSS_UNIT_IN;
+ computed = Inkscape::Util::Quantity::convert(value, "in", "px");
+ } else if (!strcmp(e, "em")) {
+ /* EM square */
+ unit = SP_CSS_UNIT_EM;
+ if( style ) {
+ computed = value * style->font_size.computed;
+ } else {
+ computed = value * SPIFontSize::font_size_default;
+ }
+ } else if (!strcmp(e, "ex")) {
+ /* ex square */
+ unit = SP_CSS_UNIT_EX;
+ if( style ) {
+ computed = value * style->font_size.computed * 0.5; // FIXME
+ } else {
+ computed = value * SPIFontSize::font_size_default * 0.5;
+ }
+ } else if (!strcmp(e, "%")) {
+ /* Percentage */
+ unit = SP_CSS_UNIT_PERCENT;
+ value = value * 0.01;
+ if (id() == SPAttr::LINE_HEIGHT) {
+ // See: http://www.w3.org/TR/CSS2/visudet.html#propdef-line-height
+ if( style ) {
+ computed = value * style->font_size.computed;
+ } else {
+ computed = value * SPIFontSize::font_size_default;
+ }
+ }
+ } else {
+ /* Invalid */
+ return;
+ }
+ set = true;
+ inherit = false;
+ }
+ }
+}
+
+const Glib::ustring SPILength::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ auto value = this->computed;
+ auto unit_out = Glib::ustring("");
+ switch (this->unit) {
+ case SP_CSS_UNIT_NONE:
+ break;
+ case SP_CSS_UNIT_PX:
+ unit_out = "px";
+ break;
+ case SP_CSS_UNIT_PT:
+ case SP_CSS_UNIT_PC:
+ case SP_CSS_UNIT_MM:
+ case SP_CSS_UNIT_CM:
+ case SP_CSS_UNIT_IN:
+ unit_out = sp_style_get_css_unit_string(this->unit);
+ value = Inkscape::Util::Quantity::convert(this->computed, "px", unit_out);
+ break;
+ case SP_CSS_UNIT_EM:
+ case SP_CSS_UNIT_EX:
+ unit_out = sp_style_get_css_unit_string(this->unit);
+ value = this->value;
+ break;
+ case SP_CSS_UNIT_PERCENT:
+ unit_out = "%";
+ value = this->value * 100.0;
+ break;
+ default:
+ /* Invalid */
+ break;
+ }
+ return Glib::ustring::format(value) + unit_out;
+}
+
+void
+SPILength::cascade( const SPIBase* const parent ) {
+ if( const SPILength* p = dynamic_cast<const SPILength*>(parent) ) {
+ if( (inherits && !set) || inherit ) {
+ unit = p->unit;
+ value = p->value;
+ computed = p->computed;
+ } else {
+ // Recalculate based on new font-size, font-family inherited from parent
+ double const em = style->font_size.computed;
+ if (unit == SP_CSS_UNIT_EM) {
+ computed = value * em;
+ } else if (unit == SP_CSS_UNIT_EX) {
+ // FIXME: Get x height from libnrtype or pango.
+ computed = value * em * 0.5;
+ } else if (unit == SP_CSS_UNIT_PERCENT && id() == SPAttr::LINE_HEIGHT) {
+ // Special case
+ computed = value * em;
+ }
+ }
+ } else {
+ std::cerr << "SPILength::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPILength::merge( const SPIBase* const parent ) {
+ if( const SPILength* p = dynamic_cast<const SPILength*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ unit = p->unit;
+ value = p->value;
+ computed = p->computed;
+
+ // Fix up so values are correct
+ switch (p->unit) {
+ case SP_CSS_UNIT_EM:
+ case SP_CSS_UNIT_EX:
+ value *= p->style->font_size.computed / style->font_size.computed;
+ /** \todo
+ * FIXME: Have separate ex ratio parameter.
+ * Get x height from libnrtype or pango.
+ */
+ if (!std::isfinite(value)) {
+ value = computed;
+ unit = SP_CSS_UNIT_NONE;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ } else {
+ std::cerr << "SPIFloat::merge(): Incorrect parent type" << std::endl;
+ }
+}
+
+void SPILength::setDouble(double v)
+{
+ unit = SP_CSS_UNIT_NONE;
+ value = v;
+ computed = v;
+ value_default = v;
+}
+
+// Generate a string and allow emove name for parsing dasharray, etc.
+const Glib::ustring SPILength::toString(bool wname) const
+{
+ CSSOStringStream os;
+ if (wname) {
+ os << name() << ":";
+ }
+ os << this->get_value();
+ if (wname) {
+ os << important_str();
+ os << ";";
+ }
+ return os.str();
+}
+
+bool
+SPILength::operator==(const SPIBase& rhs) const {
+ if( const SPILength* r = dynamic_cast<const SPILength*>(&rhs) ) {
+
+ if( unit != r->unit ) return false;
+
+ // If length depends on external parameter, lengths cannot be equal.
+ if (unit == SP_CSS_UNIT_EM) return false;
+ if (unit == SP_CSS_UNIT_EX) return false;
+ if (unit == SP_CSS_UNIT_PERCENT) return false;
+ if (r->unit == SP_CSS_UNIT_EM) return false;
+ if (r->unit == SP_CSS_UNIT_EX) return false;
+ if (r->unit == SP_CSS_UNIT_PERCENT) return false;
+
+ return (computed == r->computed );
+ } else {
+ return false;
+ }
+}
+
+// SPILengthOrNormal ----------------------------------------------------
+
+void
+SPILengthOrNormal::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if ( !strcmp(str, "normal") ) {
+ set = true;
+ inherit = false;
+ unit = SP_CSS_UNIT_NONE;
+ value = computed = 0.0;
+ normal = true;
+ } else {
+ SPILength::read( str );
+ normal = false;
+ }
+};
+
+const Glib::ustring SPILengthOrNormal::get_value() const
+{
+ if (this->normal) return Glib::ustring("normal");
+ return SPILength::get_value();
+}
+
+void
+SPILengthOrNormal::cascade( const SPIBase* const parent ) {
+ if( const SPILengthOrNormal* p = dynamic_cast<const SPILengthOrNormal*>(parent) ) {
+ if( (inherits && !set) || inherit ) {
+ normal = p->normal;
+ }
+ SPILength::cascade( parent );
+ } else {
+ std::cerr << "SPILengthOrNormal::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPILengthOrNormal::merge( const SPIBase* const parent ) {
+ if( const SPILengthOrNormal* p = dynamic_cast<const SPILengthOrNormal*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ normal = p->normal;
+ SPILength::merge( parent );
+ }
+ }
+ }
+}
+
+bool
+SPILengthOrNormal::operator==(const SPIBase& rhs) const {
+ if( const SPILengthOrNormal* r = dynamic_cast<const SPILengthOrNormal*>(&rhs) ) {
+ if( normal && r->normal ) { return true; }
+ if( normal != r->normal ) { return false; }
+ return SPILength::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+// SPIFontVariationSettings ----------------------------------------------------
+
+void
+SPIFontVariationSettings::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if ( !strcmp(str, "normal") ) {
+ set = true;
+ inherit = false;
+ normal = true;
+ axes.clear();
+ return;
+ }
+
+
+ std::vector<Glib::ustring> tokens = Glib::Regex::split_simple(",", str);
+
+ // Match a pattern of a CSS <string> of length 4, whitespace, CSS <number>.
+ // (CSS string is quoted with double quotes).
+
+ // Matching must use a Glib::ustring or matching may produce
+ // subtle errors which may be shown by an "Invalid byte sequence
+ // in conversion input" error.
+ Glib::RefPtr<Glib::Regex> regex = Glib::Regex::create(
+ "[\"'](\\w{4})[\"']"
+ "\\s+([-+]?\\d*\\.?\\d+([eE][-+]?\\d+)?)");
+ Glib::MatchInfo matchInfo;
+
+ for (auto token: tokens) {
+ regex->match(token, matchInfo);
+ if (matchInfo.matches()) {
+ float value = std::stod(matchInfo.fetch(2));
+ axes.insert(std::pair<Glib::ustring,float>(matchInfo.fetch(1), value));
+ }
+ }
+
+ if (!axes.empty()) {
+ set = true;
+ inherit = false;
+ normal = false;
+ }
+};
+
+const Glib::ustring SPIFontVariationSettings::get_value() const
+{
+ if (this->normal) return Glib::ustring("normal");
+ auto ret = Glib::ustring("");
+ for(auto it: axes) {
+ ret += "'" + it.first + "' " + Glib::ustring::format(it.second) + ", ";
+ }
+ if (!ret.empty()) ret.erase(ret.size() - 2);
+ return ret;
+}
+
+void
+SPIFontVariationSettings::cascade( const SPIBase* const parent ) {
+ if( const SPIFontVariationSettings* p = dynamic_cast<const SPIFontVariationSettings*>(parent) ) {
+ if( !set || inherit ) { // Always inherits
+ normal = p->normal;
+ axes.clear();
+ axes = p->axes;
+ }
+ } else {
+ std::cerr << "SPIFontVariationSettings::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIFontVariationSettings::merge( const SPIBase* const parent ) {
+ if( const SPIFontVariationSettings* p = dynamic_cast<const SPIFontVariationSettings*>(parent) ) {
+ // if( inherits ) { 'font-variation-settings' always inherits.
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ normal = p->normal;
+ axes = p->axes;
+ }
+ }
+}
+
+bool
+SPIFontVariationSettings::operator==(const SPIBase& rhs) const {
+ if( const SPIFontVariationSettings* r = dynamic_cast<const SPIFontVariationSettings*>(&rhs) ) {
+ if( normal && r->normal ) { return true; }
+ if( normal != r->normal ) { return false; }
+ return axes == r->axes;
+ } else {
+ return false;
+ }
+}
+
+// Generate a string useful for passing to Pango, etc.
+const Glib::ustring
+SPIFontVariationSettings::toString() const {
+
+ Inkscape::CSSOStringStream os;
+ for (const auto & axe : axes){
+ os << axe.first << "=" << axe.second << ",";
+ }
+
+ std::string string = os.str(); // Glib::ustring doesn't have pop_back()
+ if (!string.empty()) {
+ string.pop_back(); // Delete extra comma at end
+ }
+
+ return string;
+}
+
+// Helpers for SPIEnum -----------------------------------------------------
+
+// The default exists to satisfy linking of derived classes but must never be called
+template <typename T> static SPStyleEnum const *get_enums() { g_assert_not_reached(); return nullptr; }
+
+template <> SPStyleEnum const *get_enums<SPBlendMode>() { return enum_blend_mode; }
+template <> SPStyleEnum const *get_enums<SPColorInterpolation>() { return enum_color_interpolation; }
+template <> SPStyleEnum const *get_enums<SPColorRendering>() { return enum_color_rendering; }
+template <> SPStyleEnum const *get_enums<SPCSSBaseline>() { return enum_baseline; }
+template <> SPStyleEnum const *get_enums<SPCSSDirection>() { return enum_direction; }
+template <> SPStyleEnum const *get_enums<SPCSSDisplay>() { return enum_display; }
+template <> SPStyleEnum const *get_enums<SPCSSFontVariantAlternates>() { return enum_font_variant_alternates; }
+template <> SPStyleEnum const *get_enums<SPCSSTextAlign>() { return enum_text_align; }
+template <> SPStyleEnum const *get_enums<SPCSSTextOrientation>() { return enum_text_orientation; }
+template <> SPStyleEnum const *get_enums<SPCSSTextTransform>() { return enum_text_transform; }
+template <> SPStyleEnum const *get_enums<SPCSSWritingMode>() { return enum_writing_mode; }
+template <> SPStyleEnum const *get_enums<SPEnableBackground>() { return enum_enable_background; }
+template <> SPStyleEnum const *get_enums<SPImageRendering>() { return enum_image_rendering; }
+template <> SPStyleEnum const *get_enums<SPIsolation>() { return enum_isolation; }
+template <> SPStyleEnum const *get_enums<SPOverflow>() { return enum_overflow; }
+template <> SPStyleEnum const *get_enums<SPShapeRendering>() { return enum_shape_rendering; }
+template <> SPStyleEnum const *get_enums<SPStrokeCapType>() { return enum_stroke_linecap; }
+template <> SPStyleEnum const *get_enums<SPStrokeJoinType>() { return enum_stroke_linejoin; }
+template <> SPStyleEnum const *get_enums<SPTextAnchor>() { return enum_text_anchor; }
+template <> SPStyleEnum const *get_enums<SPTextRendering>() { return enum_text_rendering; }
+template <> SPStyleEnum const *get_enums<SPVisibility>() { return enum_visibility; }
+template <> SPStyleEnum const *get_enums<SPWhiteSpace>() { return enum_white_space; }
+template <> SPStyleEnum const *get_enums<SPWindRule>() { return enum_clip_rule; }
+template <> SPStyleEnum const *get_enums<SPCSSFontStyle>() { return enum_font_style; }
+template <> SPStyleEnum const *get_enums<SPCSSFontVariant>() { return enum_font_variant; }
+template <> SPStyleEnum const *get_enums<SPCSSFontWeight>() { return enum_font_weight; }
+template <> SPStyleEnum const *get_enums<SPCSSFontStretch>() { return enum_font_stretch; }
+template <> SPStyleEnum const *get_enums<SPCSSFontVariantPosition>() { return enum_font_variant_position; }
+template <> SPStyleEnum const *get_enums<SPCSSFontVariantCaps>() { return enum_font_variant_caps; }
+
+// SPIEnum --------------------------------------------------------------
+
+template <typename T>
+void SPIEnum<T>::update_computed()
+{
+ computed = value;
+}
+
+template <>
+void SPIEnum<SPCSSFontWeight>::update_computed()
+{
+ // The following is defined in CSS 2.1
+ if (value == SP_CSS_FONT_WEIGHT_NORMAL) {
+ computed = SP_CSS_FONT_WEIGHT_400;
+ } else if (value == SP_CSS_FONT_WEIGHT_BOLD) {
+ computed = SP_CSS_FONT_WEIGHT_700;
+ } else {
+ computed = value;
+ }
+}
+
+template <typename T>
+void SPIEnum<T>::read(gchar const *str)
+{
+
+ if( !str ) return;
+
+ if( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else {
+ auto const *enums = get_enums<T>();
+ for (unsigned i = 0; enums[i].key; i++) {
+ if (!strcmp(str, enums[i].key)) {
+ set = true;
+ inherit = false;
+ value = static_cast<T>(enums[i].value);
+ /* Save copying for values not needing it */
+ break;
+ }
+ }
+
+ // type-specialized subroutine
+ update_computed();
+ }
+}
+
+template <typename T>
+const Glib::ustring SPIEnum<T>::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ auto const *enums = get_enums<T>();
+ for (unsigned i = 0; enums[i].key; ++i) {
+ if (enums[i].value == static_cast< gint > (this->value) ) {
+ return Glib::ustring(enums[i].key);
+ }
+ }
+ return Glib::ustring("");
+}
+
+template <>
+void SPIEnum<SPCSSFontWeight>::update_computed_cascade(SPCSSFontWeight const &p_computed)
+{
+ // strictly, 'bolder' and 'lighter' should go to the next weight
+ // expressible in the current font family, but that's difficult to
+ // find out, so jumping by 3 seems an appropriate approximation
+ if (value == SP_CSS_FONT_WEIGHT_LIGHTER) {
+ computed = static_cast<SPCSSFontWeight>(std::max<int>(SP_CSS_FONT_WEIGHT_100, int(p_computed) - 3));
+ } else if (value == SP_CSS_FONT_WEIGHT_BOLDER) {
+ computed = static_cast<SPCSSFontWeight>(std::min<int>(SP_CSS_FONT_WEIGHT_900, p_computed + 3));
+ }
+}
+
+template <>
+void SPIEnum<SPCSSFontStretch>::update_computed_cascade(SPCSSFontStretch const &p_computed)
+{
+ if (value == SP_CSS_FONT_STRETCH_NARROWER) {
+ computed =
+ static_cast<SPCSSFontStretch>(std::max<int>(SP_CSS_FONT_STRETCH_ULTRA_CONDENSED, int(p_computed) - 1));
+ } else if (value == SP_CSS_FONT_STRETCH_WIDER) {
+ computed = static_cast<SPCSSFontStretch>(std::min<int>(SP_CSS_FONT_STRETCH_ULTRA_EXPANDED, p_computed + 1));
+ }
+}
+
+template <typename T>
+void SPIEnum<T>::cascade(const SPIBase *const parent)
+{
+ if (const auto *p = dynamic_cast<const SPIEnum<T> *>(parent)) {
+ if( inherits && (!set || inherit) ) {
+ computed = p->computed;
+ } else {
+ // type-specialized subroutine
+ update_computed_cascade(p->computed);
+ }
+ } else {
+ std::cerr << "SPIEnum<T>::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+// FIXME Handle font_stretch and font_weight (relative values) New derived class?
+template <typename T>
+void SPIEnum<T>::update_value_merge(SPIEnum<T> const &p, T smaller, T larger)
+{
+ g_assert(set);
+
+ if (value == p.value) {
+ // Leave as is, what does applying "wider" twice do?
+ } else if ((value == smaller && p.value == larger) || //
+ (value == larger && p.value == smaller)) {
+ // Values cancel, unset
+ set = false;
+ } else if (value == smaller || value == larger) {
+ value = computed;
+ inherit = false;
+ }
+}
+
+template <>
+void SPIEnum<SPCSSFontWeight>::update_value_merge(SPIEnum<SPCSSFontWeight> const &p)
+{
+ update_value_merge(p, SP_CSS_FONT_WEIGHT_LIGHTER, SP_CSS_FONT_WEIGHT_BOLDER);
+}
+
+template <>
+void SPIEnum<SPCSSFontStretch>::update_value_merge(SPIEnum<SPCSSFontStretch> const &p)
+{
+ update_value_merge(p, SP_CSS_FONT_STRETCH_NARROWER, SP_CSS_FONT_STRETCH_WIDER);
+}
+
+template <typename T>
+void SPIEnum<T>::merge(const SPIBase *const parent)
+{
+ if (const auto *p = dynamic_cast<const SPIEnum<T> *>(parent)) {
+ if( inherits ) {
+ if( p->set && !p->inherit ) {
+ if( !set || inherit ) {
+ set = p->set;
+ inherit = p->inherit;
+ value = p->value;
+ computed = p->computed; // Different from value for font-weight and font-stretch
+ } else {
+ // type-specialized subroutine
+ update_value_merge(*p);
+ }
+ }
+ }
+ }
+}
+
+template <typename T>
+bool SPIEnum<T>::operator==(const SPIBase &rhs) const
+{
+ if (auto *r = dynamic_cast<const SPIEnum<T> *>(&rhs)) {
+ return (computed == r->computed && SPIBase::operator==(rhs));
+ } else {
+ return false;
+ }
+}
+
+
+#if 0
+// SPIEnumBits ----------------------------------------------------------
+// Used for 'font-variant-xxx'
+void
+SPIEnumBits::read( gchar const *str ) {
+
+ if( !str ) return;
+ if( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else {
+ for (unsigned i = 0; enums[i].key; i++) {
+ if (!strcmp(str, enums[i].key)) {
+ set = true;
+ inherit = false;
+ value |= enums[i].value;
+ }
+ }
+ /* Save copying for values not needing it */
+ computed = value;
+ }
+}
+
+const Glib::ustring SPIEnumBits::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->value == 0) return Glib::ustring("normal");
+ auto ret = Glib::ustring("");
+ for (unsigned i = 0; enums[i].key; ++i) {
+ if (this->value & enums[i].value) {
+ if (!ret.empty()) ret += " ";
+ ret += enums[i].key;
+ }
+ }
+ return ret;
+}
+#endif
+
+// SPILigatures -----------------------------------------------------
+// Used for 'font-variant-ligatures'
+void
+SPILigatures::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ value = SP_CSS_FONT_VARIANT_LIGATURES_NORMAL;
+ if( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else if (!strcmp(str, "normal" )) {
+ // Defaults for TrueType
+ inherit = false;
+ set = true;
+ } else if (!strcmp(str, "none" )) {
+ value = SP_CSS_FONT_VARIANT_LIGATURES_NONE;
+ inherit = false;
+ set = true;
+ } else {
+ // We need to parse in order
+ std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s+", str );
+ auto const *enums = enum_font_variant_ligatures;
+ for(auto & token : tokens) {
+ for (unsigned j = 0; enums[j].key; ++j ) {
+ if (token.compare( enums[j].key ) == 0 ) {
+ set = true;
+ inherit = false;
+ if( enums[j].value < SP_CSS_FONT_VARIANT_LIGATURES_NOCOMMON ) {
+ // Turn on
+ value |= enums[j].value;
+ } else {
+ // Turn off
+ value &= ~(enums[j].value >> 4);
+ }
+ }
+ }
+ }
+ }
+ computed = value;
+}
+
+/* FIXME:: This whole class is bogus and should be an SPIBitEnum TODO */
+
+const Glib::ustring SPILigatures::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->value == SP_CSS_FONT_VARIANT_LIGATURES_NONE) return Glib::ustring("none");
+ if (this->value == SP_CSS_FONT_VARIANT_LIGATURES_NORMAL) return Glib::ustring("normal");
+ auto ret = Glib::ustring("");
+ if (!(value & SP_CSS_FONT_VARIANT_LIGATURES_COMMON))
+ ret += "no-common-ligatures ";
+ if (value & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY)
+ ret += "discretionary-ligatures ";
+ if (value & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL )
+ ret += "historical-ligatures ";
+ if ( !(value & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL) )
+ ret += "no-contextual ";
+ ret.erase(ret.size() - 1);
+ return ret;
+}
+
+// SPINumeric -----------------------------------------------------
+// Used for 'font-variant-numeric'
+void
+SPINumeric::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ value = SP_CSS_FONT_VARIANT_NUMERIC_NORMAL;
+ if( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else if (!strcmp(str, "normal" )) {
+ // Defaults for TrueType
+ inherit = false;
+ set = true;
+ } else {
+ // We need to parse in order
+ std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s+", str );
+ auto const *enums = enum_font_variant_numeric;
+ for(auto & token : tokens) {
+ for (unsigned j = 0; enums[j].key; ++j ) {
+ if (token.compare( enums[j].key ) == 0 ) {
+ set = true;
+ inherit = false;
+ value |= enums[j].value;
+
+ // Must switch off incompatible value
+ switch (enums[j].value ) {
+ case SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS:
+ value &= ~SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS;
+ break;
+ case SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS:
+ value &= ~SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS;
+ break;
+
+ case SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS:
+ value &= ~SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS;
+ break;
+ case SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS:
+ value &= ~SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS;
+ break;
+
+ case SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS:
+ value &= ~SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS;
+ break;
+ case SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS:
+ value &= ~SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS;
+ break;
+
+ case SP_CSS_FONT_VARIANT_NUMERIC_NORMAL:
+ case SP_CSS_FONT_VARIANT_NUMERIC_ORDINAL:
+ case SP_CSS_FONT_VARIANT_NUMERIC_SLASHED_ZERO:
+ // Do nothing
+ break;
+
+ default:
+ std::cerr << "SPINumeric::read(): Invalid value." << std::endl;
+ break;
+ }
+ }
+ }
+ }
+ }
+ computed = value;
+}
+
+/* FIXME:: This whole class is bogus and should be an SPIBitEnum TODO */
+const Glib::ustring SPINumeric::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->value == 0) return Glib::ustring("normal");
+ auto ret = Glib::ustring("");
+ auto enums = enum_font_variant_numeric;
+ for (unsigned i = 1; enums[i].key; ++i) {
+ // Bitmap is shifted by 1 because normal is zero
+ if (this->value & (1 << (i - 1))) {
+ if (!ret.empty()) ret += " ";
+ ret += enums[i].key;
+ }
+ }
+ return ret;
+}
+
+// SPIEastAsian ---------------------------------------------------
+// Used for 'font-variant-east-asian'
+void
+SPIEastAsian::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ value = SP_CSS_FONT_VARIANT_EAST_ASIAN_NORMAL;
+ if( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else if (!strcmp(str, "normal" )) {
+ // Defaults for TrueType
+ inherit = false;
+ set = true;
+ } else {
+ // We need to parse in order
+ std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s+", str );
+ auto const *enums = enum_font_variant_east_asian;
+ for(auto & token : tokens) {
+ for (unsigned j = 0; enums[j].key; ++j ) {
+ if (token.compare( enums[j].key ) == 0 ) {
+ set = true;
+ inherit = false;
+
+ // Must switch off incompatible value (turn on correct one below)
+ switch (enums[j].value ) {
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS78:
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS83:
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS90:
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS04:
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_SIMPLIFIED:
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_TRADITIONAL:
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS78;
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS83;
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS90;
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_JIS04;
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_SIMPLIFIED;
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_TRADITIONAL;
+ break;
+
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_FULL_WIDTH:
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_PROPORTIONAL_WIDTH;
+ break;
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_PROPORTIONAL_WIDTH:
+ value &= ~SP_CSS_FONT_VARIANT_EAST_ASIAN_FULL_WIDTH;
+ break;
+
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_NORMAL:
+ case SP_CSS_FONT_VARIANT_EAST_ASIAN_RUBY:
+ // Do nothing
+ break;
+
+ default:
+ std::cerr << "SPIEastasian::read(): Invalid value." << std::endl;
+ break;
+ }
+
+ value |= enums[j].value;
+ }
+ }
+ }
+ }
+ computed = value;
+}
+
+const Glib::ustring SPIEastAsian::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->value == 0) return Glib::ustring("normal");
+ auto ret = Glib::ustring("");
+ auto enums = enum_font_variant_east_asian;
+ for (unsigned i = 0; enums[i].key; ++i) {
+ if (this->value & (1 << i)) {
+ if (!ret.empty()) ret += " ";
+ ret += enums[i].key;
+ }
+ }
+ return ret;
+}
+
+// SPIString ------------------------------------------------------------
+
+void
+SPIString::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ clear();
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ } else if (!g_strcmp0(str, get_default_value())) {
+ // no need to copy string
+ set = true;
+ } else {
+ Glib::ustring str_temp;
+
+ if (id() == SPAttr::FONT_FAMILY) {
+ // Family names may be quoted in CSS, internally we use unquoted names.
+ str_temp = str;
+ css_font_family_unquote( str_temp );
+ str = str_temp.c_str();
+ } else if (id() == SPAttr::INKSCAPE_FONT_SPEC) {
+ str_temp = str;
+ css_unquote( str_temp );
+ str = str_temp.c_str();
+ }
+
+ set = true;
+ _value = g_strdup(str);
+ }
+}
+
+
+/**
+ * Value as it should be written to CSS representation, including quotes if needed.
+ */
+const Glib::ustring SPIString::get_value() const
+{
+ Glib::ustring val;
+
+ if (set && inherit) {
+ val = "inherit";
+ } else if (auto *v = value()) {
+ val = v;
+
+ if (id() == SPAttr::FONT_FAMILY) {
+ css_font_family_quote(val);
+ } else if (id() == SPAttr::INKSCAPE_FONT_SPEC) {
+ css_quote(val);
+ }
+ }
+
+ return val;
+}
+
+char const *SPIString::value() const
+{
+ return _value ? _value : get_default_value();
+}
+
+char const *SPIString::get_default_value() const
+{
+ switch (id()) {
+ case SPAttr::FONT_FAMILY:
+ return "sans-serif";
+ case SPAttr::FONT_FEATURE_SETTINGS:
+ return "normal";
+ default:
+ return nullptr;
+ }
+}
+
+
+void
+SPIString::clear() {
+ SPIBase::clear();
+ g_free(_value);
+ _value = nullptr;
+}
+
+void
+SPIString::cascade( const SPIBase* const parent ) {
+ if( const SPIString* p = dynamic_cast<const SPIString*>(parent) ) {
+ if( inherits && (!set || inherit) ) {
+ g_free(_value);
+ _value = g_strdup(p->_value);
+ }
+ } else {
+ std::cerr << "SPIString::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIString::merge( const SPIBase* const parent ) {
+ if( const SPIString* p = dynamic_cast<const SPIString*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ g_free(_value);
+ _value = g_strdup(p->_value);
+ }
+ }
+ }
+}
+
+bool
+SPIString::operator==(const SPIBase& rhs) const {
+ if( const SPIString* r = dynamic_cast<const SPIString*>(&rhs) ) {
+ return g_strcmp0(_value, r->_value) == 0 && SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+// SPIShapes ------------------------------------------------------------
+
+SPIShapes::~SPIShapes() {
+ hrefs_clear();
+}
+
+SPIShapes::SPIShapes()
+ : SPIString(false)
+{
+}
+
+/**
+ * Check if a Shape object exists in the selection
+ * Needed for when user selects multiple objects and
+ * * transforms them all simultaneously
+ * ie. Flowed text and a Rectangle (See issue 1029)
+ *
+ * \param the ObjectSet to search
+ * \return true if found, else false
+ */
+bool SPIShapes::containsAnyShape(Inkscape::ObjectSet *set) {
+ for (auto ref : hrefs) {
+ if (set->includes(ref->getObject())) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// Used to add/remove listeners for text wrapped in shapes.
+// Note: this is done differently than for patterns, etc. where presentation attributes can be used.
+// 'shape-inside' and 'shape-subtract' are only properties.
+void
+SPIShapes::read( gchar const *str) {
+
+ if (!style) {
+ std::cerr << "SPIShapes::read: no style!" << std::endl;
+ return;
+ }
+
+ if( !str ) return;
+
+ SPIString::read(str);
+ assert(set);
+
+ // The object/repr this property is connected to..
+ SPObject* object = style->object;
+ if (!object) {
+ std::cout << " No object" << std::endl;
+ return;
+ }
+
+ // clear(); // Already cleared! (In SPStyle::read.) Calling again causes segfault.
+
+ // Add new listeners
+ std::vector<Glib::ustring> shapes_url = Glib::Regex::split_simple(" ", str);
+ for (auto shape_url : shapes_url) {
+ if ( shape_url.compare(0,5,"url(#") != 0 || shape_url.compare(shape_url.size()-1,1,")") != 0 ){
+ std::cerr << "SPIShapes::read: Invalid shape value: " << shape_url << std::endl;
+ } else {
+ auto uri = extract_uri(shape_url.c_str()); // Do before we erase "url(#"
+
+ // This ups the href count of the shape. This is required so that vacuuming a
+ // document does not delete shapes stored in <defs>.
+ SPShapeReference *href = new SPShapeReference(object);
+
+ if (href->try_attach(uri.c_str())) {
+ hrefs.emplace_back(href);
+ } else {
+ delete href;
+ }
+ }
+ }
+}
+
+void
+SPIShapes::clear() {
+
+ SPIBase::clear();
+
+ hrefs_clear();
+}
+
+void SPIShapes::hrefs_clear()
+{
+ for (auto href : hrefs) {
+ delete href;
+ }
+ hrefs.clear();
+}
+
+// SPIColor -------------------------------------------------------------
+
+// Used for 'color', 'text-decoration-color', 'flood-color', 'lighting-color', and 'stop-color'.
+// (The last three have yet to be implemented.)
+// CSS3: 'currentcolor' is allowed value and is equal to inherit for the 'color' property.
+// FIXME: We should preserve named colors, hsl colors, etc.
+void SPIColor::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ set = false;
+ inherit = false;
+ currentcolor = false;
+ if ( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else if ( !strcmp(str, "currentColor") ) {
+ set = true;
+ currentcolor = true;
+ if (id() == SPAttr::COLOR) {
+ inherit = true; // CSS3
+ } else if (style) {
+ setColor( style->color.value.color );
+ } else {
+ std::cerr << "SPIColor::read(): value is 'currentColor' but 'color' not available." << std::endl;
+ }
+ } else {
+ guint32 const rgb0 = sp_svg_read_color(str, 0xff);
+ if (rgb0 != 0xff) {
+ setColor(rgb0);
+ set = true;
+ }
+ }
+}
+
+const Glib::ustring SPIColor::get_value() const
+{
+ // currentcolor goes first to handle special case for 'color' property
+ if (this->currentcolor) return Glib::ustring("currentColor");
+ if (this->inherit) return Glib::ustring("inherit");
+ return this->value.color.toString();
+}
+
+void
+SPIColor::cascade( const SPIBase* const parent ) {
+ if( const SPIColor* p = dynamic_cast<const SPIColor*>(parent) ) {
+ if( (inherits && !set) || inherit) { // FIXME verify for 'color'
+ if( !(inherit && currentcolor) ) currentcolor = p->currentcolor;
+ setColor( p->value.color );
+ } else {
+ // Add CSS4 Color: Lighter, Darker
+ }
+ } else {
+ std::cerr << "SPIColor::cascade(): Incorrect parent type" << std::endl;
+ }
+
+}
+
+void
+SPIColor::merge( const SPIBase* const parent ) {
+ if( const SPIColor* p = dynamic_cast<const SPIColor*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ currentcolor = p->currentcolor;
+ value.color = p->value.color;
+ }
+ }
+ }
+}
+
+bool
+SPIColor::operator==(const SPIBase& rhs) const {
+ if( const SPIColor* r = dynamic_cast<const SPIColor*>(&rhs) ) {
+
+ if ( (this->currentcolor != r->currentcolor ) ||
+ (this->value.color != r->value.color ) ||
+ (this->value.color.icc != r->value.color.icc ) ||
+ (this->value.color.icc && r->value.color.icc &&
+ this->value.color.icc->colorProfile != r->value.color.icc->colorProfile &&
+ this->value.color.icc->colors != r->value.color.icc->colors ) ) {
+ return false;
+ }
+
+ return SPIBase::operator==(rhs);
+
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIPaint -------------------------------------------------------------
+
+// Paint is used for 'fill' and 'stroke'. SPIPaint perhaps should be derived from SPIColor.
+// 'style' is set in SPStyle::SPStyle or in the legacy SPIPaint::read( gchar, style, document )
+// It is needed for computed value when value is 'currentColor'. It is also needed to
+// find the object for creating an href (this is done through document but should be done
+// directly so document not needed.. FIXME).
+
+SPIPaint::~SPIPaint() {
+ if( value.href ) {
+ clear();
+ delete value.href;
+ value.href = nullptr;
+ }
+}
+
+/**
+ * Set SPIPaint object from string.
+ *
+ * \pre paint == \&style.fill || paint == \&style.stroke.
+ */
+void
+SPIPaint::read( gchar const *str ) {
+
+ // std::cout << "SPIPaint::read: Entrance: " << " |" << (str?str:"null") << "|" << std::endl;
+ // if( style ) {
+ // std::cout << " document: " << (void*)style->document << std::endl;
+ // std::cout << " object: " << (style->object?"present":"null") << std::endl;
+ // if( style->object )
+ // std::cout << " : " << (style->object->getId()?style->object->getId():"no ID")
+ // << " document: " << (style->object->document?"yes":"no") << std::endl;
+ // }
+
+ if(!str ) return;
+
+ reset( false ); // Do not init
+
+ // Is this necessary?
+ while (g_ascii_isspace(*str)) {
+ ++str;
+ }
+
+ if (streq(str, "inherit")) {
+ set = true;
+ inherit = true;
+ } else {
+ // Read any URL first. The other values can be stand-alone or backup to the URL.
+
+ if ( strneq(str, "url", 3) ) {
+
+ // FIXME: THE FOLLOWING CODE SHOULD BE PUT IN A PRIVATE FUNCTION FOR REUSE
+ auto uri = extract_uri(str, &str); // std::string
+ if(uri.empty()) {
+ std::cerr << "SPIPaint::read: url is empty or invalid" << std::endl;
+ } else if (!style ) {
+ std::cerr << "SPIPaint::read: url with empty SPStyle pointer" << std::endl;
+ } else {
+ set = true;
+ SPDocument *document = (style->object) ? style->object->document : nullptr;
+
+ // Create href if not done already
+ if (!value.href) {
+
+ if (style->object) {
+ value.href = new SPPaintServerReference(style->object);
+ } else if (document) {
+ value.href = new SPPaintServerReference(document);
+ } else {
+ std::cerr << "SPIPaint::read: No valid object or document!" << std::endl;
+ return;
+ }
+
+ if (this == &style->fill) {
+ style->fill_ps_changed_connection = value.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_fill_paint_server_ref_changed), style));
+ } else {
+ style->stroke_ps_changed_connection = value.href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_stroke_paint_server_ref_changed), style));
+ }
+ }
+
+ // TODO check what this does in light of move away from union
+ sp_style_set_ipaint_to_uri_string(style, this, uri.c_str());
+ }
+ }
+
+ while ( g_ascii_isspace(*str) ) {
+ ++str;
+ }
+
+ if (streq(str, "currentColor")) {
+ set = true;
+ paintOrigin = SP_CSS_PAINT_ORIGIN_CURRENT_COLOR;
+ if (style) {
+ setColor( style->color.value.color );
+ } else {
+ // Normally an SPIPaint is part of an SPStyle and the value of 'color' is
+ // available. SPIPaint can be used 'stand-alone' (e.g. to parse color values) in
+ // which case a value of 'currentColor' is meaningless, thus we shouldn't reach
+ // here.
+ std::cerr << "SPIPaint::read(): value is 'currentColor' but 'color' not available." << std::endl;
+ setColor( 0 );
+ }
+ } else if (streq(str, "context-fill")) {
+ set = true;
+ paintOrigin = SP_CSS_PAINT_ORIGIN_CONTEXT_FILL;
+ } else if (streq(str, "context-stroke")) {
+ set = true;
+ paintOrigin = SP_CSS_PAINT_ORIGIN_CONTEXT_STROKE;
+ } else if (streq(str, "none")) {
+ set = true;
+ noneSet = true;
+ } else {
+ guint32 const rgb0 = sp_svg_read_color(str, &str, 0xff);
+ if (rgb0 != 0xff) {
+ setColor( rgb0 );
+ set = true;
+
+ while (g_ascii_isspace(*str)) {
+ ++str;
+ }
+ if (strneq(str, "icc-color(", 10)) {
+ SVGICCColor* tmp = new SVGICCColor();
+ if ( ! sp_svg_read_icc_color( str, &str, tmp ) ) {
+ delete tmp;
+ tmp = nullptr;
+ }
+ value.color.icc = tmp;
+ }
+ }
+ }
+ }
+}
+
+// Stand-alone read (Legacy read()), used multiple places, e.g. sp-stop.cpp
+// This function should not be necessary. FIXME
+void
+SPIPaint::read( gchar const *str, SPStyle &style_in, SPDocument *document_in ) {
+ style = &style_in;
+ style->document = document_in;
+ read( str );
+}
+
+const Glib::ustring SPIPaint::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->noneSet) return Glib::ustring("none");
+ // url must go first as other values can serve as fallbacks
+ auto ret = Glib::ustring("");
+ if (this->value.href && this->value.href->getURI()) {
+ ret += this->value.href->getURI()->cssStr();
+ }
+ switch(this->paintOrigin) {
+ case SP_CSS_PAINT_ORIGIN_CURRENT_COLOR:
+ if (!ret.empty()) ret += " ";
+ ret += "currentColor";
+ break;
+ case SP_CSS_PAINT_ORIGIN_CONTEXT_FILL:
+ if (!ret.empty()) ret += " ";
+ ret += "context-fill";
+ break;
+ case SP_CSS_PAINT_ORIGIN_CONTEXT_STROKE:
+ if (!ret.empty()) ret += " ";
+ ret += "context-stroke";
+ break;
+ case SP_CSS_PAINT_ORIGIN_NORMAL:
+ if (this->colorSet) {
+ char color_buf[8];
+ sp_svg_write_color(color_buf, sizeof(color_buf), this->value.color.toRGBA32(0));
+ if (!ret.empty()) ret += " ";
+ ret += color_buf;
+ }
+ if (this->value.color.icc) {
+ ret += " icc-color(";
+ ret += this->value.color.icc->colorProfile;
+ for(auto i: this->value.color.icc->colors) {
+ ret += ", " + Glib::ustring::format(i);
+ }
+ ret += ")";
+ }
+ break;
+ }
+ return ret;
+}
+
+void
+SPIPaint::clear() {
+ // std::cout << "SPIPaint::clear(): " << name << std::endl;
+ reset( true ); // Reset and Init
+}
+
+void
+SPIPaint::reset( bool init ) {
+
+ // std::cout << "SPIPaint::reset(): " << name << " " << init << std::endl;
+ SPIBase::clear();
+ paintOrigin = SP_CSS_PAINT_ORIGIN_NORMAL;
+ colorSet = false;
+ noneSet = false;
+ value.color.set( false );
+ tag = nullptr;
+ if (value.href){
+ if (value.href->getObject()) {
+ value.href->detach();
+ }
+ }
+ if( init ) {
+ if (id() == SPAttr::FILL) {
+ // 'black' is default for 'fill'
+ setColor(0.0, 0.0, 0.0);
+ } else if (id() == SPAttr::TEXT_DECORATION_COLOR) {
+ // currentcolor = true;
+ }
+ }
+}
+
+void
+SPIPaint::cascade( const SPIBase* const parent ) {
+
+ // std::cout << "SPIPaint::cascade" << std::endl;
+ if( const SPIPaint* p = dynamic_cast<const SPIPaint*>(parent) ) {
+ if (!set || inherit) { // Always inherits
+
+ reset( false ); // Do not init
+
+ if( p->isPaintserver() ) {
+ if( p->value.href) {
+ // Why can we use p->document ?
+ sp_style_set_ipaint_to_uri( style, this, p->value.href->getURI(), p->value.href->getOwnerDocument());
+ } else {
+ std::cerr << "SPIPaint::cascade: Expected paint server not found." << std::endl;
+ }
+ } else if( p->isColor() ) {
+ setColor( p->value.color );
+ } else if( p->isNoneSet() ) {
+ noneSet = true;
+ } else if( p->paintOrigin == SP_CSS_PAINT_ORIGIN_CURRENT_COLOR ) {
+ paintOrigin = SP_CSS_PAINT_ORIGIN_CURRENT_COLOR;
+ setColor( style->color.value.color );
+ } else if( isNone() ) {
+ //
+ } else {
+ g_assert_not_reached();
+ }
+ } else {
+ if( paintOrigin == SP_CSS_PAINT_ORIGIN_CURRENT_COLOR ) {
+ // Update in case color value changed.
+ setColor( style->color.value.color );
+ }
+ }
+
+ } else {
+ std::cerr << "SPIPaint::cascade(): Incorrect parent type" << std::endl;
+ }
+
+}
+
+void
+SPIPaint::merge( const SPIBase* const parent ) {
+ if( const SPIPaint* p = dynamic_cast<const SPIPaint*>(parent) ) {
+ // if( inherits ) { Paint always inherits
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ this->cascade( parent ); // Must call before setting 'set'
+ set = p->set;
+ inherit = p->inherit;
+ }
+ }
+}
+
+bool
+SPIPaint::operator==(const SPIBase& rhs) const {
+
+ if( const SPIPaint* r = dynamic_cast<const SPIPaint*>(&rhs) ) {
+
+ if ( (this->isColor() != r->isColor() ) ||
+ (this->isPaintserver() != r->isPaintserver() ) ||
+ (this->paintOrigin != r->paintOrigin ) ) {
+ return false;
+ }
+
+ if ( this->isPaintserver() ) {
+ if( this->value.href == nullptr || r->value.href == nullptr ||
+ this->value.href->getObject() != r->value.href->getObject() ) {
+ return false;
+ }
+ }
+
+ if ( this->isColor() ) {
+ if ( (this->value.color != r->value.color ) ||
+ (this->value.color.icc != r->value.color.icc ) ||
+ (this->value.color.icc && r->value.color.icc &&
+ this->value.color.icc->colorProfile != r->value.color.icc->colorProfile &&
+ this->value.color.icc->colors != r->value.color.icc->colors ) ) {
+ return false;
+ }
+ }
+
+ return SPIBase::operator==(rhs);
+
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIPaintOrder --------------------------------------------------------
+
+void
+SPIPaintOrder::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ g_free(value);
+ set = false;
+ inherit = false;
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ } else {
+ set = true;
+ value = g_strdup(str);
+
+ if (!strcmp(value, "normal")) {
+ layer[0] = SP_CSS_PAINT_ORDER_NORMAL;
+ layer_set[0] = true;
+ } else {
+ // This certainly can be done more efficiently
+ gchar** c = g_strsplit(value, " ", PAINT_ORDER_LAYERS + 1);
+ bool used[3] = {false, false, false};
+ unsigned int i = 0;
+ for( ; i < PAINT_ORDER_LAYERS; ++i ) {
+ if( c[i] ) {
+ layer_set[i] = false;
+ if( !strcmp( c[i], "fill")) {
+ layer[i] = SP_CSS_PAINT_ORDER_FILL;
+ layer_set[i] = true;
+ used[0] = true;
+ } else if( !strcmp( c[i], "stroke")) {
+ layer[i] = SP_CSS_PAINT_ORDER_STROKE;
+ layer_set[i] = true;
+ used[1] = true;
+ } else if( !strcmp( c[i], "markers")) {
+ layer[i] = SP_CSS_PAINT_ORDER_MARKER;
+ layer_set[i] = true;
+ used[2] = true;
+ } else {
+ std::cerr << "sp_style_read_ipaintorder: illegal value: " << c[i] << std::endl;
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+ g_strfreev(c);
+
+ // Fill out rest of the layers using the default order
+ if( !used[0] && i < PAINT_ORDER_LAYERS ) {
+ layer[i] = SP_CSS_PAINT_ORDER_FILL;
+ layer_set[i] = false;
+ ++i;
+ }
+ if( !used[1] && i < PAINT_ORDER_LAYERS ) {
+ layer[i] = SP_CSS_PAINT_ORDER_STROKE;
+ layer_set[i] = false;
+ ++i;
+ }
+ if( !used[2] && i < PAINT_ORDER_LAYERS ) {
+ layer[i] = SP_CSS_PAINT_ORDER_MARKER;
+ layer_set[i] = false;
+ }
+ }
+ }
+}
+
+const Glib::ustring SPIPaintOrder::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ auto ret = Glib::ustring("");
+ for( unsigned i = 0; i < PAINT_ORDER_LAYERS; ++i ) {
+ if (layer_set[i]) {
+ if (!ret.empty()) ret += " ";
+ switch (this->layer[i]) {
+ case SP_CSS_PAINT_ORDER_NORMAL:
+ ret += "normal";
+ assert( i == 0 );
+ break;
+ case SP_CSS_PAINT_ORDER_FILL:
+ ret += "fill";
+ break;
+ case SP_CSS_PAINT_ORDER_STROKE:
+ ret += "stroke";
+ break;
+ case SP_CSS_PAINT_ORDER_MARKER:
+ ret += "markers";
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+ return ret;
+}
+
+void
+SPIPaintOrder::cascade( const SPIBase* const parent ) {
+ if( const SPIPaintOrder* p = dynamic_cast<const SPIPaintOrder*>(parent) ) {
+ if (!set || inherit) { // Always inherits
+ for( unsigned i = 0; i < PAINT_ORDER_LAYERS; ++i ) {
+ layer[i] = p->layer[i];
+ layer_set[i] = p->layer_set[i];
+ }
+ g_free( value );
+ value = g_strdup(p->value);
+ }
+ } else {
+ std::cerr << "SPIPaintOrder::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIPaintOrder::merge( const SPIBase* const parent ) {
+ if( const SPIPaintOrder* p = dynamic_cast<const SPIPaintOrder*>(parent) ) {
+ // if( inherits ) { PaintOrder always inherits
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ this->cascade( parent ); // Must call be setting 'set'
+ set = p->set;
+ inherit = p->inherit;
+ }
+ }
+}
+
+bool
+SPIPaintOrder::operator==(const SPIBase& rhs) const {
+ if( const SPIPaintOrder* r = dynamic_cast<const SPIPaintOrder*>(&rhs) ) {
+ if( layer[0] == SP_CSS_PAINT_ORDER_NORMAL &&
+ r->layer[0] == SP_CSS_PAINT_ORDER_NORMAL ) return SPIBase::operator==(rhs);
+ for (unsigned i = 0; i < PAINT_ORDER_LAYERS; ++i ) {
+ if( layer[i] != r->layer[i] ) return false;
+ }
+ return SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIFilter ------------------------------------------------------------
+
+SPIFilter::~SPIFilter() {
+ if( href ) {
+ clear();
+ delete href;
+ href = nullptr;
+ }
+}
+
+void
+SPIFilter::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ clear();
+
+ if ( streq(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else if (streq(str, "none")) {
+ set = true;
+ } else if (strneq(str, "url", 3)) {
+ auto uri = extract_uri(str);
+ if (uri.empty()) {
+ std::cerr << "SPIFilter::read: url is empty or invalid" << std::endl;
+ return;
+ } else if (!style) {
+ std::cerr << "SPIFilter::read: url with empty SPStyle pointer" << std::endl;
+ return;
+ }
+ set = true;
+
+ // Create href if not already done.
+ if (!href) {
+ if (style->object) {
+ href = new SPFilterReference(style->object);
+ }
+ // Do we have href now?
+ if ( href ) {
+ style->filter_changed_connection = href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_filter_ref_changed), style));
+ } else {
+ std::cerr << "SPIFilter::read(): Could not allocate 'href'" << std::endl;
+ return;
+ }
+ }
+
+ // We have href
+ try {
+ href->attach(Inkscape::URI(uri.c_str()));
+ } catch (Inkscape::BadURIException &e) {
+ std::cerr << "SPIFilter::read() " << e.what() << std::endl;
+ delete href;
+ href = nullptr;
+ }
+
+ } else {
+ std::cerr << "SPIFilter::read(): malformed value: " << str << std::endl;
+ }
+}
+
+const Glib::ustring SPIFilter::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->href) return this->href->getURI()->cssStr();
+ return Glib::ustring("");
+}
+
+void
+SPIFilter::clear() {
+
+ SPIBase::clear();
+ if( href ) {
+ if( href->getObject() ) {
+ href->detach();
+ }
+ }
+}
+
+void
+SPIFilter::cascade( const SPIBase* const parent ) {
+ if( const SPIFilter* p = dynamic_cast<const SPIFilter*>(parent) ) {
+ if( inherit ) { // Only inherits if 'inherit' true/
+ // FIXME: This is rather unlikely so ignore for now.
+ (void)p;
+ std::cerr << "SPIFilter::cascade: value 'inherit' not supported." << std::endl;
+ } else {
+ // Do nothing
+ }
+ } else {
+ std::cerr << "SPIFilter::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIFilter::merge( const SPIBase* const parent ) {
+ if( const SPIFilter* p = dynamic_cast<const SPIFilter*>(parent) ) {
+ // The "correct" thing to do is to combine the filter primitives.
+ // The next best thing is to keep any filter on this object. If there
+ // is no filter on this object, then use any filter on the parent.
+ if( (!set || inherit) && p->href && p->href->getObject() ) { // is the getObject() needed?
+ set = p->set;
+ inherit = p->inherit;
+ if( href ) {
+ // If we already have an href, use it (unlikely but heck...)
+ if( href->getObject() ) {
+ href->detach();
+ }
+ } else {
+ // If we don't have an href, create it
+ if( style->document ) { // FIXME
+ href = new SPFilterReference(style->document);
+ //href->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_style_filter_ref_changed), style));
+ } else if (style->object) {
+ href = new SPFilterReference(style->object);
+ }
+ }
+ if( href ) {
+ // If we now have an href, try to attach parent filter
+ try {
+ href->attach(*p->href->getURI());
+ } catch (Inkscape::BadURIException &e) {
+ std::cerr << "SPIFilter::merge: " << e.what() << std::endl;
+ href->detach();
+ }
+ }
+ }
+ }
+}
+
+// FIXME
+bool
+SPIFilter::operator==(const SPIBase& rhs) const {
+ if( const SPIFilter* r = dynamic_cast<const SPIFilter*>(&rhs) ) {
+ (void)r;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIDashArray ---------------------------------------------------------
+
+void
+SPIDashArray::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ set = true;
+
+ if( strcmp( str, "inherit") == 0 ) {
+ inherit = true;
+ return;
+ }
+
+ values.clear();
+
+ if( strcmp(str, "none") == 0) {
+ return;
+ }
+
+ std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("[(,\\s|\\s)]+", str);
+
+ bool LineSolid = true;
+
+ for (auto token : tokens) {
+ SPILength spilength;
+ spilength.read(token.c_str());
+ if (spilength.value > 0.00000001)
+ LineSolid = false;
+ values.push_back(spilength);
+ }
+
+ if (LineSolid) {
+ values.clear();
+ }
+ return;
+}
+
+const Glib::ustring SPIDashArray::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->values.empty()) return Glib::ustring("none");
+ auto ret = Glib::ustring("");
+ for(auto value: this->values) {
+ if (!ret.empty()) ret += ", ";
+ ret += value.toString();
+ }
+ return ret;
+}
+
+void
+SPIDashArray::cascade( const SPIBase* const parent ) {
+ if( const SPIDashArray* p = dynamic_cast<const SPIDashArray*>(parent) ) {
+ if( !set || inherit ) values = p->values; // Always inherits
+ } else {
+ std::cerr << "SPIDashArray::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPIDashArray::merge( const SPIBase* const parent ) {
+ if( const SPIDashArray* p = dynamic_cast<const SPIDashArray*>(parent) ) {
+ if( inherits ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ values = p->values;
+ }
+ }
+ } else {
+ std::cerr << "SPIDashArray::merge(): Incorrect parent type" << std::endl;
+ }
+}
+
+bool
+SPIDashArray::operator==(const SPIBase& rhs) const {
+ if (const SPIDashArray *r = dynamic_cast<const SPIDashArray *>(&rhs)) {
+ if (values.size() != r->values.size()) {
+ return false;
+ }
+ for (int i = 0; i < values.size(); i++) {
+ if (values[i] != r->values[i]) {
+ return false;
+ }
+ }
+ }
+ return SPIBase::operator==(rhs);
+}
+
+
+// SPIFontSize ----------------------------------------------------------
+
+/** Indexed by SP_CSS_FONT_SIZE_blah. These seem a bit small */
+float const SPIFontSize::font_size_table[] = {6.0, 8.0, 10.0, 12.0, 14.0, 18.0, 24.0};
+float const SPIFontSize::font_size_default = 12.0;
+
+void
+SPIFontSize::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ } else if ((*str == 'x') || (*str == 's') || (*str == 'm') || (*str == 'l')) {
+ // xx-small, x-small, etc.
+ for (unsigned i = 0; enum_font_size[i].key; i++) {
+ if (!strcmp(str, enum_font_size[i].key)) {
+ set = true;
+ inherit = false;
+ type = SP_FONT_SIZE_LITERAL;
+ literal = enum_font_size[i].value;
+ return;
+ }
+ }
+ /* Invalid */
+ return;
+ } else {
+ SPILength length;
+ length.set = false;
+ length.read( str );
+ if( length.set ) {
+ set = true;
+ inherit = length.inherit;
+ unit = length.unit;
+ value = length.value;
+ computed = length.computed;
+ /* Set a minimum font size to something much smaller than should ever (ever!) be encountered in a real file.
+ If a bad SVG file is encountered and this is zero odd things
+ might happen because the inverse is used in some scaling actions.
+ */
+ if ( computed <= 1.0e-32 ) { computed = 1.0e-32; }
+ if( unit == SP_CSS_UNIT_PERCENT ) {
+ type = SP_FONT_SIZE_PERCENTAGE;
+ } else {
+ type = SP_FONT_SIZE_LENGTH;
+ }
+ }
+ return;
+ }
+}
+
+const Glib::ustring SPIFontSize::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT);
+ auto ret = Glib::ustring("");
+ switch (this->type) {
+ case SP_FONT_SIZE_LITERAL:
+ for (unsigned i = 0; enum_font_size[i].key; i++) {
+ if (enum_font_size[i].value == static_cast< gint > (this->literal) ) {
+ if (!ret.empty()) ret += " ";
+ ret += enum_font_size[i].key;
+ }
+ }
+ break;
+ case SP_FONT_SIZE_LENGTH:
+ if (prefs->getBool("/options/font/textOutputPx", true)) {
+ unit = SP_CSS_UNIT_PX;
+ }
+ ret += Glib::ustring::format(sp_style_css_size_px_to_units(this->computed, unit));
+ ret += sp_style_get_css_unit_string(unit);
+ break;
+ case SP_FONT_SIZE_PERCENTAGE:
+ return Glib::ustring::format(this->value * 100.0) + "%";
+ default:
+ g_error("Invalid FontSize value, not writing it.");
+ }
+ return ret;
+}
+
+void
+SPIFontSize::cascade( const SPIBase* const parent ) {
+ if( const SPIFontSize* p = dynamic_cast<const SPIFontSize*>(parent) ) {
+ if( !set || inherit ) { // Always inherits
+ computed = p->computed;value = p->value;
+
+
+ // Calculate computed based on parent as needed
+ } else if( type == SP_FONT_SIZE_LITERAL ) {
+ if( literal < SP_CSS_FONT_SIZE_SMALLER ) {
+ computed = font_size_table[ literal ];
+ } else if( literal == SP_CSS_FONT_SIZE_SMALLER ) {
+ computed = p->computed / 1.2;
+ } else if( literal == SP_CSS_FONT_SIZE_LARGER ) {
+ computed = p->computed * 1.2;
+ } else {
+ std::cerr << "SPIFontSize::cascade: Illegal literal value" << std::endl;
+ }
+ } else if( type == SP_FONT_SIZE_PERCENTAGE ) {
+ // Percentage for font size is relative to parent computed (rather than viewport)
+ computed = p->computed * value;
+ } else if( type == SP_FONT_SIZE_LENGTH ) {
+ switch ( unit ) {
+ case SP_CSS_UNIT_EM:
+ /* Relative to parent font size */
+ computed = p->computed * value;
+ break;
+ case SP_CSS_UNIT_EX:
+ /* Relative to parent font size */
+ computed = p->computed * value * 0.5; /* Hack FIXME */
+ break;
+ default:
+ /* No change */
+ break;
+ }
+ }
+ /* Set a minimum font size to something much smaller than should ever (ever!) be encountered in a real file.
+ If a bad SVG file is encountered and this is zero odd things
+ might happen because the inverse is used in some scaling actions.
+ */
+ if ( computed <= 1.0e-32 ) { computed = 1.0e-32; }
+ } else {
+ std::cerr << "SPIFontSize::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+double
+SPIFontSize::relative_fraction() const {
+
+ switch (type) {
+ case SP_FONT_SIZE_LITERAL: {
+ switch (literal) {
+ case SP_CSS_FONT_SIZE_SMALLER:
+ return 5.0 / 6.0;
+
+ case SP_CSS_FONT_SIZE_LARGER:
+ return 6.0 / 5.0;
+
+ default:
+ g_assert_not_reached();
+ }
+ }
+
+ case SP_FONT_SIZE_PERCENTAGE:
+ return value;
+
+ case SP_FONT_SIZE_LENGTH: {
+ switch (unit ) {
+ case SP_CSS_UNIT_EM:
+ return value;
+
+ case SP_CSS_UNIT_EX:
+ return value * 0.5;
+
+ default:
+ g_assert_not_reached();
+ }
+ }
+ }
+ g_assert_not_reached();
+ return 1; // Make -Wreturn-type happy
+}
+
+void
+SPIFontSize::merge( const SPIBase* const parent ) {
+ if( const SPIFontSize* p = dynamic_cast<const SPIFontSize*>(parent) ) {
+ if( p->set && !(p->inherit) ) {
+ // Parent has definined font-size
+ if( (!set || inherit) ) {
+ // Computed value same as parent
+ set = p->set;
+ inherit = p->inherit;
+ type = p->type;
+ unit = p->unit;
+ literal = p->literal;
+ value = p->value;
+ computed = p->computed; // Just to be sure
+ } else if ( type == SP_FONT_SIZE_LENGTH &&
+ unit != SP_CSS_UNIT_EM &&
+ unit != SP_CSS_UNIT_EX ) {
+ // Absolute size, computed value already set
+ } else if ( type == SP_FONT_SIZE_LITERAL &&
+ literal < SP_CSS_FONT_SIZE_SMALLER ) {
+ // Absolute size, computed value already set
+ //g_assert( literal < G_N_ELEMENTS(font_size_table) );
+ g_assert( computed == font_size_table[literal] );
+ } else {
+ // Relative size
+ double const child_frac( relative_fraction() );
+ set = true;
+ inherit = false;
+ computed = p->computed * child_frac;
+
+ if ( ( p->type == SP_FONT_SIZE_LITERAL &&
+ p->literal < SP_CSS_FONT_SIZE_SMALLER ) ||
+ ( p->type == SP_FONT_SIZE_LENGTH &&
+ p->unit != SP_CSS_UNIT_EM &&
+ p->unit != SP_CSS_UNIT_EX ) ) {
+ // Parent absolute size
+ type = SP_FONT_SIZE_LENGTH;
+
+ } else {
+ // Parent relative size
+ double const parent_frac( p->relative_fraction() );
+ if( type == SP_FONT_SIZE_LENGTH ) {
+ // ex/em
+ value *= parent_frac;
+ } else {
+ value = parent_frac * child_frac;
+ type = SP_FONT_SIZE_PERCENTAGE;
+ }
+ }
+ } // Relative size
+ /* Set a minimum font size to something much smaller than should ever (ever!) be encountered in a real file.
+ If a bad SVG file is encountered and this is zero odd things
+ might happen because the inverse is used in some scaling actions.
+ */
+ if ( computed <= 1.0e-32 ) { computed = 1.0e-32; }
+ } // Parent set and not inherit
+ } else {
+ std::cerr << "SPIFontSize::merge(): Incorrect parent type" << std::endl;
+ }
+}
+
+// What about different SVG units?
+bool
+SPIFontSize::operator==(const SPIBase& rhs) const {
+ if( const SPIFontSize* r = dynamic_cast<const SPIFontSize*>(&rhs) ) {
+ if( type != r->type ) { return false;}
+ if( type == SP_FONT_SIZE_LENGTH ) {
+ if( computed != r->computed ) { return false;}
+ } else if (type == SP_FONT_SIZE_LITERAL ) {
+ if( literal != r->literal ) { return false;}
+ } else {
+ if( value != r->value ) { return false;}
+ }
+ return SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIFont ----------------------------------------------------------
+
+void
+SPIFont::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if( !style ) {
+ std::cerr << "SPIFont::read(): style is void" << std::endl;
+ return;
+ }
+
+ if ( !strcmp(str, "inherit") ) {
+ set = true;
+ inherit = true;
+ } else {
+
+ // Break string into white space separated tokens
+ std::stringstream os( str );
+ Glib::ustring param;
+
+ while (os >> param) {
+
+ // CSS is case insensitive but we're comparing against lowercase strings
+ Glib::ustring lparam = param.lowercase();
+
+ if (lparam == "/" ) {
+ // line_height follows... note: font-size already read
+
+ os >> param;
+ lparam = param.lowercase();
+ style->line_height.readIfUnset( lparam.c_str() );
+
+ } else {
+ // Try to parse each property in turn
+
+ decltype(style->font_style) test_style;
+ test_style.read( lparam.c_str() );
+ if( test_style.set ) {
+ style->font_style = test_style;
+ continue;
+ }
+
+ // font-variant (Note: only CSS2.1 value small-caps is valid in shortcut.)
+ decltype(style->font_variant) test_variant;
+ test_variant.read( lparam.c_str() );
+ if( test_variant.set ) {
+ style->font_variant = test_variant;
+ continue;
+ }
+
+ // font-weight
+ decltype(style->font_weight) test_weight;
+ test_weight.read( lparam.c_str() );
+ if( test_weight.set ) {
+ style->font_weight = test_weight;
+ continue;
+ }
+
+ // font-stretch (added in CSS 3 Fonts)
+ decltype(style->font_stretch) test_stretch;
+ test_stretch.read( lparam.c_str() );
+ if( test_stretch.set ) {
+ style->font_stretch = test_stretch;
+ continue;
+ }
+
+ // font-size
+ decltype(style->font_size) test_size;
+ test_size.read( lparam.c_str() );
+ if( test_size.set ) {
+ style->font_size = test_size;
+ continue;
+ }
+
+ // No valid property value found.
+ break;
+ }
+ } // params
+
+ // The rest must be font-family...
+ std::string str_s = str; // Why this extra step?
+ std::string family = str_s.substr( str_s.find( param ) );
+
+ style->font_family.readIfUnset( family.c_str() );
+
+ // Everything in shorthand is set per CSS rules, this works since
+ // properties are read backwards from end to start.
+ style->font_style.set = true;
+ style->font_variant.set = true;
+ style->font_weight.set = true;
+ style->font_stretch.set = true;
+ style->font_size.set = true;
+ style->line_height.set = true;
+ style->font_family.set = true;
+ // style->font_size_adjust.set = true;
+ // style->font_kerning.set = true;
+ // style->font_language_override.set = true;;
+ }
+}
+
+const Glib::ustring SPIFont::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ // At the moment, do nothing. We could add a preference to write out
+ // 'font' shorthand rather than longhand properties.
+ /* SPIFontSize const *const my_base = dynamic_cast<const SPIFontSize*>(base);
+ if ( (flags & SP_STYLE_FLAG_ALWAYS) ||
+ ((flags & SP_STYLE_FLAG_IFSET) && this->set) ||
+ ((flags & SP_STYLE_FLAG_IFDIFF) && this->set
+ && (!my_base->set || this != my_base )))
+ {
+ }*/
+
+ return Glib::ustring("");
+}
+
+// void
+// SPIFont::cascade( const SPIBase* const parent ) {
+// }
+
+// void
+// SPIFont::merge( const SPIBase* const parent ) {
+// }
+
+// Does nothing...
+bool
+SPIFont::operator==(const SPIBase& rhs) const {
+ if( /* const SPIFont* r = */ dynamic_cast<const SPIFont*>(&rhs) ) {
+ return SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPIBaselineShift -----------------------------------------------------
+
+void
+SPIBaselineShift::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ } else if ((*str == 'b') || (*str == 's')) {
+ // baseline or sub or super
+ for (unsigned i = 0; enum_baseline_shift[i].key; i++) {
+ if (!strcmp(str, enum_baseline_shift[i].key)) {
+ set = true;
+ inherit = false;
+ type = SP_BASELINE_SHIFT_LITERAL;
+ literal = enum_baseline_shift[i].value;
+ return;
+ }
+ }
+ /* Invalid */
+ return;
+ } else {
+ SPILength length;
+ length.read( str );
+ set = length.set;
+ inherit = length.inherit;
+ unit = length.unit;
+ value = length.value;
+ computed = length.computed;
+ if( unit == SP_CSS_UNIT_PERCENT ) {
+ type = SP_BASELINE_SHIFT_PERCENTAGE;
+ } else {
+ type = SP_BASELINE_SHIFT_LENGTH;
+ }
+ return;
+ }
+}
+
+const Glib::ustring SPIBaselineShift::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ auto ret = Glib::ustring("");
+ switch (this->type) {
+ case SP_BASELINE_SHIFT_LITERAL:
+ for (unsigned i = 0; enum_baseline_shift[i].key; i++) {
+ if (enum_baseline_shift[i].value == static_cast< gint > (this->literal) ) {
+ if (!ret.empty()) ret += " ";
+ ret += enum_baseline_shift[i].key;
+ }
+ }
+ break;
+ case SP_BASELINE_SHIFT_LENGTH:
+ if( this->unit == SP_CSS_UNIT_EM || this->unit == SP_CSS_UNIT_EX ) {
+ ret += Glib::ustring::format(this->value);
+ ret += (this->unit == SP_CSS_UNIT_EM ? "em" : "ex");
+ } else {
+ // must specify px, see inkscape bug 1221626, mozilla bug 234789
+ ret += Glib::ustring::format(this->computed) + "px";
+ }
+ break;
+ case SP_BASELINE_SHIFT_PERCENTAGE:
+ return Glib::ustring::format(this->value * 100.0) + "%";
+ }
+ return ret;
+}
+
+void
+SPIBaselineShift::cascade( const SPIBase* const parent ) {
+ if( const SPIBaselineShift* p = dynamic_cast<const SPIBaselineShift*>(parent) ) {
+ SPIFontSize *pfont_size = &(p->style->font_size);
+ g_assert( pfont_size != nullptr );
+
+ if( !set || inherit ) {
+ computed = p->computed; // Shift relative to parent shift, corrected below
+ } else if (type == SP_BASELINE_SHIFT_LITERAL) {
+ if( literal == SP_CSS_BASELINE_SHIFT_BASELINE ) {
+ computed = 0; // No change
+ } else if (literal == SP_CSS_BASELINE_SHIFT_SUB ) {
+ // Should use subscript position from font relative to alphabetic baseline
+ // OpenOffice, Adobe: -0.33, Word -0.14, LaTex about -0.2.
+ computed = -0.2 * pfont_size->computed;
+ } else if (literal == SP_CSS_BASELINE_SHIFT_SUPER ) {
+ // Should use superscript position from font relative to alphabetic baseline
+ // OpenOffice, Adobe: 0.33, Word 0.35, LaTex about 0.45.
+ computed = 0.4 * pfont_size->computed;
+ } else {
+ /* Illegal value */
+ }
+ } else if (type == SP_BASELINE_SHIFT_PERCENTAGE) {
+ // Percentage for baseline shift is relative to computed "line-height"
+ // which is just font-size (see SVG1.1 'font').
+ computed = pfont_size->computed * value;
+ } else if (type == SP_BASELINE_SHIFT_LENGTH) {
+ switch (unit) {
+ case SP_CSS_UNIT_EM:
+ computed = value * pfont_size->computed;
+ break;
+ case SP_CSS_UNIT_EX:
+ computed = value * 0.5 * pfont_size->computed;
+ break;
+ default:
+ /* No change */
+ break;
+ }
+ }
+ // baseline-shifts are relative to parent baseline
+ computed += p->computed;
+
+ } else {
+ std::cerr << "SPIBaselineShift::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+// This was not defined in the legacy C code, it needs some serious thinking (but is low priority).
+// FIX ME
+void
+SPIBaselineShift::merge( const SPIBase* const parent ) {
+ if( const SPIBaselineShift* p = dynamic_cast<const SPIBaselineShift*>(parent) ) {
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ value = p->value;
+ }
+ } else {
+ std::cerr << "SPIBaselineShift::merge(): Incorrect parent type" << std::endl;
+ }
+}
+
+// This is not used but we have it for completeness, it has not been tested.
+bool
+SPIBaselineShift::operator==(const SPIBase& rhs) const {
+ if( const SPIBaselineShift* r = dynamic_cast<const SPIBaselineShift*>(&rhs) ) {
+ if( type != r->type ) return false;
+ if( type == SP_BASELINE_SHIFT_LENGTH ) {
+ if( computed != r->computed ) return false;
+ } else if ( type == SP_BASELINE_SHIFT_LITERAL ) {
+ if( literal != r->literal ) return false;
+ } else {
+ if( value != r->value ) return false;
+ }
+ return SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+bool
+SPIBaselineShift::isZero() const {
+ if( type == SP_BASELINE_SHIFT_LITERAL ) {
+ if( literal == SP_CSS_BASELINE_SHIFT_BASELINE ) return true;
+ } else {
+ if( value == 0.0 ) return true;
+ }
+ return false;
+}
+
+
+
+// SPITextDecorationLine ------------------------------------------------
+
+void
+SPITextDecorationLine::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ } else if (!strcmp(str, "none")) {
+ set = true;
+ inherit = false;
+ underline = false;
+ overline = false;
+ line_through = false;
+ blink = false;
+ } else {
+ bool found_one = false;
+ bool hit_one = false;
+
+ // CSS 2 keywords
+ bool found_underline = false;
+ bool found_overline = false;
+ bool found_line_through = false;
+ bool found_blink = false;
+
+ // This method ignores inlineid keys and extra delimiters, so " ,,, blink hello" will set
+ // blink and ignore hello
+ const gchar *hstr = str;
+ while (true) {
+ if (*str == ' ' || *str == ',' || *str == '\0'){
+ int slen = str - hstr;
+ // CSS 2 keywords
+ while(true){ // not really a loop, used to avoid a goto
+ hit_one = true; // most likely we will
+ if ((slen == 9) && strneq(hstr, "underline", slen)){ found_underline = true; break; }
+ if ((slen == 8) && strneq(hstr, "overline", slen)){ found_overline = true; break; }
+ if ((slen == 12) && strneq(hstr, "line-through", slen)){ found_line_through = true; break; }
+ if ((slen == 5) && strneq(hstr, "blink", slen)){ found_blink = true; break; }
+ if ((slen == 4) && strneq(hstr, "none", slen)){ break; }
+
+ hit_one = false; // whatever this thing is, we do not recognize it
+ break;
+ }
+ found_one |= hit_one;
+ if(*str == '\0')break;
+ hstr = str + 1;
+ }
+ str++;
+ }
+ if (found_one) {
+ set = true;
+ inherit = false;
+ underline = found_underline;
+ overline = found_overline;
+ line_through = found_line_through;
+ blink = found_blink;
+ }
+ else {
+ set = false;
+ inherit = false;
+ }
+ }
+}
+
+const Glib::ustring SPITextDecorationLine::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ auto ret = Glib::ustring("");
+ if (underline) ret += "underline ";
+ if (overline) ret += "overline ";
+ if (line_through) ret += "line-through ";
+ if (blink) ret += "blink "; // Deprecated
+ if (ret.empty()) {
+ ret = "none";
+ } else {
+ assert(ret.raw().back() == ' ');
+ ret.resize(ret.size() - 1);
+ }
+ return ret;
+}
+
+void
+SPITextDecorationLine::cascade( const SPIBase* const parent ) {
+ if( const SPITextDecorationLine* p = dynamic_cast<const SPITextDecorationLine*>(parent) ) {
+ if( inherits && (!set || inherit) ) {
+ underline = p->underline;
+ overline = p->overline;
+ line_through = p->line_through;
+ blink = p->blink;
+ }
+ } else {
+ std::cerr << "SPITextDecorationLine::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPITextDecorationLine::merge( const SPIBase* const parent ) {
+ if( const SPITextDecorationLine* p = dynamic_cast<const SPITextDecorationLine*>(parent) ) {
+ if( inherits ) { // Always inherits... but special rules?
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ underline = p->underline;
+ overline = p->overline;
+ line_through = p->line_through;
+ blink = p->blink;
+ }
+ }
+ }
+}
+
+bool
+SPITextDecorationLine::operator==(const SPIBase& rhs) const {
+ if( const SPITextDecorationLine* r = dynamic_cast<const SPITextDecorationLine*>(&rhs) ) {
+ return
+ (underline == r->underline ) &&
+ (overline == r->overline ) &&
+ (line_through == r->line_through ) &&
+ (blink == r->blink ) &&
+ SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+
+// SPITextDecorationStyle -----------------------------------------------
+
+void
+SPITextDecorationStyle::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ set = false;
+ inherit = false;
+
+ solid = true; // Default
+ isdouble = false;
+ dotted = false;
+ dashed = false;
+ wavy = false;
+
+ if (!strcmp(str, "inherit")) {
+ set = true;
+ inherit = true;
+ solid = false;
+ } else {
+ // note, these are CSS 3 keywords
+ bool found_solid = false;
+ bool found_double = false;
+ bool found_dotted = false;
+ bool found_dashed = false;
+ bool found_wavy = false;
+ bool found_one = false;
+
+ // this method ignores inlineid keys and extra delimiters, so " ,,, style hello" will set style and ignore hello
+ // if more than one style is present, the first is used
+ const gchar *hstr = str;
+ while (true) {
+ if (*str == ' ' || *str == ',' || *str == '\0'){
+ int slen = str - hstr;
+ if ( (slen == 5) && strneq(hstr, "solid", slen)){ found_solid = true; found_one = true; break; }
+ else if ((slen == 6) && strneq(hstr, "double", slen)){ found_double = true; found_one = true; break; }
+ else if ((slen == 6) && strneq(hstr, "dotted", slen)){ found_dotted = true; found_one = true; break; }
+ else if ((slen == 6) && strneq(hstr, "dashed", slen)){ found_dashed = true; found_one = true; break; }
+ else if ((slen == 4) && strneq(hstr, "wavy", slen)){ found_wavy = true; found_one = true; break; }
+ if(*str == '\0')break; // nothing more to test
+ hstr = str + 1;
+ }
+ str++;
+ }
+ if(found_one){
+ set = true;
+ solid = found_solid;
+ isdouble = found_double;
+ dotted = found_dotted;
+ dashed = found_dashed;
+ wavy = found_wavy;
+ }
+ else {
+ set = false;
+ inherit = false;
+ }
+ }
+}
+
+const Glib::ustring SPITextDecorationStyle::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->solid) return Glib::ustring("solid");
+ if (this->isdouble) return Glib::ustring("double");
+ if (this->dotted) return Glib::ustring("dotted");
+ if (this->dashed) return Glib::ustring("dashed");
+ if (this->wavy) return Glib::ustring("wavy");
+ g_error("SPITextDecorationStyle::write(): No valid value for property");
+ return Glib::ustring("");
+}
+
+void
+SPITextDecorationStyle::cascade( const SPIBase* const parent ) {
+ if( const SPITextDecorationStyle* p = dynamic_cast<const SPITextDecorationStyle*>(parent) ) {
+ if( inherits && (!set || inherit) ) {
+ solid = p->solid;
+ isdouble = p->isdouble;
+ dotted = p->dotted;
+ dashed = p->dashed;
+ wavy = p->wavy;
+ }
+ } else {
+ std::cerr << "SPITextDecorationStyle::cascade(): Incorrect parent type" << std::endl;
+ }
+}
+
+void
+SPITextDecorationStyle::merge( const SPIBase* const parent ) {
+ if( const SPITextDecorationStyle* p = dynamic_cast<const SPITextDecorationStyle*>(parent) ) {
+ if( inherits ) { // Always inherits... but special rules?
+ if( (!set || inherit) && p->set && !(p->inherit) ) {
+ set = p->set;
+ inherit = p->inherit;
+ solid = p->solid;
+ isdouble = p->isdouble;
+ dotted = p->dotted;
+ dashed = p->dashed;
+ wavy = p->wavy;
+ }
+ }
+ }
+}
+
+bool
+SPITextDecorationStyle::operator==(const SPIBase& rhs) const {
+ if( const SPITextDecorationStyle* r = dynamic_cast<const SPITextDecorationStyle*>(&rhs) ) {
+ return
+ (solid == r->solid ) &&
+ (isdouble == r->isdouble ) &&
+ (dotted == r->dotted ) &&
+ (dashed == r->dashed ) &&
+ (wavy == r->wavy ) &&
+ SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+
+
+// TextDecorationColor is handled by SPIPaint (should be SPIColor), default value is "currentColor"
+// FIXME
+
+
+
+// SPITextDecoration ----------------------------------------------------
+
+void
+SPITextDecoration::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ bool is_css3 = false;
+
+ decltype(style->text_decoration_line) test_line;
+ test_line.read( str );
+ if( test_line.set ) {
+ if (!style->text_decoration_line.set) {
+ style->text_decoration_line = test_line;
+ }
+ set = true;
+ }
+
+ decltype(style->text_decoration_style) test_style;
+ test_style.read( str );
+ if( test_style.set ) {
+ style->text_decoration_style = test_style;
+ is_css3 = true;
+ }
+
+ // the color routine must be fed one token at a time - if multiple colors are found the LAST
+ // one is used ???? then why break on set?
+
+ // This could certainly be designed better
+ decltype(style->text_decoration_color) test_color;
+ test_color.setStylePointer( style );
+ test_color.read( "currentColor" ); // Default value
+ test_color.set = false;
+ const gchar *hstr = str;
+ while (true) {
+ if (*str == ' ' || *str == ',' || *str == '\0'){
+ int slen = str - hstr;
+ gchar *frag = g_strndup(hstr,slen+1); // only send one piece at a time, since keywords may be intermixed
+
+ if( strcmp( frag, "none" ) != 0 ) { // 'none' not allowed
+ test_color.read( frag );
+ }
+
+ free(frag);
+ if( test_color.set ) {
+ style->text_decoration_color = test_color;
+ is_css3 = true;
+ break;
+ }
+ test_color.read( "currentColor" ); // Default value
+ test_color.set = false;
+ if( *str == '\0' )break;
+ hstr = str + 1;
+ }
+ str++;
+ }
+
+ // If we read a style or color then we have CSS3 which require any non-set values to be
+ // set to their default values.
+ if( is_css3 ) {
+ style->text_decoration_line.set = true;
+ style->text_decoration_style.set = true;
+ style->text_decoration_color.set = true;
+ set = true;
+ }
+
+ // If we set text_decoration_line, then update style_td (for CSS2 text-decoration)
+ if( style->text_decoration_line.set ) {
+ style_td = style;
+ }
+}
+
+// Returns CSS2 'text-decoration' (using settings in SPTextDecorationLine)
+// This is required until all SVG renderers support CSS3 'text-decoration'
+const Glib::ustring SPITextDecoration::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ return style->text_decoration_line.get_value();
+}
+const Glib::ustring
+SPITextDecoration::write( guint const flags, SPStyleSrc const &style_src_req, SPIBase const *const base) const {
+ SPITextDecoration const *const my_base = dynamic_cast<const SPITextDecoration*>(base);
+ assert(!base || my_base);
+ // proxy for text-decoration-line, but only if set
+ if (set && style &&
+ style->text_decoration_line.shall_write(flags, style_src_req,
+ my_base ? &my_base->style->text_decoration_line : nullptr)) {
+ return (name() + ":" + this->get_value() + important_str() + ";");
+ }
+ return Glib::ustring("");
+}
+
+void
+SPITextDecoration::cascade( const SPIBase* const parent ) {
+ if( const SPITextDecoration* p = dynamic_cast<const SPITextDecoration*>(parent) ) {
+ if( style_td == nullptr ) {
+ style_td = p->style_td;
+ }
+ } else {
+ std::cerr << "SPITextDecoration::cascade(): Incorrect parent type" << std::endl;
+ }
+
+}
+
+void
+SPITextDecoration::merge( const SPIBase* const parent ) {
+ if( const SPITextDecoration* p = dynamic_cast<const SPITextDecoration*>(parent) ) {
+ if( style_td == nullptr ) {
+ style_td = p->style_td;
+ }
+ } else {
+ std::cerr << "SPITextDecoration::merge(): Incorrect parent type" << std::endl;
+ }
+
+}
+
+// Use CSS2 value
+bool
+SPITextDecoration::operator==(const SPIBase& rhs) const {
+ if( const SPITextDecoration* r = dynamic_cast<const SPITextDecoration*>(&rhs) ) {
+ return (style->text_decoration_line == r->style->text_decoration_line &&
+ SPIBase::operator==(rhs));
+ } else {
+ return false;
+ }
+}
+
+// SPIVectorEffect ------------------------------------------------
+
+void
+SPIVectorEffect::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ if (!strcmp(str, "none")) {
+ set = true;
+ stroke = false;
+ size = false;
+ rotate = false;
+ fixed = false;
+ } else {
+ bool found_one = false;
+ bool hit_one = false;
+
+ bool found_stroke = false;
+ bool found_size = false;
+ bool found_rotate = false;
+ bool found_fixed = false;
+
+ const gchar *hstr = str;
+ while (true) {
+ if (*str == ' ' || *str == ',' || *str == '\0'){
+ int slen = str - hstr;
+
+ while(true){ // not really a loop, used to avoid a goto
+ hit_one = true; // most likely we will
+ if ((slen == 18) && strneq(hstr, "non-scaling-stroke", slen)){ found_stroke = true; break; }
+ if ((slen == 16) && strneq(hstr, "non-scaling-size", slen)){ found_size = true; break; }
+ if ((slen == 12) && strneq(hstr, "non-rotation", slen)){ found_rotate = true; break; }
+ if ((slen == 14) && strneq(hstr, "fixed-position", slen)){ found_fixed = true; break; }
+ if ((slen == 4) && strneq(hstr, "none", slen)){ break; }
+
+ hit_one = false; // whatever this thing is, we do not recognize it
+ break;
+ }
+ found_one |= hit_one;
+ if(*str == '\0')break;
+ hstr = str + 1;
+ }
+ str++;
+ }
+ if (found_one) {
+ set = true;
+ stroke = found_stroke;
+ size = found_size;
+ rotate = found_rotate;
+ fixed = found_fixed;
+ }
+ else {
+ set = false;
+ }
+ }
+
+ // std::cout << " stroke: " << stroke
+ // << " size: " << size
+ // << " rotate: " << rotate
+ // << " fixed: " << fixed
+ // << std::endl;
+}
+
+const Glib::ustring SPIVectorEffect::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ auto ret = Glib::ustring("");
+ if (this->stroke) ret += " non-scaling-stroke";
+ if (this->size) ret += " non-scaling-size";
+ if (this->rotate) ret += " non-rotation";
+ if (this->fixed) ret += " fixed-position";
+ if (ret.empty()) {
+ ret += "none";
+ } else {
+ ret.erase(0, 1);
+ }
+ return ret;
+}
+
+// Does not inherit!
+// void
+// SPIVectorEffect::cascade( const SPIBase* const parent ) {
+// }
+
+// void
+// SPIVectorEffect::merge( const SPIBase* const parent ) {
+// }
+
+bool
+SPIVectorEffect::operator==(const SPIBase& rhs) const {
+ if( const SPIVectorEffect* r = dynamic_cast<const SPIVectorEffect*>(&rhs) ) {
+ return
+ (stroke == r->stroke) &&
+ (size == r->size ) &&
+ (rotate == r->rotate) &&
+ (fixed == r->fixed ) &&
+ SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+// SPIStrokeExtensions ------------------------------------------------
+
+void
+SPIStrokeExtensions::read( gchar const *str ) {
+
+ if( !str ) return;
+
+ set = false;
+ hairline = false;
+ if (!strcmp(str, "none")) {
+ set = true;
+ } else if (!strcmp(str, "hairline")) {
+ set = true;
+ hairline = true;
+ }
+}
+
+const Glib::ustring SPIStrokeExtensions::get_value() const
+{
+ if (this->inherit) return Glib::ustring("inherit");
+ if (this->hairline) return Glib::ustring("hairline");
+ return Glib::ustring("none");
+}
+
+// Does not inherit!
+// void
+// SPIStrokeExtensions::cascade( const SPIBase* const parent ) {
+// }
+
+// void
+// SPIStrokeExtensions::merge( const SPIBase* const parent ) {
+// }
+
+bool
+SPIStrokeExtensions::operator==(const SPIBase& rhs) const {
+ if( const SPIStrokeExtensions* r = dynamic_cast<const SPIStrokeExtensions*>(&rhs) ) {
+ return
+ (hairline == r->hairline ) &&
+ SPIBase::operator==(rhs);
+ } else {
+ return false;
+ }
+}
+
+// template instantiation
+template class SPIEnum<SPBlendMode>;
+template class SPIEnum<SPColorInterpolation>;
+template class SPIEnum<SPColorRendering>;
+template class SPIEnum<SPCSSBaseline>;
+template class SPIEnum<SPCSSDirection>;
+template class SPIEnum<SPCSSDisplay>;
+template class SPIEnum<SPCSSFontVariantAlternates>;
+template class SPIEnum<SPCSSTextAlign>;
+template class SPIEnum<SPCSSTextOrientation>;
+template class SPIEnum<SPCSSTextTransform>;
+template class SPIEnum<SPCSSWritingMode>;
+template class SPIEnum<SPEnableBackground>;
+template class SPIEnum<SPImageRendering>;
+template class SPIEnum<SPIsolation>;
+template class SPIEnum<SPOverflow>;
+template class SPIEnum<SPShapeRendering>;
+template class SPIEnum<SPStrokeCapType>;
+template class SPIEnum<SPStrokeJoinType>;
+template class SPIEnum<SPTextAnchor>;
+template class SPIEnum<SPTextRendering>;
+template class SPIEnum<SPVisibility>;
+template class SPIEnum<SPWhiteSpace>;
+template class SPIEnum<SPWindRule>;
+template class SPIEnum<SPCSSFontStretch>;
+template class SPIEnum<SPCSSFontStyle>;
+template class SPIEnum<SPCSSFontVariant>;
+template class SPIEnum<SPCSSFontVariantPosition>;
+template class SPIEnum<SPCSSFontVariantCaps>;
+template class SPIEnum<SPCSSFontWeight>;
+template class SPIEnum<uint_least16_t>;
+template class SPIEnum<uint_least8_t>;
+
+
+
+/* ---------------------------- NOTES ----------------------------- */
+
+/*
+ * opacity's effect is cumulative; we set the new value to the combined effect. The default value
+ * for opacity is 1.0, not inherit. stop-opacity also does not inherit. (Note that stroke-opacity
+ * and fill-opacity are quite different from opacity, and don't need any special handling.)
+ *
+ * Cases:
+ * - parent & child were each previously unset, in which case the effective
+ * opacity value is 1.0, and style should remain unset.
+ * - parent was previously unset (so computed opacity value of 1.0)
+ * and child was set to inherit. The merged child should
+ * get a value of 1.0, and shouldn't inherit (lest the new parent
+ * has a different opacity value). Given that opacity's default
+ * value is 1.0 (rather than inherit), we might as well have the
+ * merged child's opacity be unset.
+ * - parent was previously unset (so opacity 1.0), and child was set to a number.
+ * The merged child should retain its existing settings (though it doesn't matter
+ * if we make it unset if that number was 1.0).
+ * - parent was inherit and child was unset. Merged child should be set to inherit.
+ * - parent was inherit and child was inherit. (We can't in general reproduce this
+ * effect (short of introducing a new group), but setting opacity to inherit is rare.)
+ * If the inherited value was strictly between 0.0 and 1.0 (exclusive) then the merged
+ * child's value should be set to the product of the two, i.e. the square of the
+ * inherited value, and should not be marked as inherit. (This decision assumes that it
+ * is more important to retain the effective opacity than to retain the inheriting
+ * effect, and assumes that the inheriting effect either isn't important enough to create
+ * a group or isn't common enough to bother maintaining the code to create a group.) If
+ * the inherited value was 0.0 or 1.0, then marking the merged child as inherit comes
+ * closer to maintaining the effect.
+ * - parent was inherit and child was set to a numerical value. If the child's value
+ * was 1.0, then the merged child should have the same settings as the parent.
+ * If the child's value was 0, then the merged child should also be set to 0.
+ * If the child's value was anything else, then we do the same as for the inherit/inherit
+ * case above: have the merged child set to the product of the two opacities and not
+ * marked as inherit, for the same reasons as for that case.
+ * - parent was set to a value, and child was unset. The merged child should have
+ * parent's settings.
+ * - parent was set to a value, and child was inherit. The merged child should
+ * be set to the product, i.e. the square of the parent's value.
+ * - parent & child are each set to a value. The merged child should be set to the
+ * product.
+ */
+
+
+/*
+ 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 :
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-07 15:02:06 +0000