Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

24 files changed, 6492 insertions, 0 deletions

diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt
new file mode 100644
index 0000000..d5f4433
--- /dev/null
+++ b/src/util/CMakeLists.txt
@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+set(util_SRC
+	expression-evaluator.cpp
+	share.cpp
+	paper.cpp
+	preview.cpp
+	units.cpp
+	ziptool.cpp
+
+
+	# -------
+	# Headers
+	const_char_ptr.h
+	enums.h
+	expression-evaluator.h
+	fixed_point.h
+	format.h
+	forward-pointer-iterator.h
+	longest-common-suffix.h
+	pages-skeleton.h
+	paper.h
+	preview.h
+	reference.h
+	share.h
+	signal-blocker.h
+	trim.h
+	units.h
+	ziptool.h
+)
+
+add_inkscape_lib(util_LIB "${util_SRC}")
+target_link_libraries(util_LIB PUBLIC 2Geom::2geom)
+# add_inkscape_source("${util_SRC}")
diff --git a/src/util/README b/src/util/README
new file mode 100644
index 0000000..254e3fa
--- /dev/null
+++ b/src/util/README
@@ -0,0 +1,9 @@
+
+
+This directory contains a variety of utility code.
+
+To do:
+
+* Merge with 'helper' into this directory.
+* Move individual files to more appropriate directories.
+* Split into three sub-directories: numeric, color, svg.
diff --git a/src/util/const_char_ptr.h b/src/util/const_char_ptr.h
new file mode 100644
index 0000000..44e6906
--- /dev/null
+++ b/src/util/const_char_ptr.h
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Provides `const_char_ptr`
+ */
+/*
+ * Authors:
+ *    Sergei Izmailov <sergei.a.izmailov@gmail.com>
+ *
+ * Copyright (C) 2020 Sergei Izmailov
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef SEEN_INKSCAPE_UTIL_CONST_CHAR_PTR_H
+#define SEEN_INKSCAPE_UTIL_CONST_CHAR_PTR_H
+#include <glibmm/ustring.h>
+#include <string>
+#include "share.h"
+
+namespace Inkscape {
+namespace Util {
+
+/**
+ * Non-owning reference to 'const char*'
+ * Main-purpose: avoid overloads of type `f(char*, str&)`, `f(str&, char*)`, `f(char*, char*)`, ...
+ */
+class const_char_ptr{
+public:
+    const_char_ptr() noexcept: m_data(nullptr){};
+    const_char_ptr(std::nullptr_t): const_char_ptr() {};
+    const_char_ptr(const char* const data) noexcept: m_data(data) {};
+    const_char_ptr(const Glib::ustring& str) noexcept: const_char_ptr(str.c_str()) {};
+    const_char_ptr(const std::string& str) noexcept: const_char_ptr(str.c_str()) {};
+    const_char_ptr(const ptr_shared& shared) : const_char_ptr(static_cast<const char*>(shared)) {};
+
+    const char * data() const noexcept { return m_data; }
+private:
+    const char * const m_data = nullptr;
+};
+}
+}
+#endif // SEEN_INKSCAPE_UTIL_CONST_CHAR_PTR_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:
\ No newline at end of file
diff --git a/src/util/enums.h b/src/util/enums.h
new file mode 100644
index 0000000..46c4d5e
--- /dev/null
+++ b/src/util/enums.h
@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Authors:
+ *   Nicholas Bishop <nicholasbishop@gmail.com>
+ *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
+ *
+ * Copyright (C) 2007 Authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef INKSCAPE_UTIL_ENUMS_H
+#define INKSCAPE_UTIL_ENUMS_H
+
+#include <glibmm/ustring.h>
+
+namespace Inkscape {
+namespace Util {
+
+/**
+ * Simplified management of enumerations of svg items with UI labels.
+ * IMPORTANT:
+ *  When initializing the EnumData struct, you cannot use _(...) to translate strings.
+ * Instead, one must use N_(...) and do the translation every time the string is retrieved.
+ */
+template<typename E>
+struct EnumData
+{
+    E id;
+    const Glib::ustring label;
+    const Glib::ustring key;
+};
+
+const Glib::ustring empty_string("");
+
+/**
+ * Simplified management of enumerations of svg items with UI labels.
+ *
+ * @note that get_id_from_key and get_id_from_label return 0 if it cannot find an entry for that key string.
+ * @note that get_label and get_key return an empty string when the requested id is not in the list.
+ */
+template<typename E> class EnumDataConverter
+{
+public:
+    typedef EnumData<E> Data;
+
+    EnumDataConverter(const EnumData<E>* cd, const unsigned int length)
+        : _length(length), _data(cd)
+    {}
+
+    E get_id_from_label(const Glib::ustring& label) const
+    {
+        for(unsigned int i = 0; i < _length; ++i) {
+            if(_data[i].label == label)
+                return _data[i].id;
+        }
+
+        return (E)0;
+    }
+
+    E get_id_from_key(const Glib::ustring& key) const
+    {
+        for(unsigned int i = 0; i < _length; ++i) {
+            if(_data[i].key == key)
+                return _data[i].id;
+        }
+
+        return (E)0;
+    }
+
+    bool is_valid_key(const Glib::ustring& key) const
+    {
+        for(unsigned int i = 0; i < _length; ++i) {
+            if(_data[i].key == key)
+                return true;
+        }
+
+        return false;
+    }
+
+    bool is_valid_id(const E id) const
+    {
+        for(unsigned int i = 0; i < _length; ++i) {
+            if(_data[i].id == id)
+                return true;
+        }
+        return false;
+    }
+
+    const Glib::ustring& get_label(const E id) const
+    {
+        for(unsigned int i = 0; i < _length; ++i) {
+            if(_data[i].id == id)
+                return _data[i].label;
+        }
+
+        return empty_string;
+    }
+
+    const Glib::ustring& get_key(const E id) const
+    {
+        for(unsigned int i = 0; i < _length; ++i) {
+            if(_data[i].id == id)
+                return _data[i].key;
+        }
+
+        return empty_string;
+    }
+
+    const EnumData<E>& data(const unsigned int i) const
+    {
+        return _data[i];
+    }
+
+    const unsigned int _length;
+private:
+    const EnumData<E>* _data;
+};
+
+
+}
+}
+
+#endif
+
+/*
+  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/util/expression-evaluator.cpp b/src/util/expression-evaluator.cpp
new file mode 100644
index 0000000..24a56b7
--- /dev/null
+++ b/src/util/expression-evaluator.cpp
@@ -0,0 +1,396 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+/** @file
+ * TODO: insert short description here
+ */
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
+ *
+ * Original file from libgimpwidgets: gimpeevl.c
+ * Copyright (C) 2008 Fredrik Alstromer <roe@excu.se>
+ * Copyright (C) 2008 Martin Nordholts <martinn@svn.gnome.org>
+ * Modified for Inkscape by Johan Engelen
+ * Copyright (C) 2011 Johan Engelen
+ * Copyright (C) 2013 Matthew Petroff
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include "util/expression-evaluator.h"
+#include "util/units.h"
+
+#include <glib/gconvert.h>
+
+#include <cmath>
+#include <cstring>
+
+using Inkscape::Util::unit_table;
+
+namespace Inkscape {
+namespace Util {
+
+EvaluatorQuantity::EvaluatorQuantity(double value, unsigned int dimension) :
+    value(value),
+    dimension(dimension)
+{
+}
+
+EvaluatorToken::EvaluatorToken()
+{
+    type = 0;
+    value.fl = 0;
+}
+
+ExpressionEvaluator::ExpressionEvaluator(const char *string, Unit const *unit) :
+    string(g_locale_to_utf8(string,-1,nullptr,nullptr,nullptr)),
+    unit(unit)
+{
+    current_token.type  = TOKEN_END;
+    
+    // Preload symbol
+    parseNextToken();
+}
+
+/**
+ * Evaluates the given arithmetic expression, along with an optional dimension
+ * analysis, and basic unit conversions.
+ *
+ * All units conversions factors are relative to some implicit
+ * base-unit. This is also the unit of the returned value.
+ *
+ * Returns: An EvaluatorQuantity with a value given in the base unit along with
+ * the order of the dimension (e.g. if the base unit is inches, a dimension
+ * order of two means in^2).
+ *
+ * @return Result of evaluation.
+ * @throws Inkscape::Util::EvaluatorException There was a parse error.
+ **/
+EvaluatorQuantity ExpressionEvaluator::evaluate()
+{
+    if (!g_utf8_validate(string, -1, nullptr)) {
+        throw EvaluatorException("Invalid UTF8 string", nullptr);
+    }
+    
+    EvaluatorQuantity result = EvaluatorQuantity();
+    EvaluatorQuantity default_unit_factor;
+    
+    // Empty expression evaluates to 0
+    if (acceptToken(TOKEN_END, nullptr)) {
+        return result;
+    }
+    
+    result = evaluateExpression();
+    
+    // There should be nothing left to parse by now
+    isExpected(TOKEN_END, nullptr);
+    
+    resolveUnit(nullptr, &default_unit_factor, unit);
+    
+    // Entire expression is dimensionless, apply default unit if applicable
+    if ( result.dimension == 0 && default_unit_factor.dimension != 0 ) {
+        result.value     /= default_unit_factor.value;
+        result.dimension  = default_unit_factor.dimension;
+    }
+    return result;
+}
+
+EvaluatorQuantity ExpressionEvaluator::evaluateExpression()
+{
+    bool subtract;
+    EvaluatorQuantity evaluated_terms;
+    
+    evaluated_terms = evaluateTerm();
+    
+    // Continue evaluating terms, chained with + or -.
+    for (subtract = FALSE;
+        acceptToken('+', nullptr) || (subtract = acceptToken('-', nullptr));
+        subtract = FALSE)
+    {
+        EvaluatorQuantity new_term = evaluateTerm();
+        
+        // If dimensions mismatch, attempt default unit assignment
+        if ( new_term.dimension != evaluated_terms.dimension ) {
+            EvaluatorQuantity default_unit_factor;
+            
+            resolveUnit(nullptr, &default_unit_factor, unit);
+            
+            if ( new_term.dimension == 0
+                && evaluated_terms.dimension == default_unit_factor.dimension )
+            {
+                new_term.value     /= default_unit_factor.value;
+                new_term.dimension  = default_unit_factor.dimension;
+            } else if ( evaluated_terms.dimension == 0
+                && new_term.dimension == default_unit_factor.dimension )
+            {
+                evaluated_terms.value     /= default_unit_factor.value;
+                evaluated_terms.dimension  = default_unit_factor.dimension;
+            } else {
+                throwError("Dimension mismatch during addition");
+            }
+        }
+        
+        evaluated_terms.value += (subtract ? -new_term.value : new_term.value);
+    }
+    
+    return evaluated_terms;
+}
+
+EvaluatorQuantity ExpressionEvaluator::evaluateTerm()
+{
+    bool division;
+    EvaluatorQuantity evaluated_exp_terms = evaluateExpTerm();
+    
+    for ( division = false;
+        acceptToken('*', nullptr) || (division = acceptToken('/', nullptr));
+        division = false )
+    {
+        EvaluatorQuantity new_exp_term = evaluateExpTerm();
+        
+        if (division) {
+            evaluated_exp_terms.value     /= new_exp_term.value;
+            evaluated_exp_terms.dimension -= new_exp_term.dimension;
+        } else {
+            evaluated_exp_terms.value     *= new_exp_term.value;
+            evaluated_exp_terms.dimension += new_exp_term.dimension;
+        }
+    }
+    
+    return evaluated_exp_terms;
+}
+
+EvaluatorQuantity ExpressionEvaluator::evaluateExpTerm()
+{
+    EvaluatorQuantity evaluated_signed_factors = evaluateSignedFactor();
+    
+    while(acceptToken('^', nullptr)) {
+        EvaluatorQuantity new_signed_factor = evaluateSignedFactor();
+        
+        if (new_signed_factor.dimension == 0) {
+            evaluated_signed_factors.value = pow(evaluated_signed_factors.value,
+                                                 new_signed_factor.value);
+            evaluated_signed_factors.dimension *= new_signed_factor.value;
+        } else {
+            throwError("Unit in exponent");
+        }
+    }
+    
+    return evaluated_signed_factors;
+}
+
+EvaluatorQuantity ExpressionEvaluator::evaluateSignedFactor()
+{
+    EvaluatorQuantity result;
+    bool negate = FALSE;
+    
+    if (!acceptToken('+', nullptr)) {
+        negate = acceptToken ('-', nullptr);
+    }
+    
+    result = evaluateFactor();
+    
+    if (negate) {
+        result.value = -result.value;
+    }
+    
+    return result;
+}
+
+EvaluatorQuantity ExpressionEvaluator::evaluateFactor()
+{
+    EvaluatorQuantity evaluated_factor = EvaluatorQuantity();
+    EvaluatorToken consumed_token = EvaluatorToken();
+
+    if (acceptToken(TOKEN_END, &consumed_token)) {
+        return evaluated_factor;
+    }
+    else if (acceptToken(TOKEN_NUM, &consumed_token)) {
+        evaluated_factor.value = consumed_token.value.fl;
+    } else if (acceptToken('(', nullptr)) {
+        evaluated_factor = evaluateExpression();
+        isExpected(')', nullptr);
+    } else {
+        throwError("Expected number or '('");
+    }
+    
+    if ( current_token.type == TOKEN_IDENTIFIER ) {
+        char *identifier;
+        EvaluatorQuantity result;
+        
+        acceptToken(TOKEN_ANY, &consumed_token);
+        
+        identifier = g_newa(char, consumed_token.value.size + 1);
+        
+        strncpy(identifier, consumed_token.value.c, consumed_token.value.size);
+        identifier[consumed_token.value.size] = '\0';
+        
+        if (resolveUnit(identifier, &result, unit)) {
+            evaluated_factor.value      /= result.value;
+            evaluated_factor.dimension  += result.dimension;
+        } else {
+            throwError("Unit was not resolved");
+        }
+    }
+    
+    return evaluated_factor;
+}
+
+bool ExpressionEvaluator::acceptToken(TokenType token_type,
+                                      EvaluatorToken *consumed_token)
+{
+    bool existed = FALSE;
+    
+    if ( token_type == current_token.type || token_type == TOKEN_ANY ) {
+        existed = TRUE;
+        
+        if (consumed_token) {
+            *consumed_token = current_token;
+        }
+        
+        // Parse next token
+        parseNextToken();
+    }
+    
+    return existed;
+}
+
+void ExpressionEvaluator::parseNextToken()
+{
+    const char *s;
+    
+    movePastWhiteSpace();
+    s = string;
+    start_of_current_token = s;
+    
+    if ( !s || s[0] == '\0' ) {
+        // We're all done
+        current_token.type = TOKEN_END;
+    } else if ( s[0] == '+' || s[0] == '-' ) {
+        // Snatch these before the g_strtod() does, otherwise they might
+        // be used in a numeric conversion.
+        acceptTokenCount(1, s[0]);
+    } else {
+        // Attempt to parse a numeric value
+        char *endptr = nullptr;
+        gdouble value = g_strtod(s, &endptr);
+        
+        if ( endptr && endptr != s ) {
+            // A numeric could be parsed, use it
+            current_token.value.fl = value;
+            
+            current_token.type = TOKEN_NUM;
+            string             = endptr;
+        } else if (isUnitIdentifierStart(s[0])) {
+            // Unit identifier
+            current_token.value.c = s;
+            current_token.value.size = getIdentifierSize(s, 0);
+            
+            acceptTokenCount(current_token.value.size, TOKEN_IDENTIFIER);
+        } else {
+            // Everything else is a single character token
+            acceptTokenCount(1, s[0]);
+        }
+    }
+}
+
+void ExpressionEvaluator::acceptTokenCount (int count, TokenType token_type)
+{
+    current_token.type  = token_type;
+    string             += count;
+}
+
+void ExpressionEvaluator::isExpected(TokenType token_type,
+                                     EvaluatorToken *value)
+{
+    if (!acceptToken(token_type, value)) {
+        throwError("Unexpected token");
+    }
+}
+
+void ExpressionEvaluator::movePastWhiteSpace()
+{
+    if (!string) {
+        return;
+    }
+    
+    while (g_ascii_isspace(*string)) {
+        string++;
+    }
+}
+
+bool ExpressionEvaluator::isUnitIdentifierStart(gunichar c)
+{
+    return (g_unichar_isalpha (c)
+        || c == (gunichar) '%'
+        || c == (gunichar) '\'');
+}
+
+/**
+ * getIdentifierSize:
+ * @s:
+ * @start:
+ *
+ * Returns: Size of identifier in bytes (not including NULL
+ * terminator).
+ **/
+int ExpressionEvaluator::getIdentifierSize(const char *string, int start_offset)
+{
+    const char *start  = g_utf8_offset_to_pointer(string, start_offset);
+    const char *s      = start;
+    gunichar    c      = g_utf8_get_char(s);
+    int         length = 0;
+    
+    if (isUnitIdentifierStart(c)) {
+        s = g_utf8_next_char (s);
+        c = g_utf8_get_char (s);
+        length++;
+        
+        while ( isUnitIdentifierStart (c) || g_unichar_isdigit (c) ) {
+            s = g_utf8_next_char(s);
+            c = g_utf8_get_char(s);
+            length++;
+        }
+    }
+    
+    return g_utf8_offset_to_pointer(start, length) - start;
+}
+
+bool ExpressionEvaluator::resolveUnit (const char* identifier,
+                                       EvaluatorQuantity *result,
+                                       Unit const* unit)
+{
+    if (!unit) {
+        result->value = 1;
+        result->dimension = 1;
+        return true;
+    }else if (!identifier) {
+        result->value = 1;
+        result->dimension = unit->isAbsolute() ? 1 : 0;
+        return true;
+    } else if (unit_table.hasUnit(identifier)) {
+        Unit const *identifier_unit = unit_table.getUnit(identifier);
+        result->value = Quantity::convert(1, unit, identifier_unit);
+        result->dimension = identifier_unit->isAbsolute() ? 1 : 0;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void ExpressionEvaluator::throwError(const char *msg)
+{
+    throw EvaluatorException(msg, start_of_current_token);
+}
+
+} // namespace Util
+} // namespace Inkscape
diff --git a/src/util/expression-evaluator.h b/src/util/expression-evaluator.h
new file mode 100644
index 0000000..a45ad5a
--- /dev/null
+++ b/src/util/expression-evaluator.h
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+/** @file
+ * TODO: insert short description here
+ */
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
+ *
+ * Original file from libgimpwidgets: gimpeevl.h
+ * Copyright (C) 2008-2009 Fredrik Alstromer <roe@excu.se>
+ * Copyright (C) 2008-2009 Martin Nordholts <martinn@svn.gnome.org>
+ * Modified for Inkscape by Johan Engelen
+ * Copyright (C) 2011 Johan Engelen
+ * Copyright (C) 2013 Matthew Petroff
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INKSCAPE_UTIL_EXPRESSION_EVALUATOR_H
+#define INKSCAPE_UTIL_EXPRESSION_EVALUATOR_H
+
+#include "util/units.h"
+
+#include <exception>
+#include <sstream>
+#include <string>
+
+/**
+ * @file
+ * Expression evaluator: A straightforward recursive
+ * descent parser, no fuss, no new dependencies. The lexer is hand
+ * coded, tedious, not extremely fast but works. It evaluates the
+ * expression as it goes along, and does not create a parse tree or
+ * anything, and will not optimize anything. It uses doubles for
+ * precision, with the given use case, that's enough to combat any
+ * rounding errors (as opposed to optimizing the evaluation).
+ *
+ * It relies on external unit resolving through a callback and does
+ * elementary dimensionality constraint check (e.g. "2 mm + 3 px * 4
+ * in" is an error, as L + L^2 is a mismatch). It uses g_strtod() for numeric
+ * conversions and it's non-destructive in terms of the parameters, and
+ * it's reentrant.
+ *
+ * EBNF:
+ *
+ *   expression    ::= term { ('+' | '-') term }*  |
+ *                     <empty string> ;
+ *
+ *   term          ::= exponent { ( '*' | '/' ) exponent }* ;
+ *
+ *   exponent      ::= signed factor { '^' signed factor }* ;
+ *
+ *   signed factor ::= ( '+' | '-' )? factor ;
+ *
+ *   unit factor   ::= factor unit? ;
+ *
+ *   factor        ::= number | '(' expression ')' ;
+ *
+ *   number        ::= ? what g_strtod() consumes ? ;
+ *
+ *   unit          ::= ? what not g_strtod() consumes and not whitespace ? ;
+ *
+ * The code should match the EBNF rather closely (except for the
+ * non-terminal unit factor, which is inlined into factor) for
+ * maintainability reasons.
+ *
+ * It will allow 1++1 and 1+-1 (resulting in 2 and 0, respectively),
+ * but I figured one might want that, and I don't think it's going to
+ * throw anyone off.
+ */
+
+namespace Inkscape {
+namespace Util {
+
+class Unit;
+
+/**
+ * EvaluatorQuantity:
+ * @param value         In reference units.
+ * @param dimension     mm has a dimension of 1, mm^2 has a dimension of 2, etc.
+ */
+class EvaluatorQuantity
+{
+public:
+    EvaluatorQuantity(double value = 0, unsigned int dimension = 0);
+    
+    double value;
+    unsigned int dimension;
+};
+
+/**
+ * TokenType
+ */
+enum {
+  TOKEN_NUM        = 30000,
+  TOKEN_IDENTIFIER = 30001,
+  TOKEN_ANY        = 40000,
+  TOKEN_END        = 50000
+};
+typedef int TokenType;
+
+/**
+ * EvaluatorToken
+ */
+class EvaluatorToken
+{
+public:
+    EvaluatorToken();
+    
+    TokenType type;
+    
+    union {
+        double fl;
+        struct {
+            const char *c;
+            int size;
+        };
+    } value;
+};
+
+/**
+ * ExpressionEvaluator
+ * @param string    NULL terminated input string to evaluate
+ * @param unit      Unit output should be in
+ */
+class ExpressionEvaluator
+{
+public:
+    ExpressionEvaluator(const char *string, Unit const *unit = nullptr);
+    
+    EvaluatorQuantity evaluate();
+
+private:
+    const char *string;
+    Unit const *unit;
+    
+    EvaluatorToken current_token;
+    const char *start_of_current_token;
+    
+    EvaluatorQuantity evaluateExpression();
+    EvaluatorQuantity evaluateTerm();
+    EvaluatorQuantity evaluateExpTerm();
+    EvaluatorQuantity evaluateSignedFactor();
+    EvaluatorQuantity evaluateFactor();
+    
+    bool acceptToken(TokenType token_type, EvaluatorToken *consumed_token);
+    void parseNextToken();
+    void acceptTokenCount(int count, TokenType token_type);
+    void isExpected(TokenType token_type, EvaluatorToken *value);
+    
+    void movePastWhiteSpace();
+    
+    static bool isUnitIdentifierStart(gunichar c);
+    static int getIdentifierSize(const char *s, int start);
+    
+    static bool resolveUnit(const char *identifier, EvaluatorQuantity *result, Unit const *unit);
+    
+    void throwError(const char *msg);
+};
+
+/**
+ * Special exception class for the expression evaluator.
+ */
+class EvaluatorException : public std::exception {
+public:
+    EvaluatorException(const char *message, const char *at_position) {
+        std::ostringstream os;
+        const char *token = at_position ? at_position : "<End of input>";
+        os << "Expression evaluator error: " << message << " at '" << token << "'";
+        msgstr = os.str();
+    }
+
+    ~EvaluatorException() noexcept override = default; // necessary to destroy the string object!!!
+
+    const char *what() const noexcept override {
+        return msgstr.c_str();
+    }
+protected:
+    std::string msgstr;
+};
+
+}
+}
+
+#endif // INKSCAPE_UTIL_EXPRESSION_EVALUATOR_H
diff --git a/src/util/fixed_point.h b/src/util/fixed_point.h
new file mode 100644
index 0000000..44174d0
--- /dev/null
+++ b/src/util/fixed_point.h
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Util::FixedPoint - fixed point type
+ *
+ * Authors:
+ *   Jasper van de Gronde <th.v.d.gronde@hccnet.net>
+ *
+ * Copyright (C) 2006 Jasper van de Gronde
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_UTIL_FIXED_POINT_H
+#define SEEN_INKSCAPE_UTIL_FIXED_POINT_H
+
+#include <cmath>
+#include <algorithm>
+#include <limits>
+
+namespace Inkscape {
+
+namespace Util {
+
+template <typename T, unsigned int precision>
+class FixedPoint {
+public:
+    FixedPoint() = default;
+    FixedPoint(const FixedPoint& value) : v(value.v) {}
+    FixedPoint(char value) : v(static_cast<T>(value)<<precision) {}
+    FixedPoint(unsigned char value) : v(static_cast<T>(value)<<precision) {}
+    FixedPoint(short value) : v(static_cast<T>(value)<<precision) {}
+    FixedPoint(unsigned short value) : v(static_cast<T>(value)<<precision) {}
+    FixedPoint(int value) : v(static_cast<T>(value)<<precision) {}
+    FixedPoint(unsigned int value) : v(static_cast<T>(value)<<precision) {}
+    FixedPoint(double value) : v(static_cast<T>(floor(value*(1<<precision)))) {}
+
+    FixedPoint& operator+=(FixedPoint val) { v += val.v; return *this; }
+    FixedPoint& operator-=(FixedPoint val) { v -= val.v; return *this; }
+    FixedPoint& operator*=(FixedPoint val) {
+        const unsigned int half_size = 8*sizeof(T)/2;
+        const T al = v&((1<<half_size)-1), bl = val.v&((1<<half_size)-1);
+        const T ah = v>>half_size, bh = val.v>>half_size;
+        v = static_cast<unsigned int>(al*bl)>>precision;
+        if ( half_size >= precision ) {
+            v += ((al*bh)+(ah*bl)+((ah*bh)<<half_size))<<(half_size-precision);
+        } else {
+            v += ((al*bh)+(ah*bl))>>(precision-half_size);
+            v += (ah*bh)<<(2*half_size-precision);
+        }
+        return *this;
+    }
+
+    FixedPoint& operator*=(char val) { v *= val; return *this; }
+    FixedPoint& operator*=(unsigned char val) { v *= val; return *this; }
+    FixedPoint& operator*=(short val) { v *= val; return *this; }
+    FixedPoint& operator*=(unsigned short val) { v *= val; return *this; }
+    FixedPoint& operator*=(int val) { v *= val; return *this; }
+    FixedPoint& operator*=(unsigned int val) { v *= val; return *this; }
+
+    FixedPoint operator+(FixedPoint val) const { FixedPoint r(*this); return r+=val; }
+    FixedPoint operator-(FixedPoint val) const { FixedPoint r(*this); return r-=val; }
+    FixedPoint operator*(FixedPoint val) const { FixedPoint r(*this); return r*=val; }
+
+    FixedPoint operator*(char val) const { FixedPoint r(*this); return r*=val; }
+    FixedPoint operator*(unsigned char val) const { FixedPoint r(*this); return r*=val; }
+    FixedPoint operator*(short val) const { FixedPoint r(*this); return r*=val; }
+    FixedPoint operator*(unsigned short val) const { FixedPoint r(*this); return r*=val; }
+    FixedPoint operator*(int val) const { FixedPoint r(*this); return r*=val; }
+    FixedPoint operator*(unsigned int val) const { FixedPoint r(*this); return r*=val; }
+
+    float operator*(float val) const { return static_cast<float>(*this)*val; }
+    double operator*(double val) const { return static_cast<double>(*this)*val; }
+
+    operator char() const { return v>>precision; }
+    operator unsigned char() const { return v>>precision; }
+    operator short() const { return v>>precision; }
+    operator unsigned short() const { return v>>precision; }
+    operator int() const { return v>>precision; }
+    operator unsigned int() const { return v>>precision; }
+
+    operator float() const { return ldexpf(v,-precision); }
+    operator double() const { return ldexp(v,-precision); }
+private:
+    T v;
+};
+
+template<typename T, unsigned int precision> FixedPoint<T,precision> operator *(char a, FixedPoint<T,precision> b) { return b*=a; }
+template<typename T, unsigned int precision> FixedPoint<T,precision> operator *(unsigned char a, FixedPoint<T,precision> b) { return b*=a; }
+template<typename T, unsigned int precision> FixedPoint<T,precision> operator *(short a, FixedPoint<T,precision> b) { return b*=a; }
+template<typename T, unsigned int precision> FixedPoint<T,precision> operator *(unsigned short a, FixedPoint<T,precision> b) { return b*=a; }
+template<typename T, unsigned int precision> FixedPoint<T,precision> operator *(int a, FixedPoint<T,precision> b) { return b*=a; }
+template<typename T, unsigned int precision> FixedPoint<T,precision> operator *(unsigned int a, FixedPoint<T,precision> b) { return b*=a; }
+
+template<typename T, unsigned int precision> float operator *(float a, FixedPoint<T,precision> b) { return b*a; }
+template<typename T, unsigned int precision> double operator *(double a, FixedPoint<T,precision> b) { return b*a; }
+
+}
+
+}
+
+#endif
+/*
+  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/util/format.h b/src/util/format.h
new file mode 100644
index 0000000..b38f3a6
--- /dev/null
+++ b/src/util/format.h
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Util::format - g_strdup_printf wrapper producing shared strings
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2006 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_UTIL_FORMAT_H
+#define SEEN_INKSCAPE_UTIL_FORMAT_H
+
+#include <cstdarg>
+#include <glib.h>
+#include "util/share.h"
+
+namespace Inkscape {
+
+namespace Util {
+
+inline ptr_shared vformat(char const *format, va_list args) {
+    char *temp=g_strdup_vprintf(format, args);
+    ptr_shared result=share_string(temp);
+    g_free(temp);
+    return result;
+}
+
+       // needed since G_GNUC_PRINTF can only be used on a declaration
+       ptr_shared format(char const *format, ...) G_GNUC_PRINTF(1,2);
+inline ptr_shared format(char const *format, ...) {
+    va_list args;
+
+    va_start(args, format);
+    ptr_shared result=vformat(format, args);
+    va_end(args);
+
+    return result;
+}
+
+}
+
+}
+
+#endif
+/*
+  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/util/forward-pointer-iterator.h b/src/util/forward-pointer-iterator.h
new file mode 100644
index 0000000..9fe3bb8
--- /dev/null
+++ b/src/util/forward-pointer-iterator.h
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Util::ForwardPointerIterator - wraps a simple pointer
+ *                                          with various strategies
+ *                                          to determine sequence
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2004 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_UTIL_FORWARD_POINTER_ITERATOR_H
+#define SEEN_INKSCAPE_UTIL_FORWARD_POINTER_ITERATOR_H
+
+#include <iterator>
+#include <cstddef>
+#include "util/reference.h"
+
+namespace Inkscape {
+
+namespace Util {
+
+template <typename BaseType, typename Strategy>
+class ForwardPointerIterator;
+
+template <typename BaseType, typename Strategy>
+class ForwardPointerIterator<BaseType const, Strategy> {
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef typename Traits::Reference<BaseType const>::LValue value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef typename Traits::Reference<BaseType const>::LValue reference;
+    typedef typename Traits::Reference<BaseType const>::RValue const_reference;
+    typedef typename Traits::Reference<BaseType const>::Pointer pointer;
+
+    typedef ForwardPointerIterator<BaseType const, Strategy> Self;
+
+    ForwardPointerIterator() = default;
+    ForwardPointerIterator(pointer p) : _p(p) {}
+
+    operator pointer() const { return _p; }
+    reference operator*() const { return *_p; }
+    pointer operator->() const { return _p; }
+
+    bool operator==(Self const &other) const {
+        return _p == other._p;
+    }
+    bool operator!=(Self const &other) const {
+        return _p != other._p;
+    }
+
+    Self &operator++() {
+        _p = Strategy::next(_p);
+        return *this;
+    }
+    Self operator++(int) {
+        Self old(*this);
+        operator++();
+        return old;
+    }
+
+    operator bool() const { return _p != nullptr; }
+
+private:
+    pointer _p;
+};
+
+template <typename BaseType, typename Strategy>
+class ForwardPointerIterator
+: public ForwardPointerIterator<BaseType const, Strategy>
+{
+public:
+    typedef typename Traits::Reference<BaseType>::LValue value_type;
+    typedef typename Traits::Reference<BaseType>::LValue reference;
+    typedef typename Traits::Reference<BaseType>::RValue const_reference;
+    typedef typename Traits::Reference<BaseType>::Pointer pointer;
+
+    typedef ForwardPointerIterator<BaseType const, Strategy> Ancestor;
+    typedef ForwardPointerIterator<BaseType, Strategy> Self;
+
+    ForwardPointerIterator() : Ancestor() {}
+    ForwardPointerIterator(pointer p) : Ancestor(p) {}
+
+    operator pointer() const {
+        return const_cast<pointer>(Ancestor::operator->());
+    }
+    reference operator*() const {
+        return const_cast<reference>(Ancestor::operator*());
+    }
+    pointer operator->() const {
+        return const_cast<pointer>(Ancestor::operator->());
+    }
+
+    Self &operator++() {
+        Ancestor::operator++();
+        return *this;
+    }
+    Self operator++(int) {
+        Self old(*this);
+        operator++();
+        return old;
+    }
+};
+
+}
+
+}
+
+#endif
+/*
+  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/util/longest-common-suffix.h b/src/util/longest-common-suffix.h
new file mode 100644
index 0000000..1f7b228
--- /dev/null
+++ b/src/util/longest-common-suffix.h
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Algorithms::nearest_common_ancestor
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2004 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_ALGORITHMS_NEAREST_COMMON_ANCESTOR_H
+#define SEEN_INKSCAPE_ALGORITHMS_NEAREST_COMMON_ANCESTOR_H
+
+#include <iterator>
+#include <functional>
+
+namespace Inkscape {
+
+namespace Algorithms {
+
+/**
+ * Time costs:
+ *
+ * The case of sharing a common successor is handled in O(1) time.
+ *
+ * If \a a is the nearest common ancestor, then runs in O(len(rest of b)) time.
+ *
+ * Otherwise, runs in O(len(a) + len(b)) time.
+ */
+
+template <typename ForwardIterator>
+ForwardIterator nearest_common_ancestor(ForwardIterator a, ForwardIterator b, ForwardIterator end)
+{
+    if ( a == end || b == end ) {
+        return end;
+    }
+
+    /* Handle in O(1) time the common cases of identical lists or tails. */
+    {
+        /* identical lists? */
+        if ( a == b ) {
+            return a;
+        }
+
+        /* identical tails? */
+        ForwardIterator tail_a(a);
+        ForwardIterator tail_b(b);
+        if ( ++tail_a == ++tail_b ) {
+            return tail_a;
+        }
+    }
+
+    /* Build parallel lists of suffixes, ordered by increasing length. */
+
+    ForwardIterator lists[2] = { a, b };
+    std::vector<ForwardIterator> suffixes[2];
+
+    for ( int i=0 ; i < 2 ; i++ ) {
+        for ( ForwardIterator iter(lists[i]) ; iter != end ; ++iter ) {
+            if ( iter == lists[1-i] ) {
+                // the other list is a suffix of this one
+                return lists[1-i];
+            }
+            suffixes[i].push_back(iter);
+        }
+    }
+
+    /* Iterate in parallel through the lists of suffix lists from shortest to
+     * longest, stopping before the first pair of suffixes that differs
+     */
+
+    ForwardIterator longest_common(end);
+
+    while ( !suffixes[0].empty() && !suffixes[1].empty() &&
+             suffixes[0].back() == suffixes[1].back() )
+    {
+        longest_common = suffixes[0].back();
+        suffixes[0].pop_back();
+        suffixes[1].pop_back();
+    }
+
+    return longest_common;
+}
+
+}
+
+}
+
+#endif /* !SEEN_INKSCAPE_ALGORITHMS_NEAREST_COMMON_ANCESTOR_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 :
diff --git a/src/util/pages-skeleton.h b/src/util/pages-skeleton.h
new file mode 100644
index 0000000..ac984e4
--- /dev/null
+++ b/src/util/pages-skeleton.h
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * List of paper sizes
+ */
+/*
+ * Authors:
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Jon Phillips <jon@rejon.org>
+ *   Ralf Stephan <ralf@ark.in-berlin.de> (Gtkmm)
+ *   Bob Jamison <ishmal@users.sf.net>
+ *   Abhishek Sharma
+ *   + see git history
+ *
+ * Copyright (C) 2000 - 2018 Authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_PAGES_SKELETON_H
+#define SEEN_PAGES_SKELETON_H
+
+
+    /** \note
+     * The ISO page sizes in the table below differ from ghostscript's idea of page sizes (by
+     * less than 1pt).  Being off by <1pt should be OK for most purposes, but may cause fuzziness
+     * (antialiasing) problems when printing to 72dpi or 144dpi printers or bitmap files due to
+     * postscript's different coordinate system (y=0 meaning bottom of page in postscript and top
+     * of page in SVG).  I haven't looked into whether this does in fact cause fuzziness, I merely
+     * note the possibility.  Rounding done by extension/internal/ps.cpp (e.g. floor/ceil calls)
+     * will also affect whether fuzziness occurs.
+     *
+     * The remainder of this comment discusses the origin of the numbers used for ISO page sizes in
+     * this table and in ghostscript.
+     *
+     * The versions here, in mm, are the official sizes according to
+     * <a href="http://en.wikipedia.org/wiki/Paper_sizes">http://en.wikipedia.org/wiki/Paper_sizes</a>
+     * at 2005-01-25.  (The ISO entries in the below table
+     * were produced mechanically from the table on that page.)
+     *
+     * (The rule seems to be that A0, B0, ..., D0. sizes are rounded to the nearest number of mm
+     * from the "theoretical size" (i.e. 1000 * sqrt(2) or pow(2.0, .25) or the like), whereas
+     * going from e.g. A0 to A1 always take the floor of halving -- which by chance coincides
+     * exactly with flooring the "theoretical size" for n != 0 instead of the rounding to nearest
+     * done for n==0.)
+     *
+     * Ghostscript paper sizes are given in gs_statd.ps according to gs(1).  gs_statd.ps always
+     * uses an integer number ofpt: sometimes gs_statd.ps rounds to nearest (e.g. a1), sometimes
+     * floors (e.g. a10), sometimes ceils (e.g. a8).
+     *
+     * I'm not sure how ghostscript's gs_statd.ps was calculated: it isn't just rounding the
+     * "theoretical size" of each page topt (see a0), nor is it rounding the a0 size times an
+     * appropriate power of two (see a1).  Possibly it was prepared manually, with a human applying
+     * inconsistent rounding rules when converting from mm to pt.
+     */
+    /** \todo
+     * Should we include the JIS B series (used in Japan)
+     * (JIS B0 is sometimes called JB0, and similarly for JB1 etc)?
+     * Should we exclude B7--B10 and A7--10 to make the list smaller ?
+     * Should we include any of the ISO C, D and E series (see below) ?
+     */
+
+
+
+    /* See http://www.hbp.com/content/PCR_envelopes.cfm for a much larger list of US envelope
+       sizes. */
+    /* Note that `Folio' (used in QPrinter/KPrinter) is deliberately absent from this list, as it
+       means different sizes to different people: different people may expect the width to be
+       either 8, 8.25 or 8.5 inches, and the height to be either 13 or 13.5 inches, even
+       restricting our interpretation to foolscap folio.  If you wish to introduce a folio-like
+       page size to the list, then please consider using a name more specific than just `Folio' or
+       `Foolscap Folio'. */
+
+static char const pages_skeleton[] = R"(#Inkscape page sizes
+#NAME,                    WIDTH, HEIGHT, UNIT
+A4,                         210,    297, mm
+US Letter,                  8.5,     11, in
+US Legal,                   8.5,     14, in
+US Executive,              7.25,   10.5, in
+US Ledger/Tabloid,           11,     17, in
+A0,                         841,   1189, mm
+A1,                         594,    841, mm
+A2,                         420,    594, mm
+A3,                         297,    420, mm
+A5,                         148,    210, mm
+A6,                         105,    148, mm
+A7,                          74,    105, mm
+A8,                          52,     74, mm
+A9,                          37,     52, mm
+A10,                         26,     37, mm
+B0,                        1000,   1414, mm
+B1,                         707,   1000, mm
+B2,                         500,    707, mm
+B3,                         353,    500, mm
+B4,                         250,    353, mm
+B5,                         176,    250, mm
+B6,                         125,    176, mm
+B7,                          88,    125, mm
+B8,                          62,     88, mm
+B9,                          44,     62, mm
+B10,                         31,     44, mm
+C0,                         917,   1297, mm
+C1,                         648,    917, mm
+C2,                         458,    648, mm
+C3,                         324,    458, mm
+C4,                         229,    324, mm
+C5,                         162,    229, mm
+C6,                         114,    162, mm
+C7,                          81,    114, mm
+C8,                          57,     81, mm
+C9,                          40,     57, mm
+C10,                         28,     40, mm
+D1,                         545,    771, mm
+D2,                         385,    545, mm
+D3,                         272,    385, mm
+D4,                         192,    272, mm
+D5,                         136,    192, mm
+D6,                          96,    136, mm
+D7,                          68,     96, mm
+E3,                         400,    560, mm
+E4,                         280,    400, mm
+E5,                         200,    280, mm
+E6,                         140,    200, mm
+CSE,                        462,    649, pt
+US #10 Envelope,            9.5,  4.125, in
+DL Envelope,                220,    110, mm
+Banner 468x60,              468,     60, px
+Icon 16x16,                  16,     16, px
+Icon 32x32,                  32,     32, px
+Icon 48x48,                  48,     48, px
+ID Card (ISO 7810),       85.60,  53.98, mm
+Business Card (US),         3.5,      2, in
+Business Card (Europe),      85,     55, mm
+Business Card (AU/NZ),       90,     55, mm
+Arch A,                       9,     12, in
+Arch B,                      12,     18, in
+Arch C,                      18,     24, in
+Arch D,                      24,     36, in
+Arch E,                      36,     48, in
+Arch E1,                     30,     42, in
+Video SD / PAL,             768,    576, px
+Video SD-Widescreen / PAL, 1024,    576, px
+Video SD / NTSC,            544,    480, px
+Video SD-Widescreen / NTSC, 872,    486, px
+Video HD 720p,             1280,    720, px
+Video HD 1080p,            1920,   1080, px
+Video DCI 2k (Full Frame), 2048,   1080, px
+Video UHD 4k,              3840,   2160, px
+Video DCI 4k (Full Frame), 4096,   2160, px
+Video UHD 8k,              7680,   4320, px
+)";
+
+#endif
diff --git a/src/util/paper.cpp b/src/util/paper.cpp
new file mode 100644
index 0000000..3a3efe2
--- /dev/null
+++ b/src/util/paper.cpp
@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape PaperSize
+ *
+ * Authors:
+ *      Bob Jamison (2006)
+ *      Martin Owens (2021)
+ *
+ * Copyright (C) 2021 AUTHORS
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/i18n.h>
+
+#include "paper.h"
+#include "pages-skeleton.h"
+
+#include "io/resource.h"
+
+namespace Inkscape {
+
+/**
+ * Returns a list of page sizes.
+ */ 
+const std::vector<PaperSize>& PaperSize::getPageSizes()
+{   
+    // Static makes us only load pages once.
+    static std::vector<PaperSize> ret;
+    if (!ret.empty())
+        return ret;
+    
+    char *path = Inkscape::IO::Resource::profile_path("pages.csv");
+    if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
+        if (!g_file_set_contents(path, pages_skeleton, -1, nullptr)) {
+            g_warning("%s", _("Failed to create the page file."));
+        }
+    }   
+    gchar *content = nullptr;
+    if (g_file_get_contents(path, &content, nullptr, nullptr)) {
+        gchar **lines = g_strsplit_set(content, "\n", 0); 
+    
+        for (int i = 0; lines && lines[i]; ++i) {
+            gchar **line = g_strsplit_set(lines[i], ",", 5);
+            if (!line[0] || !line[1] || !line[2] || !line[3] || line[0][0]=='#') 
+                continue;
+    
+            //name, width, height, unit
+            double width = g_ascii_strtod(line[1], nullptr);
+            double height = g_ascii_strtod(line[2], nullptr);
+            g_strstrip(line[0]);
+            g_strstrip(line[3]);
+            Glib::ustring name = line[0];
+            ret.push_back(PaperSize(name, width, height, Inkscape::Util::unit_table.getUnit(line[3])));
+        }
+        g_strfreev(lines); 
+        g_free(content);
+    }   
+    g_free(path);
+    return ret;
+}   
+
+
+PaperSize::PaperSize()
+    : name("")
+    , width(0.0)
+    , height(0.0)
+{
+    unit = Inkscape::Util::unit_table.getUnit("px");
+}
+
+
+PaperSize::PaperSize(std::string name, double width, double height, Inkscape::Util::Unit const *unit)
+    : name(std::move(name))
+    , width(width)
+    , height(height)
+    , unit(unit) 
+{}
+
+std::string PaperSize::getDescription(bool landscape) const {
+    return toDescription(name, size[landscape], size[!landscape], unit);
+}
+
+std::string PaperSize::toDescription(std::string name, double x, double y, Inkscape::Util::Unit const *unit)
+{
+    return name + " (" + formatNumber(x) + " x " + formatNumber(y) + " " + unit->abbr + ")";
+}
+
+std::string PaperSize::formatNumber(double val)
+{
+    char buf[20];
+    snprintf(buf, 19, "%0.1f", val);
+    auto ret = std::string(buf);
+    // C++ doesn't provide a good number formatting control, so hack off trailing zeros.
+    if ((ret.length() > 2) && (ret.back() == '0')) {
+        ret = ret.substr(0, ret.length() - 2);
+    }
+    return ret;
+}
+
+void PaperSize::assign(const PaperSize &other)
+{
+    name = other.name;
+    width = other.width;
+    height = other.height;
+    auto [smaller, larger] = std::minmax(width, height);
+    size = Geom::Point(smaller, larger);
+    unit = other.unit;
+}
+
+/**
+ * Returns a matching paper size, if possible.
+ */
+const PaperSize *PaperSize::findPaperSize(double width, double height, Inkscape::Util::Unit const *unit)
+{
+    auto [smaller, larger] = std::minmax(width, height);
+    auto size = Geom::Point(smaller, larger);
+    auto px = Inkscape::Util::unit_table.getUnit("px");
+
+    for (auto&& page_size : Inkscape::PaperSize::getPageSizes()) {
+        auto cmp = Geom::Point(
+            unit->convert(size[0], page_size.unit),
+            unit->convert(size[1], page_size.unit)
+        );
+        // We want a half a pixel tollerance to catch floating point errors
+        auto tollerance = px->convert(0.5, page_size.unit);
+        if (Geom::are_near(page_size.size, cmp, tollerance)) {
+            return &page_size;
+        }
+    }
+    return nullptr;
+}
+
+} // namespace Inkscape
+
+/*
+  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/util/paper.h b/src/util/paper.h
new file mode 100644
index 0000000..225e806
--- /dev/null
+++ b/src/util/paper.h
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape Paper Sizes
+ *
+ * Authors:
+ *
+ * Copyright (C) 2013 AUTHORS
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <string>
+#include <vector>
+#include <2geom/point.h>
+
+#include "units.h"
+
+#ifndef INKSCAPE_UTIL_PAPER_H
+#define INKSCAPE_UTIL_PAPER_H
+
+namespace Inkscape {
+
+/**
+ * Data class used to store common paper dimensions from pages.csv
+ */ 
+class PaperSize
+{
+public:
+    PaperSize();
+    PaperSize(std::string name, double width, double height, Inkscape::Util::Unit const *unit);
+    PaperSize(const PaperSize &other) { assign(other); } 
+    PaperSize &operator=(const PaperSize &other) { assign(other); return *this; }
+
+    ~PaperSize() = default;
+
+    std::string name;
+    Geom::Point size;
+    double width;
+    double height;
+    Inkscape::Util::Unit const *unit; /// pointer to object in UnitTable, do not delete
+
+    std::string getDescription(bool landscape) const;
+
+    static const std::vector<PaperSize>& getPageSizes();
+    static const PaperSize *findPaperSize(double width, double height, Inkscape::Util::Unit const *unit);
+
+    static std::string toDescription(std::string name, double x, double y, Inkscape::Util::Unit const *unit);
+private:
+    void assign(const PaperSize &other);
+    static std::string formatNumber(double val);
+};
+
+} // namespace Inkscape
+
+#endif // define INKSCAPE_UTIL_UNITS_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/util/preview.cpp b/src/util/preview.cpp
new file mode 100644
index 0000000..4dd3283
--- /dev/null
+++ b/src/util/preview.cpp
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Utility functions for generating export previews.
+ */
+/* Authors:
+ *   Anshudhar Kumar Singh <anshudhar2001@gmail.com>
+ *   Martin Owens <doctormo@gmail.com>
+ *
+ * Copyright (C) 2021 Anshudhar Kumar Singh
+ *               2021 Martin Owens
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "preview.h"
+
+#include "desktop.h"
+#include "document.h"
+#include "display/cairo-utils.h"
+#include "display/drawing-context.h"
+#include "object/sp-namedview.h"
+#include "object/sp-root.h"
+#include "page-manager.h"
+
+namespace Inkscape {
+namespace UI {
+namespace PREVIEW {
+
+GdkPixbuf *render_preview(SPDocument *doc, Inkscape::Drawing &drawing, SPItem *item,
+                          unsigned width_in, unsigned height_in, Geom::OptRect *dboxIn)
+{
+    if (auto name = (item ? item->getId() : nullptr)) {
+        // Get item even if it's in another document.
+        if (item->document != doc) {
+            item = dynamic_cast<SPItem *>(doc->getObjectById(name));
+        }
+    }
+
+    Geom::OptRect dbox;
+    if (dboxIn) {
+        dbox = *dboxIn;
+    } else if (item) {
+        if (item->parent) {
+            dbox = item->documentVisualBounds();
+        } else {
+            dbox = doc->preferredBounds();
+        }
+    } else if (doc->getRoot()) {
+        // If we still dont have a dbox we will use document coordinates.
+        dbox = doc->getRoot()->documentVisualBounds();
+    }
+
+    // If we still dont have anything to render then return
+    if (!dbox) return nullptr;
+
+    // Calculate a scaling factor for the requested bounding box.
+    double sf = 1.0;
+    Geom::IntRect ibox = dbox->roundOutwards();
+    if (ibox.width() != width_in || ibox.height() != height_in) {
+        sf = std::min((double)width_in / dbox->width(),
+                      (double)height_in / dbox->height());
+        auto scaled_box = *dbox * Geom::Scale(sf);
+        ibox = scaled_box.roundOutwards();
+    }
+
+    // Resize the contents to the available space with a scale factor
+    drawing.root()->setTransform(Geom::Scale(sf));
+    drawing.update();
+
+    Geom::IntPoint pdim(width_in, height_in);
+    // The unsigned width/height can wrap around when negative.
+    int dx = ((int)width_in - ibox.width()) / 2;
+    int dy = ((int)height_in - ibox.height()) / 2;
+    Geom::IntRect area = Geom::IntRect::from_xywh(ibox.min() - Geom::IntPoint(dx, dy), pdim);
+
+    /* Actual renderable area */
+    Geom::IntRect ua = *Geom::intersect(ibox, area);
+
+    /* Render */
+    cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ua.width(), ua.height());
+    Inkscape::DrawingContext dc(s, ua.min());
+    cairo_t *cr = cairo_create(s);
+    cairo_rectangle(cr, 0, 0, ua.width(), ua.height());
+
+    guint32 bg = doc->getPageManager().background_color;
+
+    // We always use checkerboard to indicate transparency.
+    if (SP_RGBA32_A_F(bg) < 1.0) {
+        auto pattern = ink_cairo_pattern_create_checkerboard(bg, false);
+        auto background = Cairo::RefPtr<Cairo::Pattern>(new Cairo::Pattern(pattern));
+        cairo_set_source(cr, background->cobj());
+        cairo_fill(cr);
+    }
+    // We always draw the background on top to indicate partial backgrounds
+    auto background = Cairo::SolidPattern::create_rgba(
+        SP_RGBA32_R_F(bg), SP_RGBA32_G_F(bg),
+        SP_RGBA32_B_F(bg), SP_RGBA32_A_F(bg));
+    cairo_set_source(cr, background->cobj());
+    cairo_fill(cr);
+
+    cairo_save(cr);
+    cairo_destroy(cr);
+
+    drawing.render(dc, ua);
+    cairo_surface_flush(s);
+    return ink_pixbuf_create_from_cairo_surface(s);
+}
+
+} // namespace PREVIEW
+} // namespace UI
+} // namespace Inkscape
diff --git a/src/util/preview.h b/src/util/preview.h
new file mode 100644
index 0000000..36de1fc
--- /dev/null
+++ b/src/util/preview.h
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Utility functions for previewing icon representation.
+ */
+/* Authors:
+ *   Jon A. Cruz
+ *   Bob Jamison
+ *   Other dudes from The Inkscape Organization
+ *   Abhishek Sharma
+ *   Anshudhar Kumar Singh <anshudhar2001@gmail.com>
+ *
+ * Copyright (C) 2004 Bob Jamison
+ * Copyright (C) 2005,2010 Jon A. Cruz
+ * Copyright (C) 2021 Anshudhar Kumar Singh
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SP_PREVIEW_UTIL_H
+#define SP_PREVIEW_UTIL_H
+
+#include <glibmm/main.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "display/drawing.h"
+
+class SPDocument;
+class SPItem;
+
+namespace Inkscape {
+namespace UI {
+namespace PREVIEW {
+
+// takes doc, drawing, icon, and icon name to produce pixels
+GdkPixbuf *render_preview(SPDocument *doc, Inkscape::Drawing &drawing, SPItem *item,
+                          unsigned width_in, unsigned height_in, Geom::OptRect *dboxIn = nullptr);
+
+} // namespace PREVIEW
+} // namespace UI
+} // namespace Inkscape
+
+#endif
diff --git a/src/util/reference.h b/src/util/reference.h
new file mode 100644
index 0000000..b4a123b
--- /dev/null
+++ b/src/util/reference.h
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Traits::Reference - traits class for dealing with reference types
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2004 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_TRAITS_REFERENCE_H
+#define SEEN_INKSCAPE_TRAITS_REFERENCE_H
+
+namespace Inkscape {
+
+namespace Traits {
+
+template <typename T>
+struct Reference {
+    typedef T const &RValue;
+    typedef T &LValue;
+    typedef T *Pointer;
+    typedef T const *ConstPointer;
+};
+
+template <typename T>
+struct Reference<T &> {
+    typedef T &RValue;
+    typedef T &LValue;
+    typedef T *Pointer;
+    typedef T const *ConstPointer;
+};
+
+}
+
+}
+
+#endif
+/*
+  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/util/share.cpp b/src/util/share.cpp
new file mode 100644
index 0000000..6c436dc
--- /dev/null
+++ b/src/util/share.cpp
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Util::ptr_shared<T> - like T const *, but stronger.
+ * Used to hold c-style strings for objects that are managed by the gc.
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2006 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "util/share.h"
+#include <glib.h>
+
+namespace Inkscape {
+namespace Util {
+
+ptr_shared share_string(char const *string) {
+    g_return_val_if_fail(string != nullptr, share_unsafe(nullptr));
+    return share_string(string, std::strlen(string));
+}
+
+ptr_shared share_string(char const *string, std::size_t length) {
+    g_return_val_if_fail(string != nullptr, share_unsafe(nullptr));
+    char *new_string=new (GC::ATOMIC) char[length+1];
+    std::memcpy(new_string, string, length);
+    new_string[length] = 0;
+    return share_unsafe(new_string);
+}
+
+}
+}
+
+/*
+  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/util/share.h b/src/util/share.h
new file mode 100644
index 0000000..e8b9fb1
--- /dev/null
+++ b/src/util/share.h
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape::Util::ptr_shared<T> - like T const *, but stronger.
+ * Used to hold c-style strings for objects that are managed by the gc.
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2006 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_UTIL_SHARE_H
+#define SEEN_INKSCAPE_UTIL_SHARE_H
+
+#include "inkgc/gc-core.h"
+#include <cstring>
+#include <cstddef>
+
+namespace Inkscape {
+namespace Util {
+
+class ptr_shared {
+public:
+
+    ptr_shared() : _string(nullptr) {}
+        ptr_shared(ptr_shared const &other) = default;
+
+    operator char const *() const { return _string; }
+    operator bool() const { return _string; }
+
+    char const *pointer() const { return _string; }
+    char const &operator[](int i) const { return _string[i]; }
+
+    ptr_shared operator+(int i) const {
+        return share_unsafe(_string+i);
+    }
+    ptr_shared operator-(int i) const {
+        return share_unsafe(_string-i);
+    }
+    //WARNING: No bounds checking in += and -= functions. Moving the pointer
+    //past the end of the string and then back could probably cause the garbage
+    //collector to deallocate the string inbetween, as there's temporary no
+    //valid reference pointing into the allocated space.
+    ptr_shared &operator+=(int i) {
+        _string += i;
+        return *this;
+    }
+    ptr_shared &operator-=(int i) {
+        _string -= i;
+        return *this;
+    }
+    std::ptrdiff_t operator-(ptr_shared const &other) {
+        return _string - other._string;
+    }
+
+    ptr_shared &operator=(ptr_shared const &other) = default;
+
+    bool operator==(ptr_shared const &other) const {
+        return _string == other._string;
+    }
+    bool operator!=(ptr_shared const &other) const {
+        return _string != other._string;
+    }
+    bool operator>(ptr_shared const &other) const {
+        return _string > other._string;
+    }
+    bool operator<(ptr_shared const &other) const {
+        return _string < other._string;
+    }
+
+    friend ptr_shared share_unsafe(char const *string); 
+
+private:
+    ptr_shared(char const *string) : _string(string) {}
+    static ptr_shared share_unsafe(char const *string) {
+        return ptr_shared(string);
+    }
+
+    //This class (and code using it) assumes that it never has to free this
+    //pointer, and that the memory it points to will not be freed as long as a
+    //ptr_shared pointing to it exists.
+    char const *_string;
+};
+
+ptr_shared share_string(char const *string);
+ptr_shared share_string(char const *string, std::size_t length);
+
+inline ptr_shared share_unsafe(char const *string) {
+    return ptr_shared::share_unsafe(string);
+}
+
+//TODO: Do we need this function?
+inline ptr_shared share_static_string(char const *string) {
+    return share_unsafe(string);
+}
+
+}
+}
+
+#endif
+/*
+  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/util/signal-blocker.h b/src/util/signal-blocker.h
new file mode 100644
index 0000000..8fb6256
--- /dev/null
+++ b/src/util/signal-blocker.h
@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Base RAII blocker for sgic++ signals.
+ *
+ * Authors:
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_INKSCAPE_UTIL_SIGNAL_BLOCKER_H
+#define SEEN_INKSCAPE_UTIL_SIGNAL_BLOCKER_H
+
+#include <string>
+#include <sigc++/connection.h>
+
+/**
+ * Base RAII blocker for sgic++ signals.
+ */
+class SignalBlocker
+{
+public:
+    /**
+     * Creates a new instance that if the signal is currently unblocked will block
+     * it until this instance is destructed and then will unblock it.
+     */
+    SignalBlocker( sigc::connection *connection ) :
+        _connection(connection),
+        _wasBlocked(_connection->blocked())
+    {
+        if (!_wasBlocked)
+        {
+            _connection->block();
+        }
+    }
+
+    /**
+     * Destructor that will unblock the signal if it was blocked initially by this
+     * instance.
+     */
+    ~SignalBlocker()
+    {
+        if (!_wasBlocked)
+        {
+            _connection->block(false);
+        }
+    }
+
+private:
+    // noncopyable, nonassignable
+    SignalBlocker(SignalBlocker const &other) = delete;
+    SignalBlocker& operator=(SignalBlocker const &other) = delete;
+    
+    sigc::connection *_connection;
+    bool _wasBlocked;
+};
+
+#endif // SEEN_INKSCAPE_UTIL_SIGNAL_BLOCKER_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/util/trim.h b/src/util/trim.h
new file mode 100644
index 0000000..c8c9fd5
--- /dev/null
+++ b/src/util/trim.h
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Inkscape::Util::trim - trim whitespace and other characters
+ *
+ * Authors:
+ *   Rafael Siejakowski <rs@rs-math.net>
+ *
+ * Copyright (C) 2022 the Authors.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_TRIM_H
+#define SEEN_TRIM_H
+
+#include <glibmm/ustring.h>
+#include <glibmm/regex.h>
+
+namespace Inkscape {
+namespace Util {
+
+/**
+ * @brief
+ * Modifies a string in place, removing leading and trailing whitespace characters.
+ * Optionally, it can remove other characters or ranges in addition to whitespace.
+ *
+ * @param input - a reference to a Glib::ustring which will be modified in place.
+ * @param also_remove - optional range of characters to remove in addition to whitespace.
+ *                      NOTE: these characters are inserted into a regex range (square brackets) and
+ *                            therefore may need to be regex-escaped. It is the responsibility of
+ *                            the user to pass a string that will work correctly in a regex range.
+ */
+inline void trim(Glib::ustring &input, Glib::ustring const &also_remove = "")
+{
+    auto const regex = Glib::Regex::create(Glib::ustring("^[\\s") + also_remove + "]*(.+?)[\\s"
+                                                  + also_remove + "]*$");
+    Glib::MatchInfo match_info;
+    regex->match(input, match_info);
+    if (!match_info.matches()) {
+        input.clear();
+        return;
+    }
+    input = match_info.fetch(1);
+}
+
+} // namespace Util
+} // namespace Inkscape
+
+#endif // SEEN_TRIM_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/util/units.cpp b/src/util/units.cpp
new file mode 100644
index 0000000..478e9dc
--- /dev/null
+++ b/src/util/units.cpp
@@ -0,0 +1,574 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape Units
+ *
+ * Authors:
+ *   Matthew Petroff <matthew@mpetroff.net>
+ *
+ * Copyright (C) 2013 Matthew Petroff
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cmath>
+#include <cerrno>
+#include <iomanip>
+#include <iostream>
+#include <utility>
+#include <unordered_map>
+#include <glib.h>
+#include <glibmm/regex.h>
+#include <glibmm/fileutils.h>
+#include <glibmm/markup.h>
+
+#include <2geom/coord.h>
+
+#include "io/resource.h"
+#include "util/units.h"
+#include "path-prefix.h"
+#include "streq.h"
+
+using Inkscape::Util::UNIT_TYPE_DIMENSIONLESS;
+using Inkscape::Util::UNIT_TYPE_LINEAR;
+using Inkscape::Util::UNIT_TYPE_RADIAL;
+using Inkscape::Util::UNIT_TYPE_FONT_HEIGHT;
+
+namespace
+{
+
+#define MAKE_UNIT_CODE(a, b) \
+    ((((unsigned)(a) & 0xdf) << 8) | ((unsigned)(b) & 0xdf))
+
+enum UnitCode {
+    UNIT_CODE_PX = MAKE_UNIT_CODE('p','x'),
+    UNIT_CODE_PT = MAKE_UNIT_CODE('p','t'),
+    UNIT_CODE_PC = MAKE_UNIT_CODE('p','c'),
+    UNIT_CODE_MM = MAKE_UNIT_CODE('m','m'),
+    UNIT_CODE_CM = MAKE_UNIT_CODE('c','m'),
+    UNIT_CODE_IN = MAKE_UNIT_CODE('i','n'),
+    UNIT_CODE_EM = MAKE_UNIT_CODE('e','m'),
+    UNIT_CODE_EX = MAKE_UNIT_CODE('e','x'),
+    UNIT_CODE_PERCENT = MAKE_UNIT_CODE('%',0)
+};
+
+// TODO: convert to constexpr in C++11, so that the above constants can be eliminated
+inline unsigned make_unit_code(char const *str) {
+    if (!str || str[0] == 0) return 0;
+    return MAKE_UNIT_CODE(str[0], str[1]);
+}
+
+
+// This must match SVGLength::Unit
+unsigned const svg_length_lookup[] = {
+    0,
+    UNIT_CODE_PX,
+    UNIT_CODE_PT,
+    UNIT_CODE_PC,
+    UNIT_CODE_MM,
+    UNIT_CODE_CM,
+    UNIT_CODE_IN,
+    UNIT_CODE_EM,
+    UNIT_CODE_EX,
+    UNIT_CODE_PERCENT
+};
+
+
+
+// maps unit codes obtained from their abbreviations to their SVGLength unit indexes
+typedef std::unordered_map<unsigned, SVGLength::Unit> UnitCodeLookup;
+
+UnitCodeLookup make_unit_code_lookup()
+{
+    UnitCodeLookup umap;
+    for (unsigned i = 1; i < G_N_ELEMENTS(svg_length_lookup); ++i) {
+        umap[svg_length_lookup[i]] = static_cast<SVGLength::Unit>(i);
+    }
+    return umap;
+}
+
+UnitCodeLookup const unit_code_lookup = make_unit_code_lookup();
+
+
+
+typedef std::unordered_map<Glib::ustring, Inkscape::Util::UnitType> TypeMap;
+
+/** A std::map that gives the data type value for the string version.
+ * @todo consider hiding map behind hasFoo() and getFoo() type functions. */
+TypeMap make_type_map()
+{
+    TypeMap tmap;
+    tmap["DIMENSIONLESS"] = UNIT_TYPE_DIMENSIONLESS;
+    tmap["LINEAR"] = UNIT_TYPE_LINEAR;
+    tmap["RADIAL"] = UNIT_TYPE_RADIAL;
+    tmap["FONT_HEIGHT"] = UNIT_TYPE_FONT_HEIGHT;
+    // Note that code was not yet handling LINEAR_SCALED, TIME, QTY and NONE
+
+    return tmap;
+}
+
+TypeMap const type_map = make_type_map();
+
+} // namespace
+
+namespace Inkscape {
+namespace Util {
+
+class UnitParser : public Glib::Markup::Parser
+{
+public:
+    typedef Glib::Markup::Parser::AttributeMap AttrMap;
+    typedef Glib::Markup::ParseContext Ctx;
+
+    UnitParser(UnitTable *table);
+    ~UnitParser() override = default;
+
+protected:
+    void on_start_element(Ctx &ctx, Glib::ustring const &name, AttrMap const &attrs) override;
+    void on_end_element(Ctx &ctx, Glib::ustring const &name) override;
+    void on_text(Ctx &ctx, Glib::ustring const &text) override;
+
+public:
+    UnitTable *tbl;
+    bool primary;
+    bool skip;
+    Unit unit;
+};
+
+UnitParser::UnitParser(UnitTable *table) :
+    tbl(table),
+    primary(false),
+    skip(false)
+{
+}
+
+#define BUFSIZE (255)
+
+Unit::Unit() :
+    type(UNIT_TYPE_DIMENSIONLESS), // should this or NONE be the default?
+    factor(1.0),
+    name(),
+    name_plural(),
+    abbr(),
+    description()
+{
+}
+
+Unit::Unit(UnitType type,
+           double factor,
+           Glib::ustring name,
+           Glib::ustring name_plural,
+           Glib::ustring abbr,
+           Glib::ustring description)
+    : type(type)
+    , factor(factor)
+    , name(std::move(name))
+    , name_plural(std::move(name_plural))
+    , abbr(std::move(abbr))
+    , description(std::move(description))
+{
+    g_return_if_fail(factor <= 0);
+}
+
+void Unit::clear()
+{
+    *this = Unit();
+}
+
+int Unit::defaultDigits() const
+{
+    int factor_digits = int(log10(factor));
+    if (factor_digits < 0) {
+        g_warning("factor = %f, factor_digits = %d", factor, factor_digits);
+        g_warning("factor_digits < 0 - returning 0");
+        factor_digits = 0;
+    }
+    return factor_digits;
+}
+
+bool Unit::compatibleWith(Unit const *u) const
+{
+    // Percentages
+    if (type == UNIT_TYPE_DIMENSIONLESS || u->type == UNIT_TYPE_DIMENSIONLESS) {
+        return true;
+    }
+
+    // Other units with same type
+    if (type == u->type) {
+        return true;
+    }
+
+    // Different, incompatible types
+    return false;
+}
+bool Unit::compatibleWith(Glib::ustring const &u) const
+{
+    return compatibleWith(unit_table.getUnit(u));
+}
+
+bool Unit::operator==(Unit const &other) const
+{
+    return (type == other.type && name.compare(other.name) == 0);
+}
+
+int Unit::svgUnit() const
+{
+    char const *astr = abbr.c_str();
+    unsigned code = make_unit_code(astr);
+
+    UnitCodeLookup::const_iterator u = unit_code_lookup.find(code);
+    if (u != unit_code_lookup.end()) {
+        return u->second;
+    }
+    return 0;
+}
+
+double Unit::convert(double from_dist, Unit const *to) const
+{
+    // Percentage
+    if (to->type == UNIT_TYPE_DIMENSIONLESS) {
+        return from_dist * to->factor;
+    }   
+      
+    // Incompatible units
+    if (type != to->type) {
+        return -1; 
+    }   
+      
+    // Compatible units
+    return from_dist * factor / to->factor;
+}
+double Unit::convert(double from_dist, Glib::ustring const &to) const
+{
+    return convert(from_dist, unit_table.getUnit(to));
+} 
+double Unit::convert(double from_dist, char const *to) const
+{
+    return convert(from_dist, unit_table.getUnit(to));
+}
+
+
+
+Unit UnitTable::_empty_unit;
+
+UnitTable::UnitTable()
+{
+    using namespace Inkscape::IO::Resource;
+    auto filename = get_path_string(SYSTEM, UIS, "units.xml");
+    load(filename);
+}
+
+UnitTable::~UnitTable()
+{
+    for (auto & iter : _unit_map)
+    {
+        delete iter.second;
+    }
+}
+
+void UnitTable::addUnit(Unit const &u, bool primary)
+{
+    _unit_map[make_unit_code(u.abbr.c_str())] = new Unit(u);
+    if (primary) {
+        _primary_unit[u.type] = u.abbr;
+    }
+}
+
+Unit const *UnitTable::getUnit(char const *abbr) const
+{
+    UnitCodeMap::const_iterator f = _unit_map.find(make_unit_code(abbr));
+    if (f != _unit_map.end()) {
+        return &(*f->second);
+    }
+    return &_empty_unit;
+}
+
+Unit const *UnitTable::getUnit(Glib::ustring const &unit_abbr) const
+{
+    return getUnit(unit_abbr.c_str());
+}
+Unit const *UnitTable::getUnit(SVGLength::Unit u) const
+{
+    if (u == 0 || u > SVGLength::LAST_UNIT) {
+        return &_empty_unit;
+    }
+
+    UnitCodeMap::const_iterator f = _unit_map.find(svg_length_lookup[u]);
+    if (f != _unit_map.end()) {
+        return &(*f->second);
+    }
+    return &_empty_unit;
+}
+
+Unit const *UnitTable::findUnit(double factor, UnitType type) const
+{
+    const double eps = factor * 0.01; // allow for 1% deviation
+
+    UnitCodeMap::const_iterator cit = _unit_map.begin();
+    while (cit != _unit_map.end()) {
+        if (cit->second->type == type) {
+            if (Geom::are_near(cit->second->factor, factor, eps)) {
+                // unit found!
+                break;
+            }
+        }
+        ++cit;
+    }
+
+    if (cit != _unit_map.end()) {
+        return cit->second;
+    } else {
+        return getUnit(_primary_unit[type]);
+    }
+}
+
+Quantity UnitTable::parseQuantity(Glib::ustring const &q) const
+{
+    Glib::MatchInfo match_info;
+
+    // Extract value
+    double value = 0;
+    Glib::RefPtr<Glib::Regex> value_regex = Glib::Regex::create("[-+]*[\\d+]*[\\.,]*[\\d+]*[eE]*[-+]*\\d+");
+    if (value_regex->match(q, match_info)) {
+        std::istringstream tmp_v(match_info.fetch(0).raw());
+        tmp_v >> value;
+    }
+    int start_pos, end_pos;
+    match_info.fetch_pos(0, end_pos, start_pos);
+    end_pos = q.size() - start_pos;
+    Glib::ustring u = q.substr(start_pos, end_pos);
+
+    // Extract unit abbreviation
+    Glib::ustring abbr;
+    Glib::RefPtr<Glib::Regex> unit_regex = Glib::Regex::create("[A-z%]+");
+    if (unit_regex->match(u, match_info)) {
+        abbr = match_info.fetch(0);
+    }
+
+    Quantity qty(value, abbr);
+    return qty;
+}
+
+/* UNSAFE while passing around pointers to the Unit objects in this table 
+bool UnitTable::deleteUnit(Unit const &u)
+{
+    bool deleted = false;
+    // Cannot delete the primary unit type since it's
+    // used for conversions
+    if (u.abbr != _primary_unit[u.type]) {
+        UnitCodeMap::iterator iter = _unit_map.find(make_unit_code(u.abbr.c_str()));
+        if (iter != _unit_map.end()) {
+            delete (*iter).second;
+            _unit_map.erase(iter);
+            deleted = true;
+        }
+    }
+    return deleted;
+}
+*/
+
+bool UnitTable::hasUnit(Glib::ustring const &unit) const
+{
+    UnitCodeMap::const_iterator iter = _unit_map.find(make_unit_code(unit.c_str()));
+    return (iter != _unit_map.end());
+}
+
+UnitTable::UnitMap UnitTable::units(UnitType type) const
+{
+    UnitMap submap;
+    for (auto iter : _unit_map) {
+        if (iter.second->type == type) {
+            submap.insert(UnitMap::value_type(iter.second->abbr, *iter.second));
+        }
+    }
+
+    return submap;
+}
+
+Glib::ustring UnitTable::primary(UnitType type) const
+{
+    return _primary_unit[type];
+}
+
+bool UnitTable::load(std::string const &filename) {
+    UnitParser uparser(this);
+    Glib::Markup::ParseContext ctx(uparser);
+
+    try {
+        Glib::ustring unitfile = Glib::file_get_contents(filename);
+        ctx.parse(unitfile);
+        ctx.end_parse();
+    } catch (Glib::FileError const &e) {
+        g_warning("Units file %s is missing: %s\n", filename.c_str(), e.what().c_str());
+        return false;
+    } catch (Glib::MarkupError const &e) {
+        g_warning("Problem loading units file '%s': %s\n", filename.c_str(), e.what().c_str());
+        return false;
+    }
+    return true;
+}
+
+/*
+bool UnitTable::save(std::string const &filename) {
+    g_warning("UnitTable::save(): not implemented");
+
+    return false;
+}
+*/
+
+Inkscape::Util::UnitTable unit_table;
+
+void UnitParser::on_start_element(Ctx &/*ctx*/, Glib::ustring const &name, AttrMap const &attrs)
+{
+    if (name == "unit") {
+        // reset for next use
+        unit.clear();
+        primary = false;
+        skip = false;
+
+        AttrMap::const_iterator f;
+        if ((f = attrs.find("type")) != attrs.end()) {
+            Glib::ustring type = f->second;
+            TypeMap::const_iterator tf = type_map.find(type);
+            if (tf != type_map.end()) {
+                unit.type = tf->second;
+            } else {
+                g_warning("Skipping unknown unit type '%s'.\n", type.c_str());
+                skip = true;
+            }
+        }
+        if ((f = attrs.find("pri")) != attrs.end()) {
+            primary = (f->second[0] == 'y' || f->second[0] == 'Y');
+        }
+    }
+}
+
+void UnitParser::on_text(Ctx &ctx, Glib::ustring const &text)
+{
+    Glib::ustring element = ctx.get_element();
+    if (element == "name") {
+        unit.name = text;
+    } else if (element == "plural") {
+        unit.name_plural = text;
+    } else if (element == "abbr") {
+        unit.abbr = text;
+    } else if (element == "factor") {
+        // TODO make sure we use the right conversion
+        unit.factor = g_ascii_strtod(text.c_str(), nullptr);
+    } else if (element == "description") {
+        unit.description = text;
+    }
+}
+
+void UnitParser::on_end_element(Ctx &/*ctx*/, Glib::ustring const &name)
+{
+    if (name == "unit" && !skip) {
+        tbl->addUnit(unit, primary);
+    }
+}
+
+Quantity::Quantity(double q, Unit const *u)
+  : unit(u)
+  , quantity(q)
+{
+}
+Quantity::Quantity(double q, Glib::ustring const &u)
+  : unit(unit_table.getUnit(u.c_str()))
+  , quantity(q)
+{
+}
+Quantity::Quantity(double q, char const *u)
+  : unit(unit_table.getUnit(u))
+  , quantity(q)
+{
+}
+
+bool Quantity::compatibleWith(Unit const *u) const
+{
+    return unit->compatibleWith(u);
+}
+bool Quantity::compatibleWith(Glib::ustring const &u) const
+{
+    return compatibleWith(u.c_str());
+}
+bool Quantity::compatibleWith(char const *u) const
+{
+    return compatibleWith(unit_table.getUnit(u));
+}
+
+double Quantity::value(Unit const *u) const
+{
+    return convert(quantity, unit, u);
+}
+double Quantity::value(Glib::ustring const &u) const
+{
+    return value(u.c_str());
+}
+double Quantity::value(char const *u) const
+{
+    return value(unit_table.getUnit(u));
+}
+
+Glib::ustring Quantity::string(Unit const *u) const {
+    return Glib::ustring::format(std::fixed, std::setprecision(2), value(u)) + " " + u->abbr;
+}
+Glib::ustring Quantity::string(Glib::ustring const &u) const {
+    return string(unit_table.getUnit(u.c_str()));
+}
+Glib::ustring Quantity::string() const {
+    return string(unit);
+}
+
+double Quantity::convert(double from_dist, Unit const *from, Unit const *to)
+{
+    return from->convert(from_dist, to);
+}
+double Quantity::convert(double from_dist, Glib::ustring const &from, Unit const *to)
+{
+    return convert(from_dist, unit_table.getUnit(from.c_str()), to);
+}
+double Quantity::convert(double from_dist, Unit const *from, Glib::ustring const &to)
+{
+    return convert(from_dist, from, unit_table.getUnit(to.c_str()));
+}
+double Quantity::convert(double from_dist, Glib::ustring const &from, Glib::ustring const &to)
+{
+    return convert(from_dist, unit_table.getUnit(from.c_str()), unit_table.getUnit(to.c_str()));
+}
+double Quantity::convert(double from_dist, char const *from, char const *to)
+{
+    return convert(from_dist, unit_table.getUnit(from), unit_table.getUnit(to));
+}
+
+bool Quantity::operator<(Quantity const &rhs) const
+{
+    if (unit->type != rhs.unit->type) {
+        g_warning("Incompatible units");
+        return false;
+    }
+    return quantity < rhs.value(unit);
+}
+bool Quantity::operator==(Quantity const &other) const
+{
+    /** \fixme  This is overly strict. I think we should change this to:
+    if (unit->type != other.unit->type) {
+        g_warning("Incompatible units");
+        return false;
+    }
+    return are_near(quantity, other.value(unit));
+    */
+    return (*unit == *other.unit) && (quantity == other.quantity);
+}
+
+} // namespace Util
+} // namespace Inkscape
+
+/*
+  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/util/units.h b/src/util/units.h
new file mode 100644
index 0000000..c271ec5
--- /dev/null
+++ b/src/util/units.h
@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape Units
+ * These classes are used for defining different unit systems.
+ *
+ * Authors:
+ *   Matthew Petroff <matthew@mpetroff.net>
+ *
+ * Copyright (C) 2013 Matthew Petroff
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef INKSCAPE_UTIL_UNITS_H
+#define INKSCAPE_UTIL_UNITS_H
+
+#include <unordered_map>
+#include <boost/operators.hpp>
+#include <glibmm/ustring.h>
+#include <2geom/coord.h>
+#include "svg/svg-length.h"
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+#define DEFAULT_UNIT_NAME "mm"
+
+namespace std {
+template <>
+struct hash<Glib::ustring> : public std::unary_function<Glib::ustring, std::size_t> {
+    std::size_t operator()(Glib::ustring const &s) const {
+        return hash<std::string>()(s.raw());
+    }
+};
+} // namespace std
+
+#endif
+
+namespace Inkscape {
+namespace Util {
+
+enum UnitType {
+    UNIT_TYPE_DIMENSIONLESS,     /* Percentage */
+    UNIT_TYPE_LINEAR,
+    UNIT_TYPE_LINEAR_SCALED,
+    UNIT_TYPE_RADIAL,
+    UNIT_TYPE_TIME,
+    UNIT_TYPE_FONT_HEIGHT,
+    UNIT_TYPE_QTY,
+    UNIT_TYPE_NONE = -1
+};
+
+const char DEG[] = "°";
+
+class Unit
+    : boost::equality_comparable<Unit>
+{
+public:
+    Unit();
+    Unit(UnitType type,
+         double factor,
+         Glib::ustring name,
+         Glib::ustring name_plural,
+         Glib::ustring abbr,
+         Glib::ustring description);
+
+    void clear();
+
+    bool           isAbsolute() const { return type != UNIT_TYPE_DIMENSIONLESS; }
+
+    /**
+     * Returns the suggested precision to use for displaying numbers
+     * of this unit.
+     */
+    int            defaultDigits() const;
+
+    /** Checks if a unit is compatible with the specified unit. */
+    bool           compatibleWith(Unit const *u) const;
+    bool           compatibleWith(Glib::ustring const &) const;
+    bool           compatibleWith(char const *) const;
+
+    UnitType       type;
+    double         factor;
+    Glib::ustring  name;
+    Glib::ustring  name_plural;
+    Glib::ustring  abbr;
+    Glib::ustring  description;
+    
+    /** Check if units are equal. */
+    bool operator==(Unit const &other) const;
+    
+    /** Get SVG unit code. */
+    int svgUnit() const;
+
+    /** Convert value from this unit **/
+    double convert(double from_dist, Unit const *to) const;
+    double convert(double from_dist, Glib::ustring const &to) const;
+    double convert(double from_dist, char const *to) const;
+};
+
+class Quantity
+    : boost::totally_ordered<Quantity>
+{
+public:
+    Unit const *unit;
+    double quantity;
+    
+    /** Initialize a quantity. */
+    Quantity(double q, Unit const *u);
+    Quantity(double q, Glib::ustring const &u);
+    Quantity(double q, char const *u);
+    
+    /** Checks if a quantity is compatible with the specified unit. */
+    bool compatibleWith(Unit const *u) const;
+    bool compatibleWith(Glib::ustring const &u) const;
+    bool compatibleWith(char const *u) const;
+    
+    /** Return the quantity's value in the specified unit. */
+    double value(Unit const *u) const;
+    double value(Glib::ustring const &u) const;
+    double value(char const *u) const;
+    
+    /** Return a printable string of the value in the specified unit. */
+    Glib::ustring string(Unit const *u) const;
+    Glib::ustring string(Glib::ustring const &u) const;
+    Glib::ustring string() const;
+    
+    /** Convert distances. 
+       no NULL check is performed on the passed pointers to Unit objects!  */
+    static double convert(double from_dist, Unit const *from, Unit const *to);
+    static double convert(double from_dist, Glib::ustring const &from, Unit const *to);
+    static double convert(double from_dist, Unit const *from, Glib::ustring const &to);
+    static double convert(double from_dist, Glib::ustring const &from, Glib::ustring const &to);
+    static double convert(double from_dist, char const *from, char const *to);
+
+    /** Comparison operators. */
+    bool operator<(Quantity const &rhs) const;
+    bool operator==(Quantity const &other) const;
+};
+
+inline bool are_near(Quantity const &a, Quantity const &b, double eps=Geom::EPSILON)
+{
+    return Geom::are_near(a.quantity, b.value(a.unit), eps);
+}
+
+class UnitTable {
+public:
+    /**
+     * Initializes the unit tables and identifies the primary unit types.
+     *
+     * The primary unit's conversion factor is required to be 1.00
+     */
+    UnitTable();
+    virtual ~UnitTable();
+
+    typedef std::unordered_map<Glib::ustring, Unit> UnitMap;
+    typedef std::unordered_map<unsigned, Unit*> UnitCodeMap;
+
+    /** Add a new unit to the table */
+    void    addUnit(Unit const &u, bool primary);
+
+    /** Retrieve a given unit based on its string identifier */
+    Unit const *getUnit(Glib::ustring const &name) const;
+    Unit const *getUnit(char const *name) const;
+
+    /** Try to find a unit based on its conversion factor to the primary */
+    Unit const *findUnit(double factor, UnitType type) const;
+    
+    /** Retrieve a given unit based on its SVGLength unit */
+    Unit const *getUnit(SVGLength::Unit u) const;
+    
+    /** Retrieve a quantity based on its string identifier */
+    Quantity parseQuantity(Glib::ustring const &q) const;
+
+    /** Remove a unit definition from the given unit type table * /
+     * DISABLED, unsafe with the current passing around pointers to Unit objects in this table */
+    //bool    deleteUnit(Unit const &u);
+
+    /** Returns true if the given string 'name' is a valid unit in the table */
+    bool    hasUnit(Glib::ustring const &name) const;
+
+    /** Provides an iterable list of items in the given unit table */
+    UnitMap units(UnitType type) const;
+
+    /** Returns the default unit abbr for the given type */
+    Glib::ustring primary(UnitType type) const;
+
+    double  getScale() const;
+
+    void    setScale();
+
+    /** Load units from an XML file.
+     *
+     * Loads and merges the contents of the given file into the UnitTable,
+     * possibly overwriting existing unit definitions.
+     *
+     * @param filename file to be loaded
+     */
+    bool    load(std::string const &filename);
+
+    /* * Saves the current UnitTable to the given file. */
+    //bool    save(std::string const &filename);
+
+protected:
+    UnitCodeMap         _unit_map;
+    Glib::ustring       _primary_unit[UNIT_TYPE_QTY];
+
+    double              _linear_scale;
+    static Unit         _empty_unit;
+
+private:
+    UnitTable(UnitTable const &t);
+    UnitTable operator=(UnitTable const &t);
+
+};
+
+extern UnitTable unit_table;
+
+} // namespace Util
+} // namespace Inkscape
+
+#endif // define INKSCAPE_UTIL_UNITS_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/util/ziptool.cpp b/src/util/ziptool.cpp
new file mode 100644
index 0000000..dc87396
--- /dev/null
+++ b/src/util/ziptool.cpp
@@ -0,0 +1,3043 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors:
+ * see git history
+ * Bob Jamison
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU LGPL v2.1+, read the file 'COPYING' for more information.
+ */
+/*
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+/*
+ * This is intended to be a standalone, reduced capability
+ * implementation of Gzip and Zip functionality.  Its
+ * targeted use case is for archiving and retrieving single files
+ * which use these encoding types.  Being memory based and
+ * non-optimized, it is not useful in cases where very large
+ * archives are needed or where high performance is desired.
+ * However, it should hopefully work very well for smaller,
+ * one-at-a-time tasks.  What you get in return is the ability
+ * to drop these files into your project and remove the dependencies
+ * on ZLib and Info-Zip.  Enjoy.
+ */
+
+
+#include <cstdio>
+#include <cstdarg>
+#include <ctime>
+
+#include <string>
+#include <utility>
+
+#include "ziptool.h"
+
+
+
+
+
+
+//########################################################################
+//#  A D L E R  3 2
+//########################################################################
+
+/**
+ * Constructor
+ */
+Adler32::Adler32()
+{
+    reset();
+}
+
+/**
+ * Destructor
+ */
+Adler32::~Adler32()
+= default;
+
+/**
+ * Reset Adler-32 checksum to initial value.
+ */
+void Adler32::reset()
+{
+    value = 1;
+}
+
+// ADLER32_BASE is the largest prime number smaller than 65536
+#define ADLER32_BASE 65521
+
+void Adler32::update(unsigned char b)
+{
+    unsigned long s1 = value & 0xffff;
+    unsigned long s2 = (value >> 16) & 0xffff;
+    s1 += b & 0xff;
+    s2 += s1;
+    value = ((s2 % ADLER32_BASE) << 16) | (s1 % ADLER32_BASE);
+}
+
+void Adler32::update(char *str)
+{
+    if (str)
+        while (*str)
+            update((unsigned char)*str++);
+}
+
+
+/**
+ * Returns current checksum value.
+ */
+unsigned long Adler32::getValue()
+{
+    return value & 0xffffffffL;
+}
+
+
+
+//########################################################################
+//#  C R C  3 2
+//########################################################################
+
+/**
+ * Constructor
+ */
+Crc32::Crc32()
+{
+    reset();
+}
+
+/**
+ * Destructor
+ */
+Crc32::~Crc32()
+= default;
+
+static bool crc_table_ready = false;
+static unsigned long crc_table[256];
+
+/**
+ * make the table for a fast CRC.
+ */
+static void makeCrcTable()
+{
+    if (crc_table_ready)
+        return;
+    for (int n = 0; n < 256; n++)
+        {
+        unsigned long c = n;
+        for (int k = 8;  --k >= 0; )
+            {
+            if ((c & 1) != 0)
+                c = 0xedb88320 ^ (c >> 1);
+            else
+                c >>= 1;
+            }
+        crc_table[n] = c;
+        }
+    crc_table_ready = true;
+}
+
+
+/**
+ * Reset CRC-32 checksum to initial value.
+ */
+void Crc32::reset()
+{
+    value = 0;
+    makeCrcTable();
+}
+
+void Crc32::update(unsigned char b)
+{
+    unsigned long c = ~value;
+
+    c &= 0xffffffff;
+    c = crc_table[(c ^ b) & 0xff] ^ (c >> 8);
+    value = ~c;
+}
+
+
+void Crc32::update(char *str)
+{
+    if (str)
+        while (*str)
+            update((unsigned char)*str++);
+}
+
+void Crc32::update(const std::vector<unsigned char> &buf)
+{
+    std::vector<unsigned char>::const_iterator iter;
+    for (iter=buf.begin() ; iter!=buf.end() ; ++iter)
+        {
+        unsigned char ch = *iter;
+        update(ch);
+        }
+}
+
+
+/**
+ * Returns current checksum value.
+ */
+unsigned long Crc32::getValue()
+{
+    return value & 0xffffffffL;
+}
+
+//########################################################################
+//#  I N F L A T E R
+//########################################################################
+
+
+/**
+ *
+ */
+struct Huffman
+{
+    int *count;  // number of symbols of each length
+    int *symbol; // canonically ordered symbols
+};
+
+/**
+ *
+ */
+class Inflater
+{
+public:
+
+    Inflater();
+
+    virtual ~Inflater();
+
+    static const int MAXBITS   =  15; // max bits in a code
+    static const int MAXLCODES = 286; // max number of literal/length codes
+    static const int MAXDCODES =  30; // max number of distance codes
+    static const int MAXCODES  = 316; // max codes lengths to read
+    static const int FIXLCODES = 288; // number of fixed literal/length codes
+
+    /**
+     *
+     */
+    bool inflate(std::vector<unsigned char> &destination,
+                 std::vector<unsigned char> &source);
+
+private:
+
+    /**
+     *
+     */
+    void error(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    /**
+     *
+     */
+    void trace(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    /**
+     *
+     */
+    void dump();
+
+    /**
+     *
+     */
+    int buildHuffman(Huffman *h, int *length, int n);
+
+    /**
+     *
+     */
+    bool getBits(int need, int *oval);
+
+    /**
+     *
+     */
+    int doDecode(Huffman *h);
+
+    /**
+     *
+     */
+    bool doCodes(Huffman *lencode, Huffman *distcode);
+
+    /**
+     *
+     */
+    bool doStored();
+
+    /**
+     *
+     */
+    bool doFixed();
+
+    /**
+     *
+     */
+    bool doDynamic();
+
+
+    std::vector<unsigned char>dest;
+
+    std::vector<unsigned char>src;
+    unsigned long srcPos;  //current read position
+    int bitBuf;
+    int bitCnt;
+
+};
+
+
+/**
+ *
+ */
+Inflater::Inflater() :
+    dest(),
+    src(),
+    srcPos(0),
+    bitBuf(0),
+    bitCnt(0)
+{
+}
+
+/**
+ *
+ */
+Inflater::~Inflater()
+= default;
+
+/**
+ *
+ */
+void Inflater::error(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "Inflater error:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+/**
+ *
+ */
+void Inflater::trace(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "Inflater:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+
+/**
+ *
+ */
+void Inflater::dump()
+{
+    for (unsigned char i : dest)
+        {
+        fputc(i, stdout);
+        }
+}
+
+/**
+ *
+ */
+int Inflater::buildHuffman(Huffman *h, int *length, int n)
+{
+    // count number of codes of each length
+    for (int len = 0; len <= MAXBITS; len++)
+        h->count[len] = 0;
+    for (int symbol = 0; symbol < n; symbol++)
+        (h->count[length[symbol]])++;   // assumes lengths are within bounds
+    if (h->count[0] == n)               // no codes!
+        {
+        error("huffman tree will result in failed decode");
+        return -1;
+        }
+
+    // check for an over-subscribed or incomplete set of lengths
+    int left = 1;                // number of possible codes left of current length
+    for (int len = 1; len <= MAXBITS; len++)
+        {
+        left <<= 1;                     // one more bit, double codes left
+        left -= h->count[len];          // deduct count from possible codes
+        if (left < 0)
+            {
+            error("huffman over subscribed");
+            return -1;
+            }
+        }
+
+    // generate offsets into symbol table for each length for sorting
+    int offs[MAXBITS+1]; //offsets in symbol table for each length
+    offs[1] = 0;
+    for (int len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + h->count[len];
+
+    /*
+     * put symbols in table sorted by length, by symbol order within each
+     * length
+     */
+    for (int symbol = 0; symbol < n; symbol++)
+        if (length[symbol] != 0)
+            h->symbol[offs[length[symbol]]++] = symbol;
+
+    // return zero for complete set, positive for incomplete set
+    return left;
+}
+
+
+/**
+ *
+ */
+bool Inflater::getBits(int requiredBits, int *oval)
+{
+    long val = bitBuf;
+
+    //add more bytes if needed
+    while (bitCnt < requiredBits)
+        {
+        if (srcPos >= src.size())
+            {
+            error("premature end of input");
+            return false;
+            }
+        val |= ((long)(src[srcPos++])) << bitCnt;
+        bitCnt += 8;
+        }
+
+    //update the buffer and return the data
+    bitBuf =  (int)(val >> requiredBits);
+    bitCnt -= requiredBits;
+    *oval = (int)(val & ((1L << requiredBits) - 1));
+
+    return true;
+}
+
+
+/**
+ *
+ */
+int Inflater::doDecode(Huffman *h)
+{
+    int bitTmp  = bitBuf;
+    int left    = bitCnt;
+    int code    = 0;
+    int first   = 0;
+    int index   = 0;
+    int len     = 1;
+    int *next = h->count + 1;
+    while (true)
+        {
+        while (left--)
+            {
+            code   |=  bitTmp & 1;
+            bitTmp >>= 1;
+            int count  =   *next++;
+            if (code < first + count)
+                { /* if length len, return symbol */
+                bitBuf = bitTmp;
+                bitCnt = (bitCnt - len) & 7;
+                return h->symbol[index + (code - first)];
+                }
+            index +=  count;
+            first +=  count;
+            first <<= 1;
+            code  <<= 1;
+            len++;
+            }
+        left = (MAXBITS+1) - len;
+        if (left == 0)
+            break;
+        if (srcPos >= src.size())
+            {
+            error("premature end of input");
+            dump();
+            return -1;
+            }
+        bitTmp = src[srcPos++];
+        if (left > 8)
+            left = 8;
+        }
+
+    error("no end of block found");
+    return -1;
+}
+
+/**
+ *
+ */
+bool Inflater::doCodes(Huffman *lencode, Huffman *distcode)
+{
+    static const int lens[29] = { // Size base for length codes 257..285
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
+    static const int lext[29] = { // Extra bits for length codes 257..285
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
+    static const int dists[30] = { // Offset base for distance codes 0..29
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577};
+    static const int dext[30] = { // Extra bits for distance codes 0..29
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+        12, 12, 13, 13};
+
+    //decode literals and length/distance pairs
+    while (true)
+        {
+        int symbol = doDecode(lencode);
+        if (symbol == 256)
+            break;
+        if (symbol < 0)
+            {
+            return false;
+            }
+        if (symbol < 256) //literal
+            {
+            dest.push_back(symbol);
+            }
+        else if (symbol > 256)//length
+            {
+            symbol -= 257;
+            if (symbol >= 29)
+                {
+                error("invalid fixed code");
+                return false;
+                }
+            int ret;
+            if (!getBits(lext[symbol], &ret))
+                return false;
+            int len = lens[symbol] + ret;
+
+            symbol = doDecode(distcode);//distance
+            if (symbol < 0)
+                {
+                return false;
+                }
+
+            if (!getBits(dext[symbol], &ret))
+                return false;
+            unsigned int dist = dists[symbol] + ret;
+            if (dist > dest.size())
+                {
+                error("distance too far back %d/%d", dist, dest.size());
+                dump();
+                //printf("pos:%d\n", srcPos);
+                return false;
+                }
+
+            // copy length bytes from distance bytes back
+            //dest.push_back('{');
+            while (len--)
+                {
+                dest.push_back(dest[dest.size() - dist]);
+                }
+            //dest.push_back('}');
+
+            }
+        }
+
+    return true;
+}
+
+/**
+ */
+bool Inflater::doStored()
+{
+    //trace("### stored ###");
+
+    // clear bits from current byte
+    bitBuf = 0;
+    bitCnt = 0;
+
+    // length
+    if (srcPos + 4 > src.size())
+        {
+        error("not enough input");
+        return false;
+        }
+
+    int len = src[srcPos++];
+    len |= src[srcPos++] << 8;
+    //trace("### len:%d", len);
+    // check complement
+    if (src[srcPos++] != (~len & 0xff) ||
+        src[srcPos++] != ((~len >> 8) & 0xff))
+        {
+        error("twos complement for storage size do not match");
+        return false;
+        }
+
+    // copy data
+    if (srcPos + len > src.size())
+        {
+        error("Not enough input for stored block");
+        return false;
+        }
+    while (len--)
+        dest.push_back(src[srcPos++]);
+
+    return true;
+}
+
+/**
+ */
+bool Inflater::doFixed()
+{
+    //trace("### fixed ###");
+
+    static bool firstTime = true;
+    static int lencnt[MAXBITS+1], lensym[FIXLCODES];
+    static int distcnt[MAXBITS+1], distsym[MAXDCODES];
+    static Huffman lencode = {lencnt, lensym};
+    static Huffman distcode = {distcnt, distsym};
+
+    if (firstTime)
+        {
+        firstTime = false;
+
+        int lengths[FIXLCODES];
+
+        // literal/length table
+        int symbol = 0;
+        for ( ; symbol < 144; symbol++)
+            lengths[symbol] = 8;
+        for ( ; symbol < 256; symbol++)
+            lengths[symbol] = 9;
+        for ( ; symbol < 280; symbol++)
+            lengths[symbol] = 7;
+        for ( ; symbol < FIXLCODES; symbol++)
+            lengths[symbol] = 8;
+        buildHuffman(&lencode, lengths, FIXLCODES);
+
+        // distance table
+        for (int symbol = 0; symbol < MAXDCODES; symbol++)
+            lengths[symbol] = 5;
+        buildHuffman(&distcode, lengths, MAXDCODES);
+        }
+
+    // decode data until end-of-block code
+    bool ret = doCodes(&lencode, &distcode);
+    return ret;
+}
+
+/**
+ */
+bool Inflater::doDynamic()
+{
+    //trace("### dynamic ###");
+    int lengths[MAXCODES];                      // descriptor code lengths
+    int lencnt[MAXBITS+1], lensym[MAXLCODES];   // lencode memory
+    int distcnt[MAXBITS+1], distsym[MAXDCODES]; // distcode memory
+    Huffman lencode  = {lencnt, lensym};          // length code
+    Huffman distcode = {distcnt, distsym};        // distance code
+    static const int order[19] =                // permutation of code length codes
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    // get number of lengths in each table, check lengths
+    int ret;
+    if (!getBits(5, &ret))
+        return false;
+    int nlen  = ret + 257;
+    if (!getBits(5, &ret))
+        return false;
+    int ndist = ret + 1;
+    if (!getBits(4, &ret))
+        return false;
+    int ncode = ret + 4;
+    if (nlen > MAXLCODES || ndist > MAXDCODES)
+        {
+        error("Bad codes");
+        return false;
+        }
+
+    // get code length code lengths
+    int index = 0;
+    for ( ; index < ncode; index++)
+        {
+        if (!getBits(3, &ret))
+            return false;
+        lengths[order[index]] = ret;
+        }
+    for ( ; index < 19; index++)
+        lengths[order[index]] = 0;
+
+    // build huffman table for code lengths codes
+    if (buildHuffman(&lencode, lengths, 19) != 0)
+        return false;
+
+    // read length/literal and distance code length tables
+    index = 0;
+    while (index < nlen + ndist)
+        {
+        int symbol = doDecode(&lencode);
+        if (symbol < 16)                // length in 0..15
+            lengths[index++] = symbol;
+        else
+            {                          // repeat instruction
+            int len = 0;               // assume repeating zeros
+            if (symbol == 16)
+                {         // repeat last length 3..6 times
+                if (index == 0)
+                    {
+                    error("no last length");
+                    return false;
+                    }
+                len = lengths[index - 1];// last length
+                if (!getBits(2, &ret))
+                    return false;
+                symbol = 3 + ret;
+                }
+            else if (symbol == 17)      // repeat zero 3..10 times
+                {
+                if (!getBits(3, &ret))
+                    return false;
+                symbol = 3 + ret;
+                }
+            else                        // == 18, repeat zero 11..138 times
+                {
+                if (!getBits(7, &ret))
+                    return false;
+                symbol = 11 + ret;
+                }
+            if (index + symbol > nlen + ndist)
+                {
+                error("too many lengths");
+                return false;
+                }
+            while (symbol--)            // repeat last or zero symbol times
+                lengths[index++] = len;
+            }
+        }
+
+    // build huffman table for literal/length codes
+    int err = buildHuffman(&lencode, lengths, nlen);
+    if (err < 0 || (err > 0 && nlen - lencode.count[0] != 1))
+        {
+        error("incomplete length codes");
+        //return false;
+        }
+    // build huffman table for distance codes
+    err = buildHuffman(&distcode, lengths + nlen, ndist);
+    if (err < 0 || (err > 0 && nlen - lencode.count[0] != 1))
+        {
+        error("incomplete dist codes");
+        return false;
+        }
+
+    // decode data until end-of-block code
+    bool retn = doCodes(&lencode, &distcode);
+    return retn;
+}
+
+/**
+ */
+bool Inflater::inflate(std::vector<unsigned char> &destination,
+                       std::vector<unsigned char> &source)
+{
+    dest.clear();
+    src = source;
+    srcPos = 0;
+    bitBuf = 0;
+    bitCnt = 0;
+
+    while (true)
+        {
+        int last; // one if last block
+        if (!getBits(1, &last))
+            return false;
+        int type; // block type 0..3
+        if (!getBits(2, &type))
+            return false;
+        switch (type)
+            {
+            case 0:
+                if (!doStored())
+                    return false;
+                break;
+            case 1:
+                if (!doFixed())
+                    return false;
+                break;
+            case 2:
+                if (!doDynamic())
+                    return false;
+                break;
+            default:
+                error("Unknown block type %d", type);
+                return false;
+            }
+        if (last)
+            break;
+        }
+
+    destination = dest;
+
+    return true;
+}
+
+
+
+
+
+
+//########################################################################
+//#  D E F L A T E R
+//########################################################################
+
+
+#define DEFLATER_BUF_SIZE 32768
+class Deflater
+{
+public:
+
+    /**
+     *
+     */
+    Deflater();
+
+    /**
+     *
+     */
+    virtual ~Deflater();
+
+    /**
+     *
+     */
+    virtual void reset();
+
+    /**
+     *
+     */
+    virtual bool update(int ch);
+
+    /**
+     *
+     */
+    virtual bool finish();
+
+    /**
+     *
+     */
+    virtual std::vector<unsigned char> &getCompressed();
+
+    /**
+     *
+     */
+    bool deflate(std::vector<unsigned char> &dest,
+                 const std::vector<unsigned char> &src);
+
+    void encodeDistStatic(unsigned int len, unsigned int dist);
+
+private:
+
+    //debug messages
+    void error(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    void trace(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    bool compressWindow();
+
+    bool compress();
+
+    std::vector<unsigned char> compressed;
+
+    std::vector<unsigned char> uncompressed;
+
+    std::vector<unsigned char> window;
+
+    unsigned int windowPos;
+
+    //#### Output
+    unsigned int outputBitBuf;
+    unsigned int outputNrBits;
+
+    void put(int ch);
+
+    void putWord(int ch);
+
+    void putFlush();
+
+    void putBits(unsigned int ch, unsigned int bitsWanted);
+
+    void putBitsR(unsigned int ch, unsigned int bitsWanted);
+
+    //#### Huffman Encode
+    void encodeLiteralStatic(unsigned int ch);
+
+    unsigned char windowBuf[DEFLATER_BUF_SIZE];
+    //assume 32-bit ints
+    unsigned int windowHashBuf[DEFLATER_BUF_SIZE];
+};
+
+
+//########################################################################
+//# A P I
+//########################################################################
+
+
+/**
+ *
+ */
+Deflater::Deflater()
+{
+    reset();
+}
+
+/**
+ *
+ */
+Deflater::~Deflater()
+= default;
+
+/**
+ *
+ */
+void Deflater::reset()
+{
+    compressed.clear();
+    uncompressed.clear();
+    window.clear();
+	windowPos = 0;
+    outputBitBuf = 0;
+    outputNrBits = 0;
+    for (int k=0; k<DEFLATER_BUF_SIZE; k++)
+    {
+        windowBuf[k]=0;
+        windowHashBuf[k]=0;
+    }
+}
+
+/**
+ *
+ */
+bool Deflater::update(int ch)
+{
+    uncompressed.push_back((unsigned char)(ch & 0xff));
+    return true;
+}
+
+/**
+ *
+ */
+bool Deflater::finish()
+{
+    return compress();
+}
+
+/**
+ *
+ */
+std::vector<unsigned char> &Deflater::getCompressed()
+{
+    return compressed;
+}
+
+
+/**
+ *
+ */
+bool Deflater::deflate(std::vector<unsigned char> &dest,
+                       const std::vector<unsigned char> &src)
+{
+    reset();
+    uncompressed = src;
+    if (!compress())
+        return false;
+    dest = compressed;
+    return true;
+}
+
+
+
+
+
+
+
+//########################################################################
+//# W O R K I N G    C O D E
+//########################################################################
+
+
+//#############################
+//#  M E S S A G E S
+//#############################
+
+/**
+ *  Print error messages
+ */
+void Deflater::error(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "Deflater error:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+/**
+ *  Print trace messages
+ */
+void Deflater::trace(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "Deflater:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+
+
+
+//#############################
+//#  O U T P U T
+//#############################
+
+/**
+ *
+ */
+void Deflater::put(int ch)
+{
+    compressed.push_back(ch);
+    outputBitBuf = 0;
+    outputNrBits = 0;
+}
+
+/**
+ *
+ */
+void Deflater::putWord(int ch)
+{
+    int lo = (ch   ) & 0xff;
+    int hi = (ch>>8) & 0xff;
+    put(lo);
+    put(hi);
+}
+
+/**
+ *
+ */
+void Deflater::putFlush()
+{
+    if (outputNrBits > 0)
+        {
+        put(outputBitBuf & 0xff);
+        }
+    outputBitBuf = 0;
+    outputNrBits = 0;
+}
+
+/**
+ *
+ */
+void Deflater::putBits(unsigned int ch, unsigned int bitsWanted)
+{
+    //trace("n:%4u, %d\n", ch, bitsWanted);
+
+    while (bitsWanted--)
+        {
+        //add bits to position 7.  shift right
+        outputBitBuf = (outputBitBuf>>1) + (ch<<7 & 0x80);
+        ch >>= 1;
+        outputNrBits++;
+        if (outputNrBits >= 8)
+            {
+            unsigned char b = outputBitBuf & 0xff;
+            //printf("b:%02x\n", b);
+            put(b);
+            }
+        }
+}
+
+static unsigned int bitReverse(unsigned int code, unsigned int nrBits)
+{
+    unsigned int outb = 0;
+    while (nrBits--)
+        {
+        outb = (outb << 1) | (code & 0x01);
+        code >>= 1;
+        }
+    return outb;
+}
+
+
+/**
+ *
+ */
+void Deflater::putBitsR(unsigned int ch, unsigned int bitsWanted)
+{
+    //trace("r:%4u, %d", ch, bitsWanted);
+
+    unsigned int rcode = bitReverse(ch, bitsWanted);
+
+    putBits(rcode, bitsWanted);
+
+}
+
+
+//#############################
+//#  E N C O D E
+//#############################
+
+
+
+void Deflater::encodeLiteralStatic(unsigned int ch)
+{
+    //trace("c: %d", ch);
+
+    if (ch < 144)
+        {
+        putBitsR(ch + 0x0030 , 8); // 00110000
+        }
+    else if (ch < 256)
+        {
+        putBitsR(ch - 144 + 0x0190 , 9); // 110010000
+        }
+    else if (ch < 280)
+        {
+        putBitsR(ch - 256 + 0x0000 , 7); // 0000000
+        }
+    else if (ch < 288)
+        {
+        putBitsR(ch - 280 + 0x00c0 , 8); // 11000000
+        }
+    else //out of range
+        {
+        error("Literal out of range: %d", ch);
+        }
+
+}
+
+
+struct LenBase
+{
+    unsigned int base;
+    unsigned int range;
+    unsigned int bits;
+};
+
+LenBase lenBases[] =
+{
+    // clang-format off
+    {   3,  1, 0 },
+    {   4,  1, 0 },
+    {   5,  1, 0 },
+    {   6,  1, 0 },
+    {   7,  1, 0 },
+    {   8,  1, 0 },
+    {   9,  1, 0 },
+    {  10,  1, 0 },
+    {  11,  2, 1 },
+    {  13,  2, 1 },
+    {  15,  2, 1 },
+    {  17,  2, 1 },
+    {  19,  4, 2 },
+    {  23,  4, 2 },
+    {  27,  4, 2 },
+    {  31,  4, 2 },
+    {  35,  8, 3 },
+    {  43,  8, 3 },
+    {  51,  8, 3 },
+    {  59,  8, 3 },
+    {  67, 16, 4 },
+    {  83, 16, 4 },
+    {  99, 16, 4 },
+    { 115, 16, 4 },
+    { 131, 32, 5 },
+    { 163, 32, 5 },
+    { 195, 32, 5 },
+    { 227, 32, 5 },
+    { 258,  1, 0 }
+    // clang-format on
+};
+
+struct DistBase
+{
+    unsigned int base;
+    unsigned int range;
+    unsigned int bits;
+};
+
+DistBase distBases[] =
+{
+    // clang-format off
+    {     1,    1,  0 },
+    {     2,    1,  0 },
+    {     3,    1,  0 },
+    {     4,    1,  0 },
+    {     5,    2,  1 },
+    {     7,    2,  1 },
+    {     9,    4,  2 },
+    {    13,    4,  2 },
+    {    17,    8,  3 },
+    {    25,    8,  3 },
+    {    33,   16,  4 },
+    {    49,   16,  4 },
+    {    65,   32,  5 },
+    {    97,   32,  5 },
+    {   129,   64,  6 },
+    {   193,   64,  6 },
+    {   257,  128,  7 },
+    {   385,  128,  7 },
+    {   513,  256,  8 },
+    {   769,  256,  8 },
+    {  1025,  512,  9 },
+    {  1537,  512,  9 },
+    {  2049, 1024, 10 },
+    {  3073, 1024, 10 },
+    {  4097, 2048, 11 },
+    {  6145, 2048, 11 },
+    {  8193, 4096, 12 },
+    { 12289, 4096, 12 },
+    { 16385, 8192, 13 },
+    { 24577, 8192, 13 }
+    // clang-format on
+};
+
+void Deflater::encodeDistStatic(unsigned int len, unsigned int dist)
+{
+
+    //## Output length
+
+    if (len < 3 || len > 258)
+        {
+        error("Length out of range:%d", len);
+        return;
+        }
+
+    bool found = false;
+    for (int i=0 ; i<29 ; i++)
+        {
+        unsigned int base  = lenBases[i].base;
+        unsigned int range = lenBases[i].range;
+        if (base + range > len)
+            {
+            unsigned int lenCode = 257 + i;
+            unsigned int length  = len - base;
+            //trace("--- %d %d %d %d", len, base, range, length);
+            encodeLiteralStatic(lenCode);
+            putBits(length, lenBases[i].bits);
+            found = true;
+            break;
+            }
+        }
+    if (!found)
+        {
+        error("Length not found in table:%d", len);
+        return;
+        }
+
+    //## Output distance
+
+    if (dist < 4 || dist > 32768)
+        {
+        error("Distance out of range:%d", dist);
+        return;
+        }
+
+    found = false;
+    for (int i=0 ; i<30 ; i++)
+        {
+        unsigned int base  = distBases[i].base;
+        unsigned int range = distBases[i].range;
+        if (base + range > dist)
+            {
+            unsigned int distCode = i;
+            unsigned int distance = dist - base;
+            //error("--- %d %d %d %d", dist, base, range, distance);
+            putBitsR(distCode, 5);
+            putBits(distance, distBases[i].bits);
+            found = true;
+            break;
+            }
+        }
+    if (!found)
+        {
+        error("Distance not found in table:%d", dist);
+        return;
+        }
+}
+
+
+//#############################
+//#  C O M P R E S S
+//#############################
+
+
+/**
+ * This method does the dirty work of dictionary
+ * compression.  Basically it looks for redundant
+ * strings and has the current duplicate refer back
+ * to the previous one.
+ */
+bool Deflater::compressWindow()
+{
+    windowPos = 0;
+    unsigned int windowSize = window.size();
+    //### Compress as much of the window as possible
+
+    unsigned int hash = 0;
+    //Have each value be a long with the byte at this position,
+    //plus the 3 bytes after it in the window
+    for (int i=windowSize-1 ; i>=0 ; i--)
+        {
+        unsigned char ch = window[i];
+        windowBuf[i] = ch;
+        hash = ((hash<<8) & 0xffffff00) | ch;
+        windowHashBuf[i] = hash;
+        }
+
+    while (windowPos < windowSize - 3)
+        {
+        //### Find best match, if any
+        unsigned int bestMatchLen  = 0;
+        unsigned int bestMatchDist = 0;
+        if (windowPos >= 4)
+            {
+            for (unsigned int lookBack=0 ; lookBack<windowPos-4 ; lookBack++)
+                {
+                //Check 4-char hashes first, before continuing with string
+                if (windowHashBuf[lookBack] == windowHashBuf[windowPos])
+                    {
+                    unsigned int lookAhead=4;
+                    unsigned int lookAheadMax = windowSize - 4 - windowPos;
+                    if (lookBack + lookAheadMax >= windowPos -4 )
+                        lookAheadMax = windowPos - 4 - lookBack;
+                    if (lookAheadMax > 258)
+                        lookAheadMax = 258;
+                    unsigned char *wp = &(windowBuf[windowPos+4]);
+                    unsigned char *lb = &(windowBuf[lookBack+4]);
+                    while (lookAhead<lookAheadMax)
+                        {
+                        if (*lb++ != *wp++)
+                            break;
+                        lookAhead++;
+                        }
+                    if (lookAhead > bestMatchLen)
+                        {
+                        bestMatchLen  = lookAhead;
+                        bestMatchDist = windowPos - lookBack;
+                        }
+                    }
+                }
+            }
+        if (bestMatchLen > 3)
+            {
+            //Distance encode
+            //trace("### distance");
+            /*
+            printf("### 1 '");
+            for (int i=0 ; i < bestMatchLen ; i++)
+                fputc(window[windowPos+i], stdout);
+            printf("'\n### 2 '");
+            for (int i=0 ; i < bestMatchLen ; i++)
+                fputc(window[windowPos-bestMatchDist+i], stdout);
+            printf("'\n");
+            */
+            encodeDistStatic(bestMatchLen, bestMatchDist);
+            windowPos += bestMatchLen;
+            }
+        else
+            {
+            //Literal encode
+            //trace("### literal");
+            encodeLiteralStatic(windowBuf[windowPos]);
+            windowPos++;
+            }
+        }
+
+    while (windowPos < windowSize)
+        encodeLiteralStatic(windowBuf[windowPos++]);
+
+    encodeLiteralStatic(256);
+    return true;
+}
+
+
+/**
+ *
+ */
+bool Deflater::compress()
+{
+    //trace("compress");
+    unsigned long total = 0L;
+    windowPos = 0;
+    std::vector<unsigned char>::iterator iter;
+    for (iter = uncompressed.begin(); iter != uncompressed.end() ; )
+        {
+        total += windowPos;
+        trace("total:%ld", total);
+        if (windowPos > window.size())
+            windowPos = window.size();
+        window.erase(window.begin() , window.begin()+windowPos);
+        while (window.size() < 32768 && iter != uncompressed.end())
+            {
+            window.push_back(*iter);
+            ++iter;
+            }
+        if (window.size() >= 32768)
+            putBits(0x00, 1); //0  -- more blocks
+        else
+            putBits(0x01, 1); //1  -- last block
+        putBits(0x01, 2); //01 -- static trees
+        if (!compressWindow())
+            return false;
+        }
+    putFlush();
+    return true;
+}
+
+
+
+
+
+//########################################################################
+//#  G Z I P    F I L E
+//########################################################################
+
+/**
+ * Constructor
+ */
+GzipFile::GzipFile() :
+    data(),
+    fileName(),
+    fileBuf(),
+    fileBufPos(0),
+    compressionMethod(0)
+{
+}
+
+/**
+ * Destructor
+ */
+GzipFile::~GzipFile()
+= default;
+
+/**
+ *  Print error messages
+ */
+void GzipFile::error(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "GzipFile error:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+/**
+ *  Print trace messages
+ */
+void GzipFile::trace(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "GzipFile:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+/**
+ *
+ */
+void GzipFile::put(unsigned char ch)
+{
+    data.push_back(ch);
+}
+
+/**
+ *
+ */
+void GzipFile::setData(const std::vector<unsigned char> &str)
+{
+    data = str;
+}
+
+/**
+ *
+ */
+void GzipFile::clearData()
+{
+    data.clear();
+}
+
+/**
+ *
+ */
+std::vector<unsigned char> &GzipFile::getData()
+{
+    return data;
+}
+
+/**
+ *
+ */
+std::string &GzipFile::getFileName()
+{
+    return fileName;
+}
+
+/**
+ *
+ */
+void GzipFile::setFileName(const std::string &val)
+{
+    fileName = val;
+}
+
+
+
+//#####################################
+//# U T I L I T Y
+//#####################################
+
+/**
+ *  Loads a new file into an existing GzipFile
+ */
+bool GzipFile::loadFile(const std::string &fName)
+{
+    FILE *f = fopen(fName.c_str() , "rb");
+    if (!f)
+        {
+        error("Cannot open file %s", fName.c_str());
+        return false;
+        }
+    while (true)
+        {
+        int ch = fgetc(f);
+        if (ch < 0)
+            break;
+        data.push_back(ch);
+        }
+    fclose(f);
+    setFileName(fName);
+    return true;
+}
+
+
+
+//#####################################
+//# W R I T E
+//#####################################
+
+/**
+ *
+ */
+bool GzipFile::putByte(unsigned char ch)
+{
+    fileBuf.push_back(ch);
+    return true;
+}
+
+
+
+/**
+ *
+ */
+bool GzipFile::putLong(unsigned long val)
+{
+    fileBuf.push_back( (unsigned char)((val    ) & 0xff));
+    fileBuf.push_back( (unsigned char)((val>> 8) & 0xff));
+    fileBuf.push_back( (unsigned char)((val>>16) & 0xff));
+    fileBuf.push_back( (unsigned char)((val>>24) & 0xff));
+    return true;
+}
+
+
+
+/**
+ *
+ */
+bool GzipFile::write()
+{
+    fileBuf.clear();
+
+    putByte(0x1f); //magic
+    putByte(0x8b); //magic
+    putByte(   8); //compression method
+    putByte(0x08); //flags.  say we have a crc and file name
+
+    unsigned long ltime = (unsigned long) time(nullptr);
+    putLong(ltime);
+
+    //xfl
+    putByte(0);
+    //OS
+    putByte(0);
+
+    //file name
+    for (char i : fileName)
+        putByte(i);
+    putByte(0);
+
+
+    //compress
+    std::vector<unsigned char> compBuf;
+    Deflater deflater;
+    if (!deflater.deflate(compBuf, data))
+        {
+        return false;
+        }
+
+    std::vector<unsigned char>::iterator iter;
+    for (iter=compBuf.begin() ; iter!=compBuf.end() ; ++iter)
+        {
+        unsigned char ch = *iter;
+        putByte(ch);
+        }
+
+    Crc32 crcEngine;
+    crcEngine.update(data);
+    unsigned long crc = crcEngine.getValue();
+    putLong(crc);
+
+    putLong(data.size());
+
+    return true;
+}
+
+
+/**
+ *
+ */
+bool GzipFile::writeBuffer(std::vector<unsigned char> &outBuf)
+{
+    if (!write())
+        return false;
+    outBuf.clear();
+    outBuf = fileBuf;
+    return true;
+}
+
+
+/**
+ *
+ */
+bool GzipFile::writeFile(const std::string &fileName)
+{
+    if (!write())
+        return false;
+    FILE *f = fopen(fileName.c_str(), "wb");
+    if (!f)
+        return false;
+    std::vector<unsigned char>::iterator iter;
+    for (iter=fileBuf.begin() ; iter!=fileBuf.end() ; ++iter)
+        {
+        unsigned char ch = *iter;
+        fputc(ch, f);
+        }
+    fclose(f);
+    return true;
+}
+
+
+//#####################################
+//# R E A D
+//#####################################
+
+bool GzipFile::getByte(unsigned char *ch)
+{
+    if (fileBufPos >= fileBuf.size())
+        {
+        error("unexpected end of data");
+        return false;
+        }
+    *ch = fileBuf[fileBufPos++];
+    return true;
+}
+
+/**
+ *
+ */
+bool GzipFile::getLong(unsigned long *val)
+{
+    if (fileBuf.size() - fileBufPos < 4)
+        return false;
+    int ch1 = fileBuf[fileBufPos++];
+    int ch2 = fileBuf[fileBufPos++];
+    int ch3 = fileBuf[fileBufPos++];
+    int ch4 = fileBuf[fileBufPos++];
+    *val = ((ch4<<24) & 0xff000000L) |
+           ((ch3<<16) & 0x00ff0000L) |
+           ((ch2<< 8) & 0x0000ff00L) |
+           ((ch1    ) & 0x000000ffL);
+    return true;
+}
+
+bool GzipFile::read()
+{
+    fileBufPos = 0;
+
+    unsigned char ch;
+
+    //magic cookie
+    if (!getByte(&ch))
+        return false;
+    if (ch != 0x1f)
+        {
+        error("bad gzip header");
+        return false;
+        }
+    if (!getByte(&ch))
+        return false;
+    if (ch != 0x8b)
+        {
+        error("bad gzip header");
+        return false;
+        }
+
+    //## compression method
+    if (!getByte(&ch))
+        return false;
+    compressionMethod = ch & 0xff;
+
+    //## flags
+    if (!getByte(&ch))
+        return false;
+    //bool ftext    = ch & 0x01;
+    bool fhcrc    = ch & 0x02;
+    bool fextra   = ch & 0x04;
+    bool fname    = ch & 0x08;
+    bool fcomment = ch & 0x10;
+
+    //trace("cm:%d ftext:%d fhcrc:%d fextra:%d fname:%d fcomment:%d",
+    //         cm, ftext, fhcrc, fextra, fname, fcomment);
+
+    //## file time
+    unsigned long ltime;
+    if (!getLong(&ltime))
+        return false;
+    //time_t mtime = (time_t)ltime;
+
+    //## XFL
+    if (!getByte(&ch))
+        return false;
+    //int xfl = ch;
+
+    //## OS
+    if (!getByte(&ch))
+        return false;
+    //int os = ch;
+
+    //std::string timestr = ctime(&mtime);
+    //trace("xfl:%d os:%d mtime:%s", xfl, os, timestr.c_str());
+
+    if (fextra)
+        {
+        if (!getByte(&ch))
+            return false;
+        long xlen = ch;
+        if (!getByte(&ch))
+            return false;
+        xlen = (xlen << 8) + ch;
+        for (long l=0 ; l<xlen ; l++)
+            {
+            if (!getByte(&ch))
+                return false;
+            }
+        }
+
+    if (fname)
+        {
+        fileName = "";
+	while (true)
+	    {
+            if (!getByte(&ch))
+                return false;
+            if (ch==0)
+                break;
+            fileName.push_back(ch);
+            }
+        }
+
+    if (fcomment)
+        {
+	while (true)
+	    {
+            if (!getByte(&ch))
+                return false;
+            if (ch==0)
+                break;
+            }
+        }
+
+    if (fhcrc)
+        {
+        if (!getByte(&ch))
+            return false;
+        if (!getByte(&ch))
+            return false;
+        }
+
+    //read remainder of stream
+    //compressed data runs up until 8 bytes before end of buffer
+    std::vector<unsigned char> compBuf;
+    while (fileBufPos < fileBuf.size() - 8)
+        {
+        if (!getByte(&ch))
+            return false;
+        compBuf.push_back(ch);
+        }
+    //uncompress
+    data.clear();
+    Inflater inflater;
+    if (!inflater.inflate(data, compBuf))
+        {
+        return false;
+        }
+
+    //Get the CRC and compare
+    Crc32 crcEngine;
+    crcEngine.update(data);
+    unsigned long calcCrc = crcEngine.getValue();
+    unsigned long givenCrc;
+    if (!getLong(&givenCrc))
+        return false;
+    if (givenCrc != calcCrc)
+        {
+        error("Specified crc, %ud, not what received: %ud",
+                givenCrc, calcCrc);
+        return false;
+        }
+
+    //Get the file size and compare
+    unsigned long givenFileSize;
+    if (!getLong(&givenFileSize))
+        return false;
+    if (givenFileSize != data.size())
+        {
+        error("Specified data size, %ld, not what received: %ld",
+                givenFileSize, data.size());
+        return false;
+        }
+
+    return true;
+}
+
+
+
+/**
+ *
+ */
+bool GzipFile::readBuffer(const std::vector<unsigned char> &inbuf)
+{
+    fileBuf = inbuf;
+    if (!read())
+        return false;
+    return true;
+}
+
+
+/**
+ *
+ */
+bool GzipFile::readFile(const std::string &fileName)
+{
+    fileBuf.clear();
+    FILE *f = fopen(fileName.c_str(), "rb");
+    if (!f)
+        return false;
+    while (true)
+        {
+        int ch = fgetc(f);
+        if (ch < 0)
+            break;
+        fileBuf.push_back(ch);
+        }
+    fclose(f);
+    if (!read())
+        return false;
+    return true;
+}
+
+
+
+
+
+
+
+
+//########################################################################
+//#  Z I P    F I L E
+//########################################################################
+
+/**
+ * Constructor
+ */
+ZipEntry::ZipEntry() :
+    crc (0L),
+    fileName (),
+    comment (),
+    compressionMethod (8),
+    compressedData (),
+    uncompressedData (),
+    position (0)
+{
+}
+
+/**
+ *
+ */
+ZipEntry::ZipEntry(std::string fileNameArg,
+                   std::string commentArg) :
+    crc (0L),
+    fileName (std::move(fileNameArg)),
+    comment (std::move(commentArg)),
+    compressionMethod (8),
+    compressedData (),
+    uncompressedData (),
+    position (0)
+{
+}
+
+/**
+ * Destructor
+ */
+ZipEntry::~ZipEntry()
+= default;
+
+
+/**
+ *
+ */
+std::string ZipEntry::getFileName()
+{
+    return fileName;
+}
+
+/**
+ *
+ */
+void ZipEntry::setFileName(const std::string &val)
+{
+    fileName = val;
+}
+
+/**
+ *
+ */
+std::string ZipEntry::getComment()
+{
+    return comment;
+}
+
+/**
+ *
+ */
+void ZipEntry::setComment(const std::string &val)
+{
+    comment = val;
+}
+
+/**
+ *
+ */
+unsigned long ZipEntry::getCompressedSize()
+{
+    return (unsigned long)compressedData.size();
+}
+
+/**
+ *
+ */
+int ZipEntry::getCompressionMethod()
+{
+    return compressionMethod;
+}
+
+/**
+ *
+ */
+void ZipEntry::setCompressionMethod(int val)
+{
+    compressionMethod = val;
+}
+
+/**
+ *
+ */
+std::vector<unsigned char> &ZipEntry::getCompressedData()
+{
+    return compressedData;
+}
+
+/**
+ *
+ */
+void ZipEntry::setCompressedData(const std::vector<unsigned char> &val)
+{
+    compressedData = val;
+}
+
+/**
+ *
+ */
+unsigned long ZipEntry::getUncompressedSize()
+{
+    return (unsigned long)uncompressedData.size();
+}
+
+/**
+ *
+ */
+std::vector<unsigned char> &ZipEntry::getUncompressedData()
+{
+    return uncompressedData;
+}
+
+/**
+ *
+ */
+void ZipEntry::setUncompressedData(const std::vector<unsigned char> &val)
+{
+    uncompressedData = val;
+}
+
+void ZipEntry::setUncompressedData(const std::string &s)
+{
+    uncompressedData.clear();
+    uncompressedData.reserve(s.size());
+    uncompressedData.insert(uncompressedData.begin(), s.begin(), s.end());
+}
+
+/**
+ *
+ */
+unsigned long ZipEntry::getCrc()
+{
+    return crc;
+}
+
+/**
+ *
+ */
+void ZipEntry::setCrc(unsigned long val)
+{
+    crc = val;
+}
+
+/**
+ *
+ */
+void ZipEntry::write(unsigned char ch)
+{
+    uncompressedData.push_back(ch);
+}
+
+/**
+ *
+ */
+void ZipEntry::finish()
+{
+    Crc32 c32;
+    std::vector<unsigned char>::iterator iter;
+    for (iter = uncompressedData.begin() ;
+           iter!= uncompressedData.end() ; ++iter)
+        {
+        unsigned char ch = *iter;
+        c32.update(ch);
+        }
+    crc = c32.getValue();
+    switch (compressionMethod)
+        {
+        case 0: //none
+            {
+            for (iter = uncompressedData.begin() ;
+               iter!= uncompressedData.end() ; ++iter)
+                {
+                unsigned char ch = *iter;
+                compressedData.push_back(ch);
+                }
+            break;
+            }
+        case 8: //deflate
+            {
+            Deflater deflater;
+            if (!deflater.deflate(compressedData, uncompressedData))
+                {
+                //some error
+                }
+            break;
+            }
+        default:
+            {
+            printf("error: unknown compression method %d\n",
+                    compressionMethod);
+            }
+        }
+}
+
+
+
+
+/**
+ *
+ */
+bool ZipEntry::readFile(const std::string &fileNameArg,
+                        const std::string &commentArg)
+{
+    crc = 0L;
+    uncompressedData.clear();
+    fileName = fileNameArg;
+    comment  = commentArg;
+    FILE *f = fopen(fileName.c_str(), "rb");
+    if (!f)
+        {
+        return false;
+        }
+    while (true)
+        {
+        int ch = fgetc(f);
+        if (ch < 0)
+            break;
+        uncompressedData.push_back((unsigned char)ch);
+        }
+    fclose(f);
+    finish();
+    return true;
+}
+
+
+/**
+ *
+ */
+void ZipEntry::setPosition(unsigned long val)
+{
+    position = val;
+}
+
+/**
+ *
+ */
+unsigned long ZipEntry::getPosition()
+{
+    return position;
+}
+
+
+
+
+
+
+
+/**
+ * Constructor
+ */
+ZipFile::ZipFile() :
+    entries(),
+    fileBuf(),
+    fileBufPos(0),
+    comment()
+{
+}
+
+/**
+ * Destructor
+ */
+ZipFile::~ZipFile()
+{
+    std::vector<ZipEntry *>::iterator iter;
+    for (iter=entries.begin() ; iter!=entries.end() ; ++iter)
+        {
+        ZipEntry *entry = *iter;
+        delete entry;
+        }
+    entries.clear();
+}
+
+/**
+ *
+ */
+void ZipFile::setComment(const std::string &val)
+{
+    comment = val;
+}
+
+/**
+ *
+ */
+std::string ZipFile::getComment()
+{
+    return comment;
+}
+
+
+/**
+ *
+ */
+std::vector<ZipEntry *> &ZipFile::getEntries()
+{
+    return entries;
+}
+
+
+
+//#####################################
+//# M E S S A G E S
+//#####################################
+
+void ZipFile::error(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "ZipFile error:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+void ZipFile::trace(char const *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stdout, "ZipFile:");
+    vfprintf(stdout, fmt, args);
+    fprintf(stdout, "\n");
+    va_end(args);
+}
+
+//#####################################
+//# U T I L I T Y
+//#####################################
+
+/**
+ *
+ */
+ZipEntry *ZipFile::addFile(const std::string &fileName,
+                      const std::string &comment)
+{
+    ZipEntry *ze = new ZipEntry();
+    if (!ze->readFile(fileName, comment))
+        {
+        delete ze;
+        return nullptr;
+        }
+    entries.push_back(ze);
+    return ze;
+}
+
+
+/**
+ *
+ */
+ZipEntry *ZipFile::newEntry(const std::string &fileName,
+                            const std::string &comment)
+{
+    ZipEntry *ze = new ZipEntry(fileName, comment);
+    entries.push_back(ze);
+    return ze;
+}
+
+
+//#####################################
+//# W R I T E
+//#####################################
+
+/**
+ *
+ */
+bool ZipFile::putLong(unsigned long val)
+{
+    fileBuf.push_back( ((int)(val    )) & 0xff);
+    fileBuf.push_back( ((int)(val>> 8)) & 0xff);
+    fileBuf.push_back( ((int)(val>>16)) & 0xff);
+    fileBuf.push_back( ((int)(val>>24)) & 0xff);
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::putInt(unsigned int val)
+{
+    fileBuf.push_back( (val    ) & 0xff);
+    fileBuf.push_back( (val>> 8) & 0xff);
+    return true;
+}
+
+/**
+ *
+ */
+bool ZipFile::putByte(unsigned char val)
+{
+    fileBuf.push_back(val);
+    return true;
+}
+
+/**
+ *
+ */
+bool ZipFile::writeFileData()
+{
+    std::vector<ZipEntry *>::iterator iter;
+    for (iter = entries.begin() ; iter != entries.end() ; ++iter)
+        {
+        ZipEntry *entry = *iter;
+        entry->setPosition(fileBuf.size());
+        //##### HEADER
+        std::string fname = entry->getFileName();
+        putLong(0x04034b50L);
+        putInt(20); //versionNeeded
+        putInt(0); //gpBitFlag
+        //putInt(0); //compression method
+        putInt(entry->getCompressionMethod()); //compression method
+        putInt(0); //mod time
+        putInt(0); //mod date
+        putLong(entry->getCrc()); //crc32
+        putLong(entry->getCompressedSize());
+        putLong(entry->getUncompressedSize());
+        putInt(fname.size());//fileName length
+        putInt(8);//extra field length
+        //file name
+        for (char i : fname)
+            putByte((unsigned char)i);
+        //extra field
+        putInt(0x7855);
+        putInt(4);
+        putInt(100);
+        putInt(100);
+
+        //##### DATA
+        std::vector<unsigned char> &buf = entry->getCompressedData();
+        std::vector<unsigned char>::iterator iter;
+        for (iter = buf.begin() ; iter != buf.end() ; ++iter)
+            {
+            unsigned char ch = (unsigned char) *iter;
+            putByte(ch);
+            }
+        }
+    return true;
+}
+
+/**
+ *
+ */
+bool ZipFile::writeCentralDirectory()
+{
+    unsigned long cdPosition = fileBuf.size();
+    std::vector<ZipEntry *>::iterator iter;
+    for (iter = entries.begin() ; iter != entries.end() ; ++iter)
+        {
+        ZipEntry *entry = *iter;
+        std::string fname   = entry->getFileName();
+        std::string ecomment = entry->getComment();
+        putLong(0x02014b50L);  //magic cookie
+        putInt(2386); //versionMadeBy
+        putInt(20); //versionNeeded
+        putInt(0); //gpBitFlag
+        putInt(entry->getCompressionMethod()); //compression method
+        putInt(0); //mod time
+        putInt(0); //mod date
+        putLong(entry->getCrc()); //crc32
+        putLong(entry->getCompressedSize());
+        putLong(entry->getUncompressedSize());
+        putInt(fname.size());//fileName length
+        putInt(4);//extra field length
+        putInt(ecomment.size());//comment length
+        putInt(0); //disk number start
+        putInt(0); //internal attributes
+        putLong(0); //external attributes
+        putLong(entry->getPosition());
+
+        //file name
+        for (char i : fname)
+            putByte((unsigned char)i);
+        //extra field
+        putInt(0x7855);
+        putInt(0);
+        //comment
+        for (char i : ecomment)
+            putByte((unsigned char)i);
+        }
+    unsigned long cdSize = fileBuf.size() - cdPosition;
+
+    putLong(0x06054b50L);
+    putInt(0);//number of this disk
+    putInt(0);//nr of disk with central dir
+    putInt(entries.size()); //number of entries on this disk
+    putInt(entries.size()); //number of entries total
+    putLong(cdSize);  //size of central dir
+    putLong(cdPosition); //position of central dir
+    putInt(comment.size());//comment size
+    for (char i : comment)
+        putByte(i);
+    return true;
+}
+
+
+
+/**
+ *
+ */
+bool ZipFile::write()
+{
+    fileBuf.clear();
+    if (!writeFileData())
+        return false;
+    if (!writeCentralDirectory())
+        return false;
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::writeBuffer(std::vector<unsigned char> &outBuf)
+{
+    if (!write())
+        return false;
+    outBuf.clear();
+    outBuf = fileBuf;
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::writeFile(const std::string &fileName)
+{
+    if (!write())
+        return false;
+    FILE *f = fopen(fileName.c_str(), "wb");
+    if (!f)
+        return false;
+    std::vector<unsigned char>::iterator iter;
+    for (iter=fileBuf.begin() ; iter!=fileBuf.end() ; ++iter)
+        {
+        unsigned char ch = *iter;
+        fputc(ch, f);
+        }
+    fclose(f);
+    return true;
+}
+
+//#####################################
+//# R E A D
+//#####################################
+
+/**
+ *
+ */
+bool ZipFile::getLong(unsigned long *val)
+{
+    if (fileBuf.size() - fileBufPos < 4)
+        return false;
+    int ch1 = fileBuf[fileBufPos++];
+    int ch2 = fileBuf[fileBufPos++];
+    int ch3 = fileBuf[fileBufPos++];
+    int ch4 = fileBuf[fileBufPos++];
+    *val = ((ch4<<24) & 0xff000000L) |
+           ((ch3<<16) & 0x00ff0000L) |
+           ((ch2<< 8) & 0x0000ff00L) |
+           ((ch1    ) & 0x000000ffL);
+    return true;
+}
+
+/**
+ *
+ */
+bool ZipFile::getInt(unsigned int *val)
+{
+    if (fileBuf.size() - fileBufPos < 2)
+        return false;
+    int ch1 = fileBuf[fileBufPos++];
+    int ch2 = fileBuf[fileBufPos++];
+    *val = ((ch2<< 8) & 0xff00) |
+           ((ch1    ) & 0x00ff);
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::getByte(unsigned char *val)
+{
+    if (fileBuf.size() <= fileBufPos)
+        return false;
+    *val = fileBuf[fileBufPos++];
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::readFileData()
+{
+    //printf("#################################################\n");
+    //printf("###D A T A\n");
+    //printf("#################################################\n");
+    while (true)
+        {
+        unsigned long magicCookie;
+        if (!getLong(&magicCookie))
+            {
+            error("magic cookie not found");
+            break;
+            }
+        trace("###Cookie:%lx", magicCookie);
+        if (magicCookie == 0x02014b50L) //central directory
+            break;
+        if (magicCookie != 0x04034b50L)
+            {
+            error("file header not found");
+            return false;
+            }
+        unsigned int versionNeeded;
+        if (!getInt(&versionNeeded))
+            {
+            error("bad version needed found");
+            return false;
+            }
+        unsigned int gpBitFlag;
+        if (!getInt(&gpBitFlag))
+            {
+            error("bad bit flag found");
+            return false;
+            }
+        unsigned int compressionMethod;
+        if (!getInt(&compressionMethod))
+            {
+            error("bad compressionMethod found");
+            return false;
+            }
+        unsigned int modTime;
+        if (!getInt(&modTime))
+            {
+            error("bad modTime found");
+            return false;
+            }
+        unsigned int modDate;
+        if (!getInt(&modDate))
+            {
+            error("bad modDate found");
+            return false;
+            }
+        unsigned long crc32;
+        if (!getLong(&crc32))
+            {
+            error("bad crc32 found");
+            return false;
+            }
+        unsigned long compressedSize;
+        if (!getLong(&compressedSize))
+            {
+            error("bad compressedSize found");
+            return false;
+            }
+        unsigned long uncompressedSize;
+        if (!getLong(&uncompressedSize))
+            {
+            error("bad uncompressedSize found");
+            return false;
+            }
+        unsigned int fileNameLength;
+        if (!getInt(&fileNameLength))
+            {
+            error("bad fileNameLength found");
+            return false;
+            }
+        unsigned int extraFieldLength;
+        if (!getInt(&extraFieldLength))
+            {
+            error("bad extraFieldLength found");
+            return false;
+            }
+        std::string fileName;
+        for (unsigned int i=0 ; i<fileNameLength ; i++)
+            {
+            unsigned char ch;
+            if (!getByte(&ch))
+                break;
+            fileName.push_back(ch);
+            }
+        std::string extraField;
+        for (unsigned int i=0 ; i<extraFieldLength ; i++)
+            {
+            unsigned char ch;
+            if (!getByte(&ch))
+                break;
+            extraField.push_back(ch);
+            }
+        trace("#########################  DATA");
+        trace("FileName           :%d:%s" , fileName.size(), fileName.c_str());
+        trace("Extra field        :%d:%s" , extraField.size(), extraField.c_str());
+        trace("Version needed     :%d" , versionNeeded);
+        trace("Bitflag            :%d" , gpBitFlag);
+        trace("Compression Method :%d" , compressionMethod);
+        trace("Mod time           :%d" , modTime);
+        trace("Mod date           :%d" , modDate);
+        trace("CRC                :%lx", crc32);
+        trace("Compressed size    :%ld", compressedSize);
+        trace("Uncompressed size  :%ld", uncompressedSize);
+
+        //#### Uncompress the data
+        std::vector<unsigned char> compBuf;
+        if (gpBitFlag & 0x8)//bit 3 was set.  means we don't know compressed size
+            {
+            unsigned char c1, c2, c3, c4;
+            c2 = c3 = c4 = 0;
+            while (true)
+                {
+                unsigned char ch;
+                if (!getByte(&ch))
+                    {
+                    error("premature end of data");
+                    break;
+                    }
+                compBuf.push_back(ch);
+                c1 = c2; c2 = c3; c3 = c4; c4 = ch;
+                if (c1 == 0x50 && c2 == 0x4b && c3 == 0x07 && c4 == 0x08)
+                    {
+                    trace("found end of compressed data");
+                    //remove the cookie
+                    compBuf.erase(compBuf.end() -4, compBuf.end());
+                    break;
+                    }
+                }
+            }
+        else
+            {
+            for (unsigned long bnr = 0 ; bnr < compressedSize ; bnr++)
+                {
+                unsigned char ch;
+                if (!getByte(&ch))
+                    {
+                    error("premature end of data");
+                    break;
+                    }
+                compBuf.push_back(ch);
+                }
+            }
+
+        printf("### data: ");
+        for (int i=0 ; i<10 ; i++)
+            printf("%02x ", compBuf[i] & 0xff);
+        printf("\n");
+
+        if (gpBitFlag & 0x8)//only if bit 3 set
+            {
+            /* this cookie was read in the loop above
+            unsigned long dataDescriptorSignature ;
+            if (!getLong(&dataDescriptorSignature))
+                break;
+            if (dataDescriptorSignature != 0x08074b50L)
+                {
+                error("bad dataDescriptorSignature found");
+                return false;
+                }
+            */
+            unsigned long crc32;
+            if (!getLong(&crc32))
+                {
+                error("bad crc32 found");
+                return false;
+                }
+            unsigned long compressedSize;
+            if (!getLong(&compressedSize))
+                {
+                error("bad compressedSize found");
+                return false;
+                }
+            unsigned long uncompressedSize;
+            if (!getLong(&uncompressedSize))
+                {
+                error("bad uncompressedSize found");
+                return false;
+                }
+            }//bit 3 was set
+        //break;
+
+        std::vector<unsigned char> uncompBuf;
+        switch (compressionMethod)
+            {
+            case 8: //deflate
+                {
+                Inflater inflater;
+                if (!inflater.inflate(uncompBuf, compBuf))
+                    {
+                    return false;
+                    }
+                break;
+                }
+            default:
+                {
+                error("Unimplemented compression method %d", compressionMethod);
+                return false;
+                }
+            }
+
+        if (uncompressedSize != uncompBuf.size())
+            {
+            error("Size mismatch.  Expected %ld, received %ld",
+                uncompressedSize, uncompBuf.size());
+            return false;
+            }
+
+        Crc32 crcEngine;
+        crcEngine.update(uncompBuf);
+        unsigned long crc = crcEngine.getValue();
+        if (crc != crc32)
+            {
+            error("Crc mismatch.  Calculated %08ux, received %08ux", crc, crc32);
+            return false;
+            }
+
+        ZipEntry *ze = new ZipEntry(fileName, comment);
+        ze->setCompressionMethod(compressionMethod);
+        ze->setCompressedData(compBuf);
+        ze->setUncompressedData(uncompBuf);
+        ze->setCrc(crc);
+        entries.push_back(ze);
+
+
+        }
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::readCentralDirectory()
+{
+    //printf("#################################################\n");
+    //printf("###D I R E C T O R Y\n");
+    //printf("#################################################\n");
+    while (true)
+        {
+        //We start with a central directory cookie already
+        //Check at the bottom of the loop.
+        unsigned int version;
+        if (!getInt(&version))
+            {
+            error("bad version found");
+            return false;
+            }
+        unsigned int versionNeeded;
+        if (!getInt(&versionNeeded))
+            {
+            error("bad version found");
+            return false;
+            }
+        unsigned int gpBitFlag;
+        if (!getInt(&gpBitFlag))
+            {
+            error("bad bit flag found");
+            return false;
+            }
+        unsigned int compressionMethod;
+        if (!getInt(&compressionMethod))
+            {
+            error("bad compressionMethod found");
+            return false;
+            }
+        unsigned int modTime;
+        if (!getInt(&modTime))
+            {
+            error("bad modTime found");
+            return false;
+            }
+        unsigned int modDate;
+        if (!getInt(&modDate))
+            {
+            error("bad modDate found");
+            return false;
+            }
+        unsigned long crc32;
+        if (!getLong(&crc32))
+            {
+            error("bad crc32 found");
+            return false;
+            }
+        unsigned long compressedSize;
+        if (!getLong(&compressedSize))
+            {
+            error("bad compressedSize found");
+            return false;
+            }
+        unsigned long uncompressedSize;
+        if (!getLong(&uncompressedSize))
+            {
+            error("bad uncompressedSize found");
+            return false;
+            }
+        unsigned int fileNameLength;
+        if (!getInt(&fileNameLength))
+            {
+            error("bad fileNameLength found");
+            return false;
+            }
+        unsigned int extraFieldLength;
+        if (!getInt(&extraFieldLength))
+            {
+            error("bad extraFieldLength found");
+            return false;
+            }
+        unsigned int fileCommentLength;
+        if (!getInt(&fileCommentLength))
+            {
+            error("bad fileCommentLength found");
+            return false;
+            }
+        unsigned int diskNumberStart;
+        if (!getInt(&diskNumberStart))
+            {
+            error("bad diskNumberStart found");
+            return false;
+            }
+        unsigned int internalFileAttributes;
+        if (!getInt(&internalFileAttributes))
+            {
+            error("bad internalFileAttributes found");
+            return false;
+            }
+        unsigned long externalFileAttributes;
+        if (!getLong(&externalFileAttributes))
+            {
+            error("bad externalFileAttributes found");
+            return false;
+            }
+        unsigned long localHeaderOffset;
+        if (!getLong(&localHeaderOffset))
+            {
+            error("bad localHeaderOffset found");
+            return false;
+            }
+        std::string fileName;
+        for (unsigned int i=0 ; i<fileNameLength ; i++)
+            {
+            unsigned char ch;
+            if (!getByte(&ch))
+                break;
+            fileName.push_back(ch);
+            }
+        std::string extraField;
+        for (unsigned int i=0 ; i<extraFieldLength ; i++)
+            {
+            unsigned char ch;
+            if (!getByte(&ch))
+                break;
+            extraField.push_back(ch);
+            }
+        std::string fileComment;
+        for (unsigned int i=0 ; i<fileCommentLength ; i++)
+            {
+            unsigned char ch;
+            if (!getByte(&ch))
+                break;
+            fileComment.push_back(ch);
+            }
+        trace("######################### ENTRY");
+        trace("FileName           :%s" , fileName.c_str());
+        trace("Extra field        :%s" , extraField.c_str());
+        trace("File comment       :%s" , fileComment.c_str());
+        trace("Version            :%d" , version);
+        trace("Version needed     :%d" , versionNeeded);
+        trace("Bitflag            :%d" , gpBitFlag);
+        trace("Compression Method :%d" , compressionMethod);
+        trace("Mod time           :%d" , modTime);
+        trace("Mod date           :%d" , modDate);
+        trace("CRC                :%lx", crc32);
+        trace("Compressed size    :%ld", compressedSize);
+        trace("Uncompressed size  :%ld", uncompressedSize);
+        trace("Disk nr start      :%ld", diskNumberStart);
+        trace("Header offset      :%ld", localHeaderOffset);
+
+
+        unsigned long magicCookie;
+        if (!getLong(&magicCookie))
+            {
+            error("magic cookie not found");
+            return false;
+            }
+        trace("###Cookie:%lx", magicCookie);
+        if (magicCookie  == 0x06054b50L) //end of central directory
+            break;
+        else if (magicCookie == 0x05054b50L) //signature
+            {
+            //## Digital Signature
+            unsigned int signatureSize;
+            if (!getInt(&signatureSize))
+                {
+                error("bad signatureSize found");
+                return false;
+                }
+            std::string digitalSignature;
+            for (unsigned int i=0 ; i<signatureSize ; i++)
+                {
+                unsigned char ch;
+                if (!getByte(&ch))
+                    break;
+                digitalSignature.push_back(ch);
+                }
+            trace("######## SIGNATURE :'%s'" , digitalSignature.c_str());
+            }
+        else if (magicCookie != 0x02014b50L) //central directory
+            {
+            error("directory file header not found");
+            return false;
+            }
+        }
+
+    unsigned int diskNr;
+    if (!getInt(&diskNr))
+        {
+        error("bad diskNr found");
+        return false;
+        }
+    unsigned int diskWithCd;
+    if (!getInt(&diskWithCd))
+        {
+        error("bad diskWithCd found");
+        return false;
+        }
+    unsigned int nrEntriesDisk;
+    if (!getInt(&nrEntriesDisk))
+        {
+        error("bad nrEntriesDisk found");
+        return false;
+        }
+    unsigned int nrEntriesTotal;
+    if (!getInt(&nrEntriesTotal))
+        {
+        error("bad nrEntriesTotal found");
+        return false;
+        }
+    unsigned long cdSize;
+    if (!getLong(&cdSize))
+        {
+        error("bad cdSize found");
+        return false;
+        }
+    unsigned long cdPos;
+    if (!getLong(&cdPos))
+        {
+        error("bad cdPos found");
+        return false;
+        }
+    unsigned int commentSize;
+    if (!getInt(&commentSize))
+        {
+        error("bad commentSize found");
+        return false;
+        }
+    comment = "";
+    for (unsigned int i=0 ; i<commentSize ; i++)
+        {
+        unsigned char ch;
+        if (!getByte(&ch))
+            break;
+        comment.push_back(ch);
+        }
+    trace("######## Zip Comment :'%s'" , comment.c_str());
+
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::read()
+{
+    fileBufPos = 0;
+    if (!readFileData())
+        {
+        return false;
+        }
+    if (!readCentralDirectory())
+        {
+        return false;
+        }
+    return true;
+}
+
+/**
+ *
+ */
+bool ZipFile::readBuffer(const std::vector<unsigned char> &inbuf)
+{
+    fileBuf = inbuf;
+    if (!read())
+        return false;
+    return true;
+}
+
+
+/**
+ *
+ */
+bool ZipFile::readFile(const std::string &fileName)
+{
+    fileBuf.clear();
+    FILE *f = fopen(fileName.c_str(), "rb");
+    if (!f)
+        return false;
+    while (true)
+        {
+        int ch = fgetc(f);
+        if (ch < 0)
+            break;
+        fileBuf.push_back(ch);
+        }
+    fclose(f);
+    if (!read())
+        return false;
+    return true;
+}
+
+
+
+
+
+
+
+
+
+//########################################################################
+//#  E N D    O F    F I L E
+//########################################################################
+
+
diff --git a/src/util/ziptool.h b/src/util/ziptool.h
new file mode 100644
index 0000000..26aaac8
--- /dev/null
+++ b/src/util/ziptool.h
@@ -0,0 +1,575 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors:
+ * see git history
+ * Bob Jamison
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU LGPL v2.1+, read the file 'COPYING' for more information.
+ */
+/*
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef SEEN_ZIPTOOL_H
+#define SEEN_ZIPTOOL_H
+/**
+ * This is intended to be a standalone, reduced capability
+ * implementation of Gzip and Zip functionality.  Its
+ * targeted use case is for archiving and retrieving single files
+ * which use these encoding types.  Being memory based and
+ * non-optimized, it is not useful in cases where very large
+ * archives are needed or where high performance is desired.
+ * However, it should hopefully work well for smaller,
+ * one-at-a-time tasks.  What you get in return is the ability
+ * to drop these files into your project and remove the dependencies
+ * on ZLib and Info-Zip.  Enjoy.
+ */
+
+
+
+#include <vector>
+#include <string>
+
+
+//########################################################################
+//#  A D L E R  3 2
+//########################################################################
+
+class Adler32
+{
+public:
+
+    Adler32();
+
+    virtual ~Adler32();
+
+    void reset();
+
+    void update(unsigned char b);
+
+    void update(char *str);
+
+    unsigned long getValue();
+
+private:
+
+    unsigned long value;
+
+};
+
+
+//########################################################################
+//#  C R C  3 2
+//########################################################################
+
+class Crc32
+{
+public:
+
+    Crc32();
+
+    virtual ~Crc32();
+
+    void reset();
+
+    void update(unsigned char b);
+
+    void update(char *str);
+
+    void update(const std::vector<unsigned char> &buf);
+
+    unsigned long getValue();
+
+private:
+
+    unsigned long value;
+
+};
+
+
+
+
+
+
+//########################################################################
+//#  G Z I P    S T R E A M S
+//########################################################################
+
+class GzipFile
+{
+public:
+
+    /**
+     *
+     */
+    GzipFile();
+
+    /**
+     *
+     */
+    virtual ~GzipFile();
+
+    /**
+     *
+     */
+    virtual void put(unsigned char ch);
+
+    /**
+     *
+     */
+    virtual void setData(const std::vector<unsigned char> &str);
+
+    /**
+     *
+     */
+    virtual void clearData();
+
+    /**
+     *
+     */
+    virtual std::vector<unsigned char> &getData();
+
+    /**
+     *
+     */
+    virtual std::string &getFileName();
+
+    /**
+     *
+     */
+    virtual void setFileName(const std::string &val);
+
+
+    //######################
+    //# U T I L I T Y
+    //######################
+
+    /**
+     *
+     */
+    virtual bool readFile(const std::string &fName);
+
+    //######################
+    //# W R I T E
+    //######################
+
+    /**
+     *
+     */
+    virtual bool write();
+
+    /**
+     *
+     */
+    virtual bool writeBuffer(std::vector<unsigned char> &outbuf);
+
+    /**
+     *
+     */
+    virtual bool writeFile(const std::string &fileName);
+
+
+    //######################
+    //# R E A D
+    //######################
+
+
+    /**
+     *
+     */
+    virtual bool read();
+
+    /**
+     *
+     */
+    virtual bool readBuffer(const std::vector<unsigned char> &inbuf);
+
+    /**
+     *
+     */
+    virtual bool loadFile(const std::string &fileName);
+
+
+
+private:
+
+    std::vector<unsigned char> data;
+    std::string fileName;
+
+    //debug messages
+    void error(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    void trace(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    std::vector<unsigned char> fileBuf;
+    unsigned long fileBufPos;
+
+    bool getByte(unsigned char *ch);
+    bool getLong(unsigned long *val);
+
+    bool putByte(unsigned char ch);
+    bool putLong(unsigned long val);
+
+    int compressionMethod;
+};
+
+
+
+
+//########################################################################
+//#  Z I P    F I L E
+//########################################################################
+
+
+/**
+ *
+ */
+class ZipEntry
+{
+public:
+
+    /**
+     *
+     */
+    ZipEntry();
+
+    /**
+     *
+     */
+    ZipEntry(std::string fileName,
+             std::string comment);
+
+    /**
+     *
+     */
+    virtual ~ZipEntry();
+
+    /**
+     *
+     */
+    virtual std::string getFileName();
+
+    /**
+     *
+     */
+    virtual void setFileName(const std::string &val);
+
+    /**
+     *
+     */
+    virtual std::string getComment();
+
+    /**
+     *
+     */
+    virtual void setComment(const std::string &val);
+
+    /**
+     *
+     */
+    virtual unsigned long getCompressedSize();
+
+    /**
+     *
+     */
+    virtual int getCompressionMethod();
+
+    /**
+     *
+     */
+    virtual void setCompressionMethod(int val);
+
+    /**
+     *
+     */
+    virtual std::vector<unsigned char> &getCompressedData();
+
+    /**
+     *
+     */
+    virtual void setCompressedData(const std::vector<unsigned char> &val);
+
+    /**
+     *
+     */
+    virtual unsigned long getUncompressedSize();
+
+    /**
+     *
+     */
+    virtual std::vector<unsigned char> &getUncompressedData();
+
+    /**
+     *
+     */
+    virtual void setUncompressedData(const std::vector<unsigned char> &val);
+    virtual void setUncompressedData(const std::string &val);
+
+    /**
+     *
+     */
+    virtual void write(unsigned char ch);
+
+    /**
+     *
+     */
+    virtual void finish();
+
+    /**
+     *
+     */
+    virtual unsigned long getCrc();
+
+    /**
+     *
+     */
+    virtual void setCrc(unsigned long crc);
+
+    /**
+     *
+     */
+    virtual bool readFile(const std::string &fileNameArg,
+                          const std::string &commentArg);
+
+    /**
+     *
+     */
+    virtual void setPosition(unsigned long val);
+
+    /**
+     *
+     */
+    virtual unsigned long getPosition();
+
+private:
+
+    unsigned long crc;
+
+    std::string fileName;
+    std::string comment;
+
+    int compressionMethod;
+
+    std::vector<unsigned char> compressedData;
+    std::vector<unsigned char> uncompressedData;
+
+    unsigned long position;
+};
+
+
+
+
+
+
+
+
+
+/**
+ * This class sits over the zlib and gzip code to
+ * implement a PKWare or Info-Zip .zip file reader and
+ * writer
+ */
+class ZipFile
+{
+public:
+
+    /**
+     *
+     */
+    ZipFile();
+
+    /**
+     *
+     */
+    virtual ~ZipFile();
+
+    //######################
+    //# V A R I A B L E S
+    //######################
+
+    /**
+     *
+     */
+    virtual void setComment(const std::string &val);
+
+    /**
+     *
+     */
+    virtual std::string getComment();
+
+    /**
+     * Return the list of entries currently in this file
+     */
+    std::vector<ZipEntry *> &getEntries();
+
+
+    //######################
+    //# U T I L I T Y
+    //######################
+
+    /**
+     *
+     */
+    virtual ZipEntry *addFile(const std::string &fileNameArg,
+                              const std::string &commentArg);
+
+    /**
+     *
+     */
+    virtual ZipEntry *newEntry(const std::string &fileNameArg,
+                               const std::string &commentArg);
+
+    //######################
+    //# W R I T E
+    //######################
+
+    /**
+     *
+     */
+    virtual bool write();
+
+    /**
+     *
+     */
+    virtual bool writeBuffer(std::vector<unsigned char> &outbuf);
+
+    /**
+     *
+     */
+    virtual bool writeFile(const std::string &fileName);
+
+
+    //######################
+    //# R E A D
+    //######################
+
+
+    /**
+     *
+     */
+    virtual bool read();
+
+    /**
+     *
+     */
+    virtual bool readBuffer(const std::vector<unsigned char> &inbuf);
+
+    /**
+     *
+     */
+    virtual bool readFile(const std::string &fileName);
+
+
+private:
+
+    //debug messages
+    void error(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+    void trace(char const *fmt, ...)
+    #ifdef G_GNUC_PRINTF
+    G_GNUC_PRINTF(2, 3)
+    #endif
+    ;
+
+    //# Private writing methods
+
+    /**
+     *
+     */
+    bool putLong(unsigned long val);
+
+    /**
+     *
+     */
+    bool putInt(unsigned int val);
+
+
+    /**
+     *
+     */
+    bool putByte(unsigned char val);
+
+    /**
+     *
+     */
+    bool writeFileData();
+
+    /**
+     *
+     */
+    bool writeCentralDirectory();
+
+
+    //# Private reading methods
+
+    /**
+     *
+     */
+    bool getLong(unsigned long *val);
+
+    /**
+     *
+     */
+    bool getInt(unsigned int *val);
+
+    /**
+     *
+     */
+    bool getByte(unsigned char *val);
+
+    /**
+     *
+     */
+    bool readFileData();
+
+    /**
+     *
+     */
+    bool readCentralDirectory();
+
+
+    std::vector<ZipEntry *> entries;
+
+    std::vector<unsigned char> fileBuf;
+    unsigned long fileBufPos;
+
+    std::string comment;
+};
+
+
+
+
+
+
+#endif // SEEN_ZIPTOOL_H
+
+
+//########################################################################
+//#  E N D    O F    F I L E
+//########################################################################
+