Merge from trunk.

(bzr r12380.1.17)

2 files changed, 194 insertions, 123 deletions

diff --git a/src/util/units.cpp b/src/util/units.cpp
index e120207c9..f6350d569 100644
--- a/src/util/units.cpp
+++ b/src/util/units.cpp
@@ -22,6 +22,39 @@
 #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
+{
+
+/**
+ * A std::map that gives the data type value for the string version.
+ *
+ * Note that we'd normally not return a reference to an internal version, but
+ * for this constant case it allows us to check against getTypeMappings().end().
+ */
+/** @todo consider hiding map behind hasFoo() and getFoo() type functions.*/
+std::map<Glib::ustring, Inkscape::Util::UnitType> &getTypeMappings()
+{
+    static bool init = false;
+    static std::map<Glib::ustring, Inkscape::Util::UnitType> typeMap;
+    if (!init)
+    {
+        init = true;
+        typeMap["DIMENSIONLESS"] = UNIT_TYPE_DIMENSIONLESS;
+        typeMap["LINEAR"] = UNIT_TYPE_LINEAR;
+        typeMap["RADIAL"] = UNIT_TYPE_RADIAL;
+        typeMap["FONT_HEIGHT"] = UNIT_TYPE_FONT_HEIGHT;
+        // Note that code was not yet handling LINEAR_SCALED, TIME, QTY and NONE
+    }
+    return typeMap;
+}
+
+} // namespace
+
 namespace Inkscape {
 namespace Util {
 
@@ -51,19 +84,44 @@ UnitsSAXHandler::UnitsSAXHandler(UnitTable *table) :
 
 #define BUFSIZE (255)
 
-/**
- * Returns the suggested precision to use for displaying numbers
- * of this unit.
- */
+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 const &name,
+           Glib::ustring const &name_plural,
+           Glib::ustring const &abbr,
+           Glib::ustring const &description) :
+    type(type),
+    factor(factor),
+    name(name),
+    name_plural(name_plural),
+    abbr(abbr),
+    description(description)
+{
+}
+
+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");
-        return 0;
-    } else {
-        return factor_digits;
+        factor_digits = 0;
     }
+    return factor_digits;
 }
 
 /** Checks if a unit is compatible with the specified unit. */
@@ -143,159 +201,132 @@ int Unit::metric() const {
  *
  * The primary unit's conversion factor is required to be 1.00
  */
-UnitTable::UnitTable() 
+UnitTable::UnitTable()
 {
     // if we swich to the xml file, don't forget to force locale to 'C'
-    //    load("share/ui/units.xml");  // <-- Buggy 
+    //    load("share/ui/units.xml");  // <-- Buggy
     gchar *filename = g_build_filename(INKSCAPE_UIDIR, "units.txt", NULL);
     loadText(filename);
     g_free(filename);
 }
 
 UnitTable::~UnitTable() {
-    UnitMap::iterator iter = _unit_map.begin();
-    while (iter != _unit_map.end()) {
-	delete (*iter).second;
-	++iter;
+    for (UnitMap::iterator iter = _unit_map.begin(); iter != _unit_map.end(); ++iter)
+    {
+        delete (*iter).second;
     }
 }
 
-/** Add a new unit to the table */
 void UnitTable::addUnit(Unit const &u, bool primary) {
     _unit_map[u.abbr] = new Unit(u);
     if (primary) {
-	_primary_unit[u.type] = u.abbr;
+        _primary_unit[u.type] = u.abbr;
     }
 }
 
-/** Retrieve a given unit based on its string identifier */
 Unit UnitTable::getUnit(Glib::ustring const &unit_abbr) const {
     UnitMap::const_iterator iter = _unit_map.find(unit_abbr);
     if (iter != _unit_map.end()) {
-	return *((*iter).second);
+        return *((*iter).second);
     } else {
-	return Unit();
+        return Unit();
     }
 }
 
-/** Remove a unit definition from the given unit type table */
 bool UnitTable::deleteUnit(Unit const &u) {
-    if (u.abbr == _primary_unit[u.type]) {
-	// Cannot delete the primary unit type since it's
-	// used for conversions
-	return false;
-    }
-    UnitMap::iterator iter = _unit_map.find(u.abbr);
-    if (iter != _unit_map.end()) {
-	delete (*iter).second;
-	_unit_map.erase(iter);
-	return true;
-    } else {
-	return false;
+    bool deleted = false;
+    // Cannot delete the primary unit type since it's
+    // used for conversions
+    if (u.abbr != _primary_unit[u.type]) {
+        UnitMap::iterator iter = _unit_map.find(u.abbr);
+        if (iter != _unit_map.end()) {
+            delete (*iter).second;
+            _unit_map.erase(iter);
+            deleted = true;
+        }
     }
+    return deleted;
 }
 
-/** Returns true if the given string 'name' is a valid unit in the table */
 bool UnitTable::hasUnit(Glib::ustring const &unit) const
 {
     UnitMap::const_iterator iter = _unit_map.find(unit);
     return (iter != _unit_map.end());
 }
 
-/** Provides an iteratable list of items in the given unit table */
 UnitTable::UnitMap UnitTable::units(UnitType type) const
 {
     UnitMap submap;
-    for (UnitMap::const_iterator iter = _unit_map.begin();
-         iter != _unit_map.end(); ++iter) {
-	if (((*iter).second)->type == type) {
-	    submap.insert(UnitMap::value_type((*iter).first, new Unit(*((*iter).second))));
-	}
+    for (UnitMap::const_iterator iter = _unit_map.begin(); iter != _unit_map.end(); ++iter) {
+        if (((*iter).second)->type == type) {
+            submap.insert(UnitMap::value_type((*iter).first, new Unit(*((*iter).second))));
+        }
     }
 
     return submap;
 }
 
-/** Returns the default unit abbr for the given type */
 Glib::ustring UnitTable::primary(UnitType type) const
 {
     return _primary_unit[type];
 }
 
-/** Loads units from a text file.
-    
-    loadText loads and merges the contents of the given file into the UnitTable,
-    possibly overwriting existing unit definitions.
-    
-    @param filename: file to be loaded*/
 bool UnitTable::loadText(Glib::ustring const &filename)
 {
-    char buf[BUFSIZE];
+    char buf[BUFSIZE] = {0};
 
     // Open file for reading
     FILE * f = fopen(filename.c_str(), "r");
     if (f == NULL) {
-	    g_warning("Could not open units file '%s': %s\n", 
-		filename.c_str(), strerror(errno));
+        g_warning("Could not open units file '%s': %s\n",
+                  filename.c_str(), strerror(errno));
         g_warning("* INKSCAPE_DATADIR is:  '%s'\n", INKSCAPE_DATADIR);
         g_warning("* INKSCAPE_UIDIR is:  '%s'\n", INKSCAPE_UIDIR);
-	    return false;
+        return false;
     }
 
+    /** @todo fix this to use C++ means and explicit locale to avoid need to change. */
     // bypass current locale in order to make
     // sscanf read floats with '.' as a separator
     // set locale to 'C' and keep old locale
-    char *old_locale;
-    old_locale = g_strdup (setlocale (LC_NUMERIC, NULL));
+    char *old_locale = g_strdup(setlocale(LC_NUMERIC, NULL));
     setlocale (LC_NUMERIC, "C");
 
     while (fgets(buf, BUFSIZE, f) != NULL) {
-	char name[BUFSIZE];
-	char plural[BUFSIZE];
-	char abbr[BUFSIZE];
-	char type[BUFSIZE];
-	double factor;
-	char primary[BUFSIZE];
-
-	int nchars = 0;
-    // locale is set to C, scanning %lf should work _everywhere_
-	if (sscanf(buf, "%15s %15s %15s %15s %8lf %1s %15n", 
-		   name, plural, abbr, type, &factor, primary, &nchars) != 6)
-    {
-	    // Skip the line - doesn't appear to be valid
-	    continue;
-	}
-
-	g_assert(nchars < BUFSIZE);
-
-	char *desc = buf;
-	desc += nchars;  // buf is now only the description
-
-	// insert into _unit_map
-	Unit u;
-	u.name = name;
-	u.name_plural = plural;
-	u.abbr = abbr;
-	u.description = desc;
-	u.factor = factor;
-
-	if (streq(type, "DIMENSIONLESS")) {
-	    u.type = UNIT_TYPE_DIMENSIONLESS;
-	} else if (streq(type, "LINEAR")) {
-	    u.type = UNIT_TYPE_LINEAR;
-	} else if (streq(type, "RADIAL")) {
-	    u.type = UNIT_TYPE_RADIAL;
-	} else if (streq(type, "FONT_HEIGHT")) {
-	    u.type = UNIT_TYPE_FONT_HEIGHT;
-	} else {
-	    g_warning("Skipping unknown unit type '%s' for %s.\n", 
-		    type, name);
-	    continue;
-	}
-
-	// if primary is 'Y', list this unit as a primary
-	addUnit(u, (primary[0]=='Y' || primary[0]=='y'));
+        char name[BUFSIZE] = {0};
+        char plural[BUFSIZE] = {0};
+        char abbr[BUFSIZE] = {0};
+        char type[BUFSIZE] = {0};
+        double factor = 0.0;
+        char primary[BUFSIZE] = {0};
+
+        int nchars = 0;
+        // locale is set to C, scanning %lf should work _everywhere_
+        /** @todo address %15n, which causes a warning: */
+        if (sscanf(buf, "%15s %15s %15s %15s %8lf %1s %15n",
+                   name, plural, abbr, type, &factor, primary, &nchars) != 6)
+        {
+            // Skip the line - doesn't appear to be valid
+            continue;
+        }
+
+        g_assert(nchars < BUFSIZE);
+
+        char *desc = buf;
+        desc += nchars;  // buf is now only the description
+
+        // insert into _unit_map
+        if (getTypeMappings().find(type) == getTypeMappings().end())
+        {
+            g_warning("Skipping unknown unit type '%s' for %s.\n", type, name);
+            continue;
+        }
+        UnitType utype = getTypeMappings()[type];
+
+        Unit u(utype, factor, name, plural, abbr, desc);
 
+        // if primary is 'Y', list this unit as a primary
+        addUnit(u, (primary[0]=='Y' || primary[0]=='y'));
     }
 
     // set back the saved locale
@@ -304,9 +335,8 @@ bool UnitTable::loadText(Glib::ustring const &filename)
 
     // close file
     if (fclose(f) != 0) {
-	g_warning("Error closing units file '%s':  %s\n",
-		filename.c_str(), strerror(errno));
-	return false;
+        g_warning("Error closing units file '%s':  %s\n", filename.c_str(), strerror(errno));
+        return false;
     }
 
     return true;
@@ -318,23 +348,20 @@ bool UnitTable::load(Glib::ustring const &filename) {
     int result = handler.parseFile( filename.c_str() );
     if ( result != 0 ) {
         // perhaps
-	g_warning("Problem loading units file '%s':  %d\n", 
-		  filename.c_str(), result);
-	return false;
+        g_warning("Problem loading units file '%s':  %d\n", filename.c_str(), result);
+        return false;
     }
 
     return true;
 }
 
-/** Saves the current UnitTable to the given file. */
 bool UnitTable::save(Glib::ustring const &filename) {
 
     // open file for writing
     FILE *f = fopen(filename.c_str(), "w");
     if (f == NULL) {
-	g_warning("Could not open units file '%s': %s\n", 
-		  filename.c_str(), strerror(errno));
-	return false;
+        g_warning("Could not open units file '%s': %s\n", filename.c_str(), strerror(errno));
+        return false;
     }
 
     // write out header
@@ -351,9 +378,8 @@ bool UnitTable::save(Glib::ustring const &filename) {
 
     // close file
     if (fclose(f) != 0) {
-	g_warning("Error closing units file '%s':  %s\n",
-		  filename.c_str(), strerror(errno));
-	return false;
+        g_warning("Error closing units file '%s':  %s\n", filename.c_str(), strerror(errno));
+        return false;
     }
 
     return true;
@@ -364,12 +390,7 @@ void UnitsSAXHandler::_startElement(xmlChar const *name, xmlChar const **attrs)
 {
     if (streq("unit", (char const *)name)) {
         // reset for next use
-        unit.name.clear();
-        unit.name_plural.clear();
-        unit.abbr.clear();
-        unit.description.clear();
-        unit.type = UNIT_TYPE_DIMENSIONLESS;
-        unit.factor = 1.0;
+        unit.clear();
         primary = false;
         skip = false;
 
@@ -377,14 +398,9 @@ void UnitsSAXHandler::_startElement(xmlChar const *name, xmlChar const **attrs)
             char const *const key = (char const *)attrs[i];
             if (streq("type", key)) {
                 char const *type = (char const*)attrs[i+1];
-                if (streq(type, "DIMENSIONLESS")) {
-                    unit.type = UNIT_TYPE_DIMENSIONLESS;
-                } else if (streq(type, "LINEAR")) {
-                    unit.type = UNIT_TYPE_LINEAR;
-                } else if (streq(type, "RADIAL")) {
-                    unit.type = UNIT_TYPE_RADIAL;
-                } else if (streq(type, "FONT_HEIGHT")) {
-                    unit.type = UNIT_TYPE_FONT_HEIGHT;
+                if (getTypeMappings().find(type) != getTypeMappings().end())
+                {
+                    unit.type = getTypeMappings()[type];
                 } else {
                     g_warning("Skipping unknown unit type '%s' for %s.\n", type, name);
                     skip = true;
diff --git a/src/util/units.h b/src/util/units.h
index f275d7c3a..ead49d3b4 100644
--- a/src/util/units.h
+++ b/src/util/units.h
@@ -47,6 +47,26 @@ const char DEG[] = "°";
 
 class Unit {
  public:
+    Unit();
+    Unit(UnitType type,
+         double factor,
+         Glib::ustring const &name,
+         Glib::ustring const &name_plural,
+         Glib::ustring const &abbr,
+         Glib::ustring const &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;
+
+    UnitType       type;
+    double         factor;
     Glib::ustring  name;
     Glib::ustring  name_plural;
     Glib::ustring  abbr;
@@ -70,25 +90,50 @@ class Unit {
 
 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::map<Glib::ustring, Unit*> UnitMap;
 
+    /** Add a new unit to the table */
     void    addUnit(Unit const& u, bool primary);
+
+    /** Retrieve a given unit based on its string identifier */
     Unit    getUnit(Glib::ustring const& name) const;
+
+    /** Remove a unit definition from the given unit type 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 iteratable list of items in the given unit table */
     UnitTable::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();
 
     bool    load(Glib::ustring const &filename);
+
+    /** Loads units from a text file.
+     *
+     * loadText loads and merges the contents of the given file into the UnitTable,
+     * possibly overwriting existing unit definitions.
+     *
+     * @param filename file to be loaded
+     */
     bool    loadText(Glib::ustring const &filename);
+
+    /** Saves the current UnitTable to the given file. */
     bool    save(Glib::ustring const &filename);
 
  protected:
@@ -119,3 +164,13 @@ public:
 } // 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 :