units.cpp

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <cmath>
#include <cerrno>
#include <glib.h>

#include "io/simple-sax.h"
#include "util/units.h"
#include "path-prefix.h"
#include "streq.h"

namespace Inkscape {
namespace Util {

class UnitsSAXHandler : public Inkscape::IO::FlatSaxHandler
{
public:
    UnitsSAXHandler(UnitTable *table) : FlatSaxHandler(), tbl(table) {}
    virtual ~UnitsSAXHandler() {}

    virtual void _startElement(xmlChar const *name, xmlChar const **attrs);
    virtual void _endElement(xmlChar const *name);

    UnitTable *tbl;
    bool primary;
    bool skip;
    Unit unit;
};


#define BUFSIZE (255)

/**
 * Returns the suggested precision to use for displaying numbers
 * of 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;
    }
}

/**
 * Initializes the unit tables and identifies the primary unit types.
 *
 * The primary unit's conversion factor is required to be 1.00
 */
UnitTable::UnitTable() 
{
    // if we swich to the xml file, don't forget to force locale to 'C'
    //    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;
    }
}

/** 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;
    }
}

/** 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);
    } else {
      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;
    }
}

/** 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))));
      }
    }

    return submap;
}

/** Returns the default unit abbr for the given type */
Glib::ustring
UnitTable::primary(UnitType type) const {
    return _primary_unit[type];
}

/** Merges the contents of the given file into the UnitTable,
    possibly overwriting existing unit definitions.  This loads
    from a text file */
bool
UnitTable::loadText(Glib::ustring const &filename) {
    char buf[BUFSIZE];

    // 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("* INKSCAPE_DATADIR is:  '%s'\n", INKSCAPE_DATADIR);
        g_warning("* INKSCAPE_UIDIR is:  '%s'\n", INKSCAPE_UIDIR);
      return false;
    }

    // bypass current locale in order to make
    // sscanf read floats with '.' as a separator
    // set locate to 'C' and keep old locale
    char *old_locale;
    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;
    // locate is set to C, scanning %lf should work _everywhere_
      if (sscanf(buf, "%s %s %s %s %lf %s %n", 
               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'));

    }

    // set back the saved locale
    setlocale (LC_NUMERIC, old_locale);
    g_free (old_locale);

    // close file
    if (fclose(f) != 0) {
      g_warning("Error closing units file '%s':  %s\n",
            filename.c_str(), strerror(errno));
      return false;
    }

    return true;
}

bool
UnitTable::load(Glib::ustring const &filename) {
    UnitsSAXHandler handler(this);

    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;
    }

    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;
    }

    // write out header
    // foreach item in _unit_map, sorted alphabetically by type and then unit name
    //    sprintf a line
    //      name
    //      name_plural
    //      abbr
    //      type
    //      factor
    //      PRI - if listed in primary unit table, 'Y', else 'N'
    //      description
    //    write line to the file

    // close file
    if (fclose(f) != 0) {
      g_warning("Error closing units file '%s':  %s\n",
              filename.c_str(), strerror(errno));
      return false;
    }

    return true;
}


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;
        primary = false;
        skip = false;

        for ( int i = 0; attrs[i]; i += 2 ) {
            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;
                } else {
                    g_warning("Skipping unknown unit type '%s' for %s.\n", type, name);
                    skip = true;
                }
            } else if (streq("pri", key)) {
                primary = attrs[i+1][0] == 'y' || attrs[i+1][0] == 'Y';
            }
        }
    }
}

void UnitsSAXHandler::_endElement(xmlChar const *xname)
{
    char const *const name = (char const *) xname;
    if (streq("name", name)) {
        unit.name = data;
    } else if (streq("plural", name)) {
        unit.name_plural = data;
    } else if (streq("abbr", name)) {
        unit.abbr = data;
    } else if (streq("factor", name)) {
        // TODO make sure we use the right conversion
        unit.factor = atol(data.c_str());
    } else if (streq("description", name)) {
        unit.description = data;
    } else if (streq("unit", name)) {
        if (!skip) {
            tbl->addUnit(unit, primary);
        }
    }
}

} // 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:encoding=utf-8:textwidth=99 :