fixing to trunk

(bzr r12588.1.34)

17 files changed, 442 insertions, 159 deletions

diff --git a/src/svg/CMakeLists.txt b/src/svg/CMakeLists.txt
index 968287895..f9d0bc52d 100644
--- a/src/svg/CMakeLists.txt
+++ b/src/svg/CMakeLists.txt
@@ -7,6 +7,7 @@ set(svg_SRC
 	strip-trailing-zeros.cpp
 	svg-affine.cpp
 	svg-color.cpp
+	svg-angle.cpp
 	svg-length.cpp
 	svg-path.cpp
 	# test-stubs.cpp
@@ -24,6 +25,7 @@ set(svg_SRC
 	svg-color-test.h
 	svg-color.h
 	svg-icc-color.h
+	svg-angle.h
 	svg-length-test.h
 	svg-length.h
 	svg-path-geom-test.h
diff --git a/src/svg/Makefile_insert b/src/svg/Makefile_insert
index cf9bf3fbb..4f82bdd76 100644
--- a/src/svg/Makefile_insert
+++ b/src/svg/Makefile_insert
@@ -13,6 +13,8 @@ ink_common_sources +=	\
 	svg/svg-color.cpp	\
 	svg/svg-color.h 	\
 	svg/svg-icc-color.h \
+	svg/svg-angle.cpp   \
+	svg/svg-angle.h     \
 	svg/svg-length.cpp	\
 	svg/svg-length.h	\
 	svg/svg-path.cpp	\
diff --git a/src/svg/css-ostringstream.h b/src/svg/css-ostringstream.h
index 8cedb0979..2c66dff16 100644
--- a/src/svg/css-ostringstream.h
+++ b/src/svg/css-ostringstream.h
@@ -1,7 +1,6 @@
 #ifndef SVG_CSS_OSTRINGSTREAM_H_INKSCAPE
 #define SVG_CSS_OSTRINGSTREAM_H_INKSCAPE
 
-#include <glib.h>
 #include <sstream>
 
 namespace Inkscape {
@@ -42,8 +41,8 @@ public:
 
 #undef INK_CSS_STR_OP
 
-    gchar const *gcharp() const {
-        return reinterpret_cast<gchar const *>(ostr.str().c_str());
+    char const *gcharp() const {
+        return ostr.str().c_str();
     }
 
     std::string str() const {
diff --git a/src/svg/path-string.h b/src/svg/path-string.h
index 3a891873d..6c7e23017 100644
--- a/src/svg/path-string.h
+++ b/src/svg/path-string.h
@@ -15,10 +15,10 @@
 #ifndef SEEN_INKSCAPE_SVG_PATH_STRING_H
 #define SEEN_INKSCAPE_SVG_PATH_STRING_H
 
+#include <2geom/point.h>
+#include <cstdio>
 #include <glibmm/ustring.h>
 #include <string>
-#include <stdio.h>
-#include <2geom/point.h>
 
 namespace Inkscape {
 
diff --git a/src/svg/stringstream-test.h b/src/svg/stringstream-test.h
index ce32683f8..305cf6b8d 100644
--- a/src/svg/stringstream-test.h
+++ b/src/svg/stringstream-test.h
@@ -37,9 +37,9 @@ public:
         svg_test_float(-0.0625, "-0.0625");
         svg_test_float(30.0, "30");
         svg_test_float(12345678.0, "12345678");
-        svg_test_float(3e9, "3e+09");
-        svg_test_float(-3.5e9, "-3.5e+09");
-        svg_test_float(32768e9, "3.2768e+13");
+        svg_test_float(3e9, "3e+009");
+        svg_test_float(-3.5e9, "-3.5e+009");
+        svg_test_float(32768e9, "3.2768e+013");
         svg_test_float(-10.5, "-10.5");
     }
 
diff --git a/src/svg/stringstream.h b/src/svg/stringstream.h
index d143abee8..c9cfdd601 100644
--- a/src/svg/stringstream.h
+++ b/src/svg/stringstream.h
@@ -1,7 +1,6 @@
 #ifndef INKSCAPE_STRINGSTREAM_H
 #define INKSCAPE_STRINGSTREAM_H
 
-#include <glib.h>
 #include <sstream>
 #include <string>
 
@@ -41,8 +40,8 @@ public:
 
 #undef INK_SVG_STR_OP
 
-    gchar const *gcharp() const {
-        return reinterpret_cast<gchar const *>(ostr.str().c_str());
+    char const *gcharp() const {
+        return ostr.str().c_str();
     }
 
     std::string str() const {
diff --git a/src/svg/svg-affine-test.h b/src/svg/svg-affine-test.h
index 11b9012a8..af670a3a8 100644
--- a/src/svg/svg-affine-test.h
+++ b/src/svg/svg-affine-test.h
@@ -34,8 +34,8 @@ private:
     static char const * const read_fail_tests[25];
     static test_t const write_matrix_tests[2];
     static test_t const write_translate_tests[3];
-    static test_t const write_scale_tests[2];
-    static test_t const write_rotate_tests[2];
+    static test_t const write_scale_tests[3];
+    static test_t const write_rotate_tests[3];
     static test_t const write_skew_tests[3];
 public:
     SvgAffineTest() {
@@ -238,16 +238,18 @@ SvgAffineTest::test_t const SvgAffineTest::write_translate_tests[3] = {
     {"translate(1,1)",Geom::Affine(1,0,0,1,1,1)},
     {"translate(1)",Geom::Affine(1,0,0,1,1,0)},
     {"translate(-1345,0.123)",Geom::Affine(1,0,0,1,-1.345e3,.123)}};
-SvgAffineTest::test_t const SvgAffineTest::write_scale_tests[2] = {
+SvgAffineTest::test_t const SvgAffineTest::write_scale_tests[3] = {
     {"scale(0)",Geom::Affine(0,0,0,0,0,0)},
+    {"scale(7)",Geom::Affine(7,0,0,7,0,0)},
     {"scale(2,3)",Geom::Affine(2,0,0,3,0,0)}};
-SvgAffineTest::test_t const SvgAffineTest::write_rotate_tests[2] = {
+SvgAffineTest::test_t const SvgAffineTest::write_rotate_tests[3] = {
     {"rotate(13)",Geom::Affine(cos(13.*DEGREE),sin(13.*DEGREE),-sin(13.*DEGREE),cos(13.*DEGREE),0,0)},
-    {"rotate(-13,7,11)",Geom::Affine(cos(-13.*DEGREE),sin(-13.*DEGREE),-sin(-13.*DEGREE),cos(-13.*DEGREE),(1-cos(-13.*DEGREE))*7+sin(-13.*DEGREE)*11,(1-cos(-13.*DEGREE))*11-sin(-13.*DEGREE)*7)}};
+    {"rotate(-13,7,11)",Geom::Affine(cos(-13.*DEGREE),sin(-13.*DEGREE),-sin(-13.*DEGREE),cos(-13.*DEGREE),(1-cos(-13.*DEGREE))*7+sin(-13.*DEGREE)*11,(1-cos(-13.*DEGREE))*11-sin(-13.*DEGREE)*7)},
+    {"rotate(-34.5,6.7,89)",Geom::Affine(cos(-34.5*DEGREE),sin(-34.5*DEGREE),-sin(-34.5*DEGREE),cos(-34.5*DEGREE),(1-cos(-34.5*DEGREE))*6.7+sin(-34.5*DEGREE)*89,(1-cos(-34.5*DEGREE))*89-sin(-34.5*DEGREE)*6.7)}};
 SvgAffineTest::test_t const SvgAffineTest::write_skew_tests[3] = {
     {"skewX(30)",Geom::Affine(1,0,tan(30.*DEGREE),1,0,0)},
     {"skewX(-30)",Geom::Affine(1,0,tan(-30.*DEGREE),1,0,0)},
-    {"skewY(390)",Geom::Affine(1,tan(30.*DEGREE),0,1,0,0)}};
+    {"skewY(30)",Geom::Affine(1,tan(30.*DEGREE),0,1,0,0)}};
 
 /*
   Local Variables:
diff --git a/src/svg/svg-affine.cpp b/src/svg/svg-affine.cpp
index 44567a2bd..c853f9930 100644
--- a/src/svg/svg-affine.cpp
+++ b/src/svg/svg-affine.cpp
@@ -162,65 +162,105 @@ sp_svg_transform_write(Geom::Affine const &transform)
     int prec = prefs->getInt("/options/svgoutput/numericprecision", 8);
     int min_exp = prefs->getInt("/options/svgoutput/minimumexponent", -8);
 
-    /* fixme: We could use t1 * t1 + t2 * t2 here instead */
-    if ( Geom::are_near(transform[1], 0.0, e) && Geom::are_near (transform[2], 0.0, e)) {
-        if (Geom::are_near (transform[4], 0.0, e) && Geom::are_near (transform[5], 0.0, e)) {
-            if (Geom::are_near (transform[0], 1.0, e) && Geom::are_near (transform[3], 1.0, e)) {
-                /* We are more or less identity */
-                return NULL;
-            } else {
-                /* We are more or less scale */
-                gchar c[256];
-                unsigned p = 0;
-                strcpy (c + p, "scale(");
-                p += 6;
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[0], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[3], prec, min_exp );
-                c[p++] = ')';
-                c[p] = '\000';
-                g_assert( p <= sizeof(c) );
-                return g_strdup(c);
-            }
+    // Special case: when all fields of the affine are zero,
+    // the optimized transformation is scale(0)
+    if (transform[0] == 0 && transform[1] == 0 && transform[2] == 0 &&
+        transform[3] == 0 && transform[4] == 0 && transform[5] == 0)
+    {
+        return g_strdup("scale(0)");
+    }
+
+    // FIXME legacy C code!
+    // the function sp_svg_number_write_de is stopping me from using a proper C++ string
+
+    gchar c[256]; // string buffer
+    unsigned p = 0; // position in the buffer
+
+    if (transform.isIdentity()) {
+        // We are more or less identity, so no transform attribute needed:
+        return NULL;
+    } else if (transform.isScale()) {
+        // We are more or less a uniform scale
+        strcpy (c + p, "scale(");
+        p += 6;
+        p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[0], prec, min_exp );
+        if (Geom::are_near(transform[0], transform[3], e)) {
+            c[p++] = ')';
+            c[p] = '\000';
         } else {
-            if (Geom::are_near (transform[0], 1.0, e) && Geom::are_near (transform[3], 1.0, e)) {
-                /* We are more or less translate */
-                gchar c[256];
-                unsigned p = 0;
-                strcpy (c + p, "translate(");
-                p += 10;
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[4], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[5], prec, min_exp );
-                c[p++] = ')';
-                c[p] = '\000';
-                g_assert( p <= sizeof(c) );
-                return g_strdup(c);
-            } else {
-                gchar c[256];
-                unsigned p = 0;
-                strcpy (c + p, "matrix(");
-                p += 7;
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[0], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[1], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[2], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[3], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[4], prec, min_exp );
-                c[p++] = ',';
-                p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[5], prec, min_exp );
-                c[p++] = ')';
-                c[p] = '\000';
-                g_assert( p <= sizeof(c) );
-                return g_strdup(c);
-            }
+            c[p++] = ',';
+            p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[3], prec, min_exp );
+            c[p++] = ')';
+            c[p] = '\000';
         }
+    } else if (transform.isTranslation()) {
+        // We are more or less a pure translation
+        strcpy (c + p, "translate(");
+        p += 10;
+        p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[4], prec, min_exp );
+        if (Geom::are_near(transform[5], 0.0, e)) {
+            c[p++] = ')';
+            c[p] = '\000';
+        } else {
+            c[p++] = ',';
+            p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[5], prec, min_exp );
+            c[p++] = ')';
+            c[p] = '\000';
+        }
+    } else if (transform.isRotation()) {
+        // We are more or less a pure rotation
+        strcpy(c + p, "rotate(");
+        p += 7;
+
+        double angle = std::atan2(transform[1], transform[0]) * (180 / M_PI);
+        p += sp_svg_number_write_de(c + p, sizeof(c) - p, angle, prec, min_exp);
+
+        c[p++] = ')';
+        c[p] = '\000';
+    } else if (transform.withoutTranslation().isRotation()) {
+        // Solution found by Johan Engelen
+        // Refer to the matrix in svg-affine-test.h
+
+        // We are a rotation about a special axis
+        strcpy(c + p, "rotate(");
+        p += 7;
+
+        double angle = std::atan2(transform[1], transform[0]) * (180 / M_PI);
+        p += sp_svg_number_write_de(c + p, sizeof(c) - p, angle, prec, min_exp);
+        c[p++] = ',';
+
+        Geom::Affine const& m = transform;
+        double tx = (m[2]*m[5]+m[4]-m[4]*m[3]) / (1-m[3]-m[0]+m[0]*m[3]-m[2]*m[1]);
+        p += sp_svg_number_write_de(c + p, sizeof(c) - p, tx, prec, min_exp);
+
+        c[p++] = ',';
+
+        double ty = (m[1]*tx + m[5]) / (1 - m[3]);
+        p += sp_svg_number_write_de(c + p, sizeof(c) - p, ty, prec, min_exp);
+
+        c[p++] = ')';
+        c[p] = '\000';
+    } else if (transform.isHShear()) {
+        // We are more or less a pure skewX
+        strcpy(c + p, "skewX(");
+        p += 6;
+
+        double angle = atan(transform[2]) * (180 / M_PI);
+        p += sp_svg_number_write_de(c + p, sizeof(c) - p, angle, prec, min_exp);
+
+        c[p++] = ')';
+        c[p] = '\000';
+    } else if (transform.isVShear()) {
+        // We are more or less a pure skewY
+        strcpy(c + p, "skewY(");
+        p += 6;
+
+        double angle = atan(transform[1]) * (180 / M_PI);
+        p += sp_svg_number_write_de(c + p, sizeof(c) - p, angle, prec, min_exp);
+
+        c[p++] = ')';
+        c[p] = '\000';
     } else {
-        gchar c[256];
-        unsigned p = 0;
         strcpy (c + p, "matrix(");
         p += 7;
         p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[0], prec, min_exp );
@@ -236,9 +276,10 @@ sp_svg_transform_write(Geom::Affine const &transform)
         p += sp_svg_number_write_de( c + p, sizeof(c) - p, transform[5], prec, min_exp );
         c[p++] = ')';
         c[p] = '\000';
-        g_assert( p <= sizeof(c) );
-        return g_strdup(c);
     }
+
+    assert(p <= sizeof(c));
+    return g_strdup(c);
 }
 
 
diff --git a/src/svg/svg-angle.cpp b/src/svg/svg-angle.cpp
new file mode 100644
index 000000000..ed5ccd45e
--- /dev/null
+++ b/src/svg/svg-angle.cpp
@@ -0,0 +1,140 @@
+/**
+ *  \file src/svg/svg-angle.cpp
+ *  \brief SVG angle type
+ */
+/*
+ * Authors:
+ *   Tomasz Boczkowski <penginsbacon@gmail.com>
+ *
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <cstring>
+#include <string>
+#include <math.h>
+#include <glib.h>
+
+#include "svg.h"
+#include "stringstream.h"
+#include "svg/svg-angle.h"
+#include "util/units.h"
+
+
+static bool sp_svg_angle_read_lff(gchar const *str, SVGAngle::Unit &unit, float &val, float &computed);
+
+SVGAngle::SVGAngle()
+    : _set(false)
+    , unit(NONE)
+    , value(0)
+    , computed(0)
+{
+}
+
+/* Angle */
+
+bool SVGAngle::read(gchar const *str)
+{
+    if (!str) {
+        return false;
+    }
+
+    SVGAngle::Unit u;
+    float v;
+    float c;
+    if (!sp_svg_angle_read_lff(str, u, v, c)) {
+        return false;
+    }
+
+    _set = true;
+    unit = u;
+    value = v;
+    computed = c;
+
+    return true;
+}
+
+void SVGAngle::unset(SVGAngle::Unit u, float v, float c) {
+    _set = false;
+    unit = u;
+    value = v;
+    computed = c;
+}
+
+void SVGAngle::readOrUnset(gchar const *str, Unit u, float v, float c) {
+    if (!read(str)) {
+        unset(u, v, c);
+    }
+}
+
+static bool sp_svg_angle_read_lff(gchar const *str, SVGAngle::Unit &unit, float &val, float &computed)
+{
+    if (!str) {
+        return false;
+    }
+
+    gchar const *e;
+    float const v = g_ascii_strtod(str, (char **) &e);
+    if (e == str) {
+        return false;
+    }
+
+    if (!e[0]) {
+        /* Unitless (defaults to degrees)*/
+        unit = SVGAngle::NONE;
+        val = v;
+        computed = v;
+        return true;
+    } else if (!g_ascii_isalnum(e[0])) {
+        if (g_ascii_isspace(e[0]) && e[1] && g_ascii_isalpha(e[1])) {
+            return false; // spaces between value and unit are not allowed
+        } else {
+            /* Unitless (defaults to degrees)*/
+            unit = SVGAngle::NONE;
+            val = v;
+            computed = v;
+            return true;
+        }
+    } else {
+        if (strncmp(e, "deg", 3) == 0) {
+            unit = SVGAngle::DEG;
+            val = v;
+            computed = v;
+        } else if (strncmp(e, "grad", 4) == 0) {
+            unit = SVGAngle::GRAD;
+            val = v;
+            computed = Inkscape::Util::Quantity::convert(v, "grad", "°");
+        } else if (strncmp(e, "rad", 3) == 0) {
+            unit = SVGAngle::RAD;
+            val = v;
+            computed = Inkscape::Util::Quantity::convert(v, "rad", "°");
+        } else if (strncmp(e, "turn", 4) == 0) {
+            unit = SVGAngle::TURN;
+            val = v;
+            computed = Inkscape::Util::Quantity::convert(v, "turn", "°");
+        } else {
+            return false;
+        }
+        return true;
+    }
+
+    /* Invalid */
+    return false;
+}
+
+/*
+  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 :
diff --git a/src/svg/svg-angle.h b/src/svg/svg-angle.h
new file mode 100644
index 000000000..966491174
--- /dev/null
+++ b/src/svg/svg-angle.h
@@ -0,0 +1,69 @@
+#ifndef SEEN_SP_SVG_ANGLE_H
+#define SEEN_SP_SVG_ANGLE_H
+
+/**
+ *  \file src/svg/svg-angle.h
+ *  \brief SVG angle type
+ */
+/*
+ * Authors:
+ *   Tomasz Boczkowski <penginsbacon@gmail.com>
+ *
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glib.h>
+
+class SVGAngle
+{
+public:
+    SVGAngle();
+
+    enum Unit {
+        NONE,
+        DEG,
+        GRAD,
+        RAD,
+        TURN,
+        LAST_UNIT = TURN
+    };
+
+    // The object's value is valid / exists in SVG.
+    bool _set;
+
+    // The unit of value.
+    Unit unit;
+
+    // The value of this SVGAngle as found in the SVG.
+    float value;
+
+    // The value in degrees.
+    float computed;
+
+    float operator=(float v) {
+        _set = true;
+        unit = NONE;
+        value = computed = v;
+        return v;
+    }
+
+    bool read(gchar const *str);
+    void unset(Unit u = NONE, float v = 0, float c = 0);
+    void readOrUnset(gchar const *str, Unit u = NONE, float v = 0, float c = 0);
+};
+
+#endif // SEEN_SP_SVG_ANGLE_H
+
+/*
+  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 :
diff --git a/src/svg/svg-color.cpp b/src/svg/svg-color.cpp
index 57f542373..c9f22f8a4 100644
--- a/src/svg/svg-color.cpp
+++ b/src/svg/svg-color.cpp
@@ -173,6 +173,7 @@ static SPSVGColor const sp_svg_color_named[] = {
     { 0xDDA0DD, "plum" },
     { 0xB0E0E6, "powderblue" },
     { 0x800080, "purple" },
+    { 0x663399, "rebeccapurple" },
     { 0xFF0000, "red" },
     { 0xBC8F8F, "rosybrown" },
     { 0x4169E1, "royalblue" },
@@ -309,6 +310,59 @@ static guint32 internal_sp_svg_read_color(gchar const *str, gchar const **end_pt
             *end_ptr = s;
         }
         return val;
+    } else if (strneq(str, "hsl(", 4)) {
+
+        gchar *ptr = (gchar *) str + 4;
+
+        gchar *e; // ptr after read
+
+        double h = g_ascii_strtod(ptr, &e); // Read h (0-360)
+        if (ptr == e) return def; // Read failed
+        ptr = e;
+
+        while (*ptr && g_ascii_isspace(*ptr)) ptr += 1; // Remove any white space
+        if (*ptr != ',') return def; // Need comma
+        ptr += 1;
+        while (*ptr && g_ascii_isspace(*ptr)) ptr += 1; // Remove any white space
+
+        double s = g_ascii_strtod(ptr, &e); // Read s (percent)
+        if (ptr == e) return def; // Read failed
+        ptr = e;
+        while (*ptr && g_ascii_isspace(*ptr)) ptr += 1; // Remove any white space
+        if (*ptr != '%') return def; // Need %
+        ptr += 1;
+
+        while (*ptr && g_ascii_isspace(*ptr)) ptr += 1; // Remove any white space
+        if (*ptr != ',') return def; // Need comma
+        ptr += 1;
+        while (*ptr && g_ascii_isspace(*ptr)) ptr += 1; // Remove any white space
+
+        double l = g_ascii_strtod(ptr, &e); // Read l (percent)
+        if (ptr == e) return def; // Read failed
+        ptr = e;
+        while (*ptr && g_ascii_isspace(*ptr)) ptr += 1; // Remove any white space
+        if (*ptr != '%') return def; // Need %
+        ptr += 1;
+
+        if (end_ptr) {
+            *end_ptr = ptr;
+        }
+
+
+        // Normalize to 0..1
+        h /= 360.0;
+        s /= 100.0;
+        l /= 100.0;
+
+        gfloat rgb[3];
+
+        sp_color_hsl_to_rgb_floatv( rgb, h, s, l );
+
+        val  =  static_cast<guint>(floor(CLAMP(rgb[0], 0.0, 1.0) * 255.9999)) << 24;
+        val |= (static_cast<guint>(floor(CLAMP(rgb[1], 0.0, 1.0) * 255.9999)) << 16);
+        val |= (static_cast<guint>(floor(CLAMP(rgb[2], 0.0, 1.0) * 255.9999)) << 8);
+        return val;
+
     } else {
         gint i;
         if (colors.empty()) {
@@ -457,18 +511,18 @@ sp_svg_create_color_hash()
 
 void icc_color_to_sRGB(SVGICCColor* icc, guchar* r, guchar* g, guchar* b)
 {
-    guchar color_out[4];
-    guchar color_in[4];
     if (icc) {
 g_message("profile name: %s", icc->colorProfile.c_str());
         Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(icc->colorProfile.c_str());
         if ( prof ) {
+            guchar color_out[4] = {0,0,0,0};
             cmsHTRANSFORM trans = prof->getTransfToSRGB8();
             if ( trans ) {
                 std::vector<colorspace::Component> comps = colorspace::getColorSpaceInfo( prof );
 
                 size_t count = CMSSystem::getChannelCount( prof );
                 size_t cap = std::min(count, comps.size());
+                guchar color_in[4];
                 for (size_t i = 0; i < cap; i++) {
                     color_in[i] = static_cast<guchar>((((gdouble)icc->colors[i]) * 256.0) * (gdouble)comps[i].scale);
                     g_message("input[%d]: %d", (int)i, (int)color_in[i]);
diff --git a/src/svg/svg-color.h b/src/svg/svg-color.h
index b8e317e3b..ea0896872 100644
--- a/src/svg/svg-color.h
+++ b/src/svg/svg-color.h
@@ -1,16 +1,15 @@
 #ifndef SVG_SVG_COLOR_H_SEEN
 #define SVG_SVG_COLOR_H_SEEN
 
-#include <glib.h>
-
+typedef unsigned int guint32;
 struct SVGICCColor;
 
-guint32 sp_svg_read_color(gchar const *str, unsigned int dfl);
-guint32 sp_svg_read_color(gchar const *str, gchar const **end_ptr, guint32 def);
+guint32 sp_svg_read_color(char const *str, unsigned int dfl);
+guint32 sp_svg_read_color(char const *str, char const **end_ptr, guint32 def);
 void sp_svg_write_color(char *buf, unsigned int buflen, unsigned int rgba32);
 
-bool sp_svg_read_icc_color( gchar const *str, gchar const **end_ptr, SVGICCColor* dest );
-bool sp_svg_read_icc_color( gchar const *str, SVGICCColor* dest );
-void icc_color_to_sRGB(SVGICCColor* dest, guchar* r, guchar* g, guchar* b);
+bool sp_svg_read_icc_color( char const *str, char const **end_ptr, SVGICCColor* dest );
+bool sp_svg_read_icc_color( char const *str, SVGICCColor* dest );
+void icc_color_to_sRGB(SVGICCColor* dest, unsigned char* r, unsigned char* g, unsigned char* b);
 
 #endif /* !SVG_SVG_COLOR_H_SEEN */
diff --git a/src/svg/svg-length-test.h b/src/svg/svg-length-test.h
index 81a28c9e7..796943e45 100644
--- a/src/svg/svg-length-test.h
+++ b/src/svg/svg-length-test.h
@@ -164,13 +164,13 @@ SvgLengthTest::test_t const SvgLengthTest::absolute_tests[12] = {
     {"1.00001",      SVGLength::NONE,   1.00001  ,   1.00001},
     {"1px",          SVGLength::PX  ,   1        ,   1},
     {".1px",         SVGLength::PX  ,   0.1      ,   0.1},
-    {"100pt",        SVGLength::PT  , 100        , 125},
-    {"1e2pt",        SVGLength::PT  , 100        , 125},
-    {"3pc",          SVGLength::PC  ,   3        ,  45},
-    {"-3.5pc",       SVGLength::PC  ,  -3.5      ,  -3.5*15.},
-    {"1.2345678mm",  SVGLength::MM  ,   1.2345678,   1.2345678*3.543307}, // TODO: More precise constants? (a 7 digit constant when the default precision is 8 digits?)
-    {"123.45678cm", SVGLength::CM   , 123.45678  , 123.45678*35.43307},
-    {"73.162987in",  SVGLength::INCH,  73.162987 ,  73.162987*90}};
+    {"100pt",        SVGLength::PT  , 100        ,  400.0/3.0},
+    {"1e2pt",        SVGLength::PT  , 100        ,  400.0/3.0},
+    {"3pc",          SVGLength::PC  ,   3        ,  48},
+    {"-3.5pc",       SVGLength::PC  ,  -3.5      ,  -3.5*16.0},
+    {"1.2345678mm",  SVGLength::MM  ,   1.2345678,   1.2345678f*96.0/25.4}, // TODO: More precise constants? (a 7 digit constant when the default precision is 8 digits?)
+    {"123.45678cm", SVGLength::CM   , 123.45678  , 123.45678f*96.0/2.54},   // Note that svg_length_read is casting the result from g_ascii_strtod to float.
+    {"73.162987in",  SVGLength::INCH,  73.162987 ,  73.162987f*96.0/1.00}};
 SvgLengthTest::test_t const SvgLengthTest::relative_tests[3] = {
     {"123em", SVGLength::EM,      123, 123. *  7.},
     {"123ex", SVGLength::EX,      123, 123. * 13.},
diff --git a/src/svg/svg-length.cpp b/src/svg/svg-length.cpp
index b9e8e6340..b9b475f4b 100644
--- a/src/svg/svg-length.cpp
+++ b/src/svg/svg-length.cpp
@@ -1,6 +1,4 @@
-#define __SP_SVG_LENGTH_C__
-
-/*
+/**
  * SVG data parser
  *
  * Authors:
@@ -12,20 +10,15 @@
  * This code is in public domain
  */
 
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
+#include <cmath>
 #include <cstring>
 #include <string>
-#include <math.h>
 #include <glib.h>
 
 #include "svg.h"
 #include "stringstream.h"
 #include "util/units.h"
 
-
 static unsigned sp_svg_length_read_lff(gchar const *str, SVGLength::Unit *unit, float *val, float *computed, char **next);
 
 #ifndef MAX
@@ -570,4 +563,4 @@ void SVGLength::readOrUnset(gchar const *str, Unit u, float v, float c)
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/svg/svg-length.h b/src/svg/svg-length.h
index 477b3ef81..c34905d07 100644
--- a/src/svg/svg-length.h
+++ b/src/svg/svg-length.h
@@ -1,11 +1,4 @@
-#ifndef SEEN_SP_SVG_LENGTH_H
-#define SEEN_SP_SVG_LENGTH_H
-
 /**
- *  \file src/svg/svg-length.h
- *  \brief SVG length type
- */
-/*
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   Carl Hetherington <inkscape@carlh.net>
@@ -16,10 +9,13 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glib.h>
+#ifndef SEEN_SP_SVG_LENGTH_H
+#define SEEN_SP_SVG_LENGTH_H
 
-class SVGLength
-{
+/**
+ *  SVG length type
+ */
+class SVGLength {
 public:
     SVGLength();
 
@@ -57,9 +53,9 @@ public:
         return v;
     }
 
-    bool read(gchar const *str);
-    void readOrUnset(gchar const *str, Unit u = NONE, float v = 0, float c = 0);
-    bool readAbsolute(gchar const *str);
+    bool read(char const *str);
+    void readOrUnset(char const *str, Unit u = NONE, float v = 0, float c = 0);
+    bool readAbsolute(char const *str);
     void set(Unit u, float v, float c);
     void unset(Unit u = NONE, float v = 0, float c = 0);
     void update(double em, double ex, double scale);
@@ -76,4 +72,4 @@ public:
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/svg/svg-path.cpp b/src/svg/svg-path.cpp
index 59dad9ead..9ba3c0ebd 100644
--- a/src/svg/svg-path.cpp
+++ b/src/svg/svg-path.cpp
@@ -1,41 +1,25 @@
-#define __SP_SVG_PARSE_C__
 /*
-   svg-path.c: Parse SVG path element data into bezier path.
-
-   Copyright (C) 2000 Eazel, Inc.
-   Copyright (C) 2000 Lauris Kaplinski
-   Copyright (C) 2001 Ximian, Inc.
-   Copyright (C) 2008 Johan Engelen
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public
-   License along with this program; if not, write to the
-   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.
-
-   Authors:
-     Johan Engelen
-     (old nartbpath code that has been deleted: Raph Levien <raph@artofcode.com>)
-     (old nartbpath code that has been deleted: Lauris Kaplinski <lauris@ximian.com>)
-*/
+ * svg-path.cpp: Parse SVG path element data into bezier path.
+ * Authors:
+ *   Johan Engelen
+ *   (old nartbpath code that has been deleted: Raph Levien <raph@artofcode.com>)
+ *   (old nartbpath code that has been deleted: Lauris Kaplinski <lauris@ximian.com>)
+ *
+ * Copyright (C) 2000 Eazel, Inc.
+ * Copyright (C) 2000 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2008 Johan Engelen
+ *
+ * Copyright (C) 2000-2008 authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
 
 #include <cstring>
 #include <string>
 #include <cassert>
 #include <glib.h> // g_assert()
 
-#include "svg/svg.h"
-#include "svg/path-string.h"
-
 #include <2geom/pathvector.h>
 #include <2geom/path.h>
 #include <2geom/curves.h>
@@ -45,6 +29,9 @@
 #include <2geom/exception.h>
 #include <2geom/angle.h>
 
+#include "svg/svg.h"
+#include "svg/path-string.h"
+
 /*
  * Parses the path in str. When an error is found in the pathstring, this method
  * returns a truncated path up to where the error was found in the pathstring.
@@ -150,4 +137,4 @@ gchar * sp_svg_write_path(Geom::Path const &p) {
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/svg/svg.h b/src/svg/svg.h
index a7795b82e..6ce9db937 100644
--- a/src/svg/svg.h
+++ b/src/svg/svg.h
@@ -11,7 +11,7 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-#include <glib.h>
+
 #include <vector>
 #include <cstring>
 #include <string>
@@ -28,13 +28,13 @@
  * Return FALSE and let val untouched on error
  */
 
-unsigned int sp_svg_number_read_f( const gchar *str, float *val );
-unsigned int sp_svg_number_read_d( const gchar *str, double *val );
+unsigned int sp_svg_number_read_f( const char *str, float *val );
+unsigned int sp_svg_number_read_d( const char *str, double *val );
 
 /*
  * No buffer overflow checking is done, so better wrap them if needed
  */
-unsigned int sp_svg_number_write_de( gchar *buf, int bufLen, double val, unsigned int tprec, int min_exp );
+unsigned int sp_svg_number_write_de( char *buf, int bufLen, double val, unsigned int tprec, int min_exp );
 
 /* Length */
 
@@ -47,24 +47,24 @@ unsigned int sp_svg_number_write_de( gchar *buf, int bufLen, double val, unsigne
  * Any return value pointer can be NULL
  */
 
-unsigned int sp_svg_length_read_computed_absolute( const gchar *str, float *length );
-std::vector<SVGLength> sp_svg_length_list_read( const gchar *str );
-unsigned int sp_svg_length_read_ldd( const gchar *str, SVGLength::Unit *unit, double *value, double *computed );
+unsigned int sp_svg_length_read_computed_absolute( const char *str, float *length );
+std::vector<SVGLength> sp_svg_length_list_read( const char *str );
+unsigned int sp_svg_length_read_ldd( const char *str, SVGLength::Unit *unit, double *value, double *computed );
 
 std::string sp_svg_length_write_with_units(SVGLength const &length);
 
-bool sp_svg_transform_read(gchar const *str, Geom::Affine *transform);
+bool sp_svg_transform_read(char const *str, Geom::Affine *transform);
 
-gchar *sp_svg_transform_write(Geom::Affine const &transform);
-gchar *sp_svg_transform_write(Geom::Affine const *transform);
+char *sp_svg_transform_write(Geom::Affine const &transform);
+char *sp_svg_transform_write(Geom::Affine const *transform);
 
 double sp_svg_read_percentage( const char * str, double def );
 
 /* NB! As paths can be long, we use here dynamic string */
 
 Geom::PathVector sp_svg_read_pathv( char const * str );
-gchar * sp_svg_write_path( Geom::PathVector const &p );
-gchar * sp_svg_write_path( Geom::Path const &p );
+char * sp_svg_write_path( Geom::PathVector const &p );
+char * sp_svg_write_path( Geom::Path const &p );
 
 #endif // SEEN_SP_SVG_H