number_unit.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2007 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

/****************************************************************************************************/

#ifndef ADOBE_NUMBER_UNIT_HPP
#define ADOBE_NUMBER_UNIT_HPP

/****************************************************************************************************/

#include <adobe/algorithm/clamp.hpp>
#include <adobe/name_fwd.hpp>
#include <adobe/dictionary_fwd.hpp>

#include <string>

/****************************************************************************************************/

namespace adobe {

/****************************************************************************************************/

struct unit_t
{
    unit_t() :
        unit_name_m(0),
        base_unit_id_m(0),
        decimal_places_m(0),    
        trailing_zeroes_m(false),
        format_m("#"),
        increment_m(1),
        scale_m_m(1),
        scale_b_m(0),
        min_value_m((std::numeric_limits<double>::min)()),
        max_value_m((std::numeric_limits<double>::max)())
    { }
    
    // this is a name_t indentifier for identifying which unit is selected
    unsigned long unit_name_m;

    std::string name_m;
    std::string short_name_m;
    adobe::name_t base_unit_filter_m;
    adobe::name_t base_unit_m;
    // Unique id for base unit
    unsigned int base_unit_id_m;    

    unsigned int decimal_places_m;
    bool trailing_zeroes_m;

    std::string format_m;   

    double increment_m;

    double scale_m_m;

    double scale_b_m; 

    double min_value_m;

    double max_value_m;
};

unit_t to_unit(const dictionary_t& dict,  const unit_t& default_unit = unit_t());

inline double to_scaled_value(double base_value, const unit_t& unit)
{ return (unit.scale_m_m * base_value) + unit.scale_b_m; }

inline double to_base_value(double scaled_value, const unit_t& unit)
{ return (scaled_value - unit.scale_b_m) / unit.scale_m_m; }

inline double to_pinned_base_value(double               scaled_value,
                                   const unit_t& unit,
                                   double               min,
                                   double               max)
{
    double base(to_base_value(scaled_value, unit));

    if (min == (std::numeric_limits<double>::min)())
        min = base;

    if (max == (std::numeric_limits<double>::max)())
        max = base;

    return adobe::clamp(base, min, max);
}

/****************************************************************************************************/

} //namespace adobe

/****************************************************************************************************/

#endif

/****************************************************************************************************/