PrusaSlicer-NonPlainar/xs/src/Config.hpp

451 lines
12 KiB
C++
Raw Normal View History

#ifndef slic3r_Config_hpp_
#define slic3r_Config_hpp_
#include <myinit.h>
#include <map>
2013-12-20 19:54:11 +00:00
#include <sstream>
#include <climits>
2013-12-20 19:54:11 +00:00
#include <cstdio>
#include <cstdlib>
2013-12-21 09:46:43 +00:00
#include <iostream>
2014-01-04 23:36:33 +00:00
#include <stdexcept>
#include <string>
#include <vector>
2013-12-20 19:54:11 +00:00
#include "Point.hpp"
2013-12-20 15:37:28 +00:00
namespace Slic3r {
typedef std::string t_config_option_key;
typedef std::vector<std::string> t_config_option_keys;
2013-12-20 15:37:28 +00:00
class ConfigOption {
public:
virtual ~ConfigOption() {};
2014-01-05 12:16:13 +00:00
virtual std::string serialize() const = 0;
2013-12-20 19:54:11 +00:00
virtual void deserialize(std::string str) = 0;
2013-12-20 15:37:28 +00:00
};
2014-01-04 23:36:33 +00:00
template <class T>
class ConfigOptionVector
{
public:
virtual ~ConfigOptionVector() {};
std::vector<T> values;
T get_at(size_t i) {
try {
return this->values.at(i);
} catch (const std::out_of_range& oor) {
return this->values.front();
}
};
};
2013-12-20 15:37:28 +00:00
class ConfigOptionFloat : public ConfigOption
{
public:
double value; // use double instead of float for preserving compatibility with values coming from Perl
2013-12-20 19:54:11 +00:00
ConfigOptionFloat() : value(0) {};
operator double() const { return this->value; };
2013-12-20 19:54:11 +00:00
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-20 19:54:11 +00:00
std::ostringstream ss;
ss << this->value;
return ss.str();
};
void deserialize(std::string str) {
this->value = ::atof(str.c_str());
};
2013-12-20 15:37:28 +00:00
};
2014-01-04 23:36:33 +00:00
class ConfigOptionFloats : public ConfigOption, public ConfigOptionVector<double>
2013-12-21 13:27:58 +00:00
{
public:
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-21 13:27:58 +00:00
std::ostringstream ss;
for (std::vector<double>::const_iterator it = this->values.begin(); it != this->values.end(); ++it) {
2013-12-21 13:27:58 +00:00
if (it - this->values.begin() != 0) ss << ",";
ss << *it;
}
return ss.str();
};
void deserialize(std::string str) {
this->values.clear();
std::istringstream is(str);
std::string item_str;
while (std::getline(is, item_str, ',')) {
this->values.push_back(::atof(item_str.c_str()));
}
};
};
2013-12-20 15:37:28 +00:00
class ConfigOptionInt : public ConfigOption
{
public:
int value;
2013-12-20 19:54:11 +00:00
ConfigOptionInt() : value(0) {};
2013-12-20 15:37:28 +00:00
operator int() const { return this->value; };
2013-12-20 19:54:11 +00:00
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-20 19:54:11 +00:00
std::ostringstream ss;
ss << this->value;
return ss.str();
};
void deserialize(std::string str) {
this->value = ::atoi(str.c_str());
};
2013-12-20 15:37:28 +00:00
};
2014-01-04 23:36:33 +00:00
class ConfigOptionInts : public ConfigOption, public ConfigOptionVector<int>
2013-12-21 13:27:58 +00:00
{
public:
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-21 13:27:58 +00:00
std::ostringstream ss;
for (std::vector<int>::const_iterator it = this->values.begin(); it != this->values.end(); ++it) {
if (it - this->values.begin() != 0) ss << ",";
ss << *it;
}
return ss.str();
};
void deserialize(std::string str) {
this->values.clear();
std::istringstream is(str);
std::string item_str;
while (std::getline(is, item_str, ',')) {
this->values.push_back(::atoi(item_str.c_str()));
}
};
};
2013-12-20 15:37:28 +00:00
class ConfigOptionString : public ConfigOption
{
public:
std::string value;
2013-12-20 19:54:11 +00:00
ConfigOptionString() : value("") {};
2013-12-20 15:37:28 +00:00
operator std::string() const { return this->value; };
2013-12-20 19:54:11 +00:00
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-20 19:54:11 +00:00
std::string str = this->value;
// s/\R/\\n/g
size_t pos = 0;
while ((pos = str.find("\n", pos)) != std::string::npos || (pos = str.find("\r", pos)) != std::string::npos) {
str.replace(pos, 1, "\\n");
pos += 2; // length of "\\n"
}
return str;
};
void deserialize(std::string str) {
// s/\\n/\n/g
size_t pos = 0;
while ((pos = str.find("\\n", pos)) != std::string::npos) {
str.replace(pos, 2, "\n");
pos += 1; // length of "\n"
}
this->value = str;
};
2013-12-20 15:37:28 +00:00
};
// semicolon-separated strings
2014-01-04 23:36:33 +00:00
class ConfigOptionStrings : public ConfigOption, public ConfigOptionVector<std::string>
{
public:
2014-01-05 12:16:13 +00:00
std::string serialize() const {
std::ostringstream ss;
for (std::vector<std::string>::const_iterator it = this->values.begin(); it != this->values.end(); ++it) {
if (it - this->values.begin() != 0) ss << ";";
ss << *it;
}
return ss.str();
};
void deserialize(std::string str) {
this->values.clear();
std::istringstream is(str);
std::string item_str;
while (std::getline(is, item_str, ';')) {
this->values.push_back(item_str);
}
};
};
2013-12-20 15:37:28 +00:00
class ConfigOptionFloatOrPercent : public ConfigOption
{
public:
double value;
2013-12-20 15:37:28 +00:00
bool percent;
2013-12-20 19:54:11 +00:00
ConfigOptionFloatOrPercent() : value(0), percent(false) {};
2014-01-05 12:16:13 +00:00
double get_abs_value(double ratio_over) const {
if (this->percent) {
return ratio_over * this->value / 100;
} else {
return this->value;
}
};
std::string serialize() const {
2013-12-20 19:54:11 +00:00
std::ostringstream ss;
ss << this->value;
std::string s(ss.str());
if (this->percent) s += "%";
return s;
};
void deserialize(std::string str) {
if (str.find_first_of("%") != std::string::npos) {
sscanf(str.c_str(), "%lf%%", &this->value);
2013-12-20 19:54:11 +00:00
this->percent = true;
} else {
this->value = ::atof(str.c_str());
this->percent = false;
}
};
};
class ConfigOptionPoint : public ConfigOption
{
public:
Pointf point;
ConfigOptionPoint() : point(Pointf(0,0)) {};
2013-12-20 20:32:18 +00:00
operator Pointf() const { return this->point; };
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-20 19:54:11 +00:00
std::ostringstream ss;
ss << this->point.x;
ss << ",";
ss << this->point.y;
return ss.str();
};
void deserialize(std::string str) {
sscanf(str.c_str(), "%lf%*1[,x]%lf", &this->point.x, &this->point.y);
2013-12-20 19:54:11 +00:00
};
};
2014-01-04 23:36:33 +00:00
class ConfigOptionPoints : public ConfigOption, public ConfigOptionVector<Pointf>
2013-12-21 13:27:58 +00:00
{
public:
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-21 13:27:58 +00:00
std::ostringstream ss;
2014-01-04 23:36:33 +00:00
for (Pointfs::const_iterator it = this->values.begin(); it != this->values.end(); ++it) {
if (it - this->values.begin() != 0) ss << ",";
2013-12-21 13:27:58 +00:00
ss << it->x;
ss << "x";
ss << it->y;
}
return ss.str();
};
void deserialize(std::string str) {
2014-01-04 23:36:33 +00:00
this->values.clear();
2013-12-21 13:27:58 +00:00
std::istringstream is(str);
std::string point_str;
while (std::getline(is, point_str, ',')) {
Pointf point;
sscanf(point_str.c_str(), "%lfx%lf", &point.x, &point.y);
2014-01-04 23:36:33 +00:00
this->values.push_back(point);
2013-12-21 13:27:58 +00:00
}
};
};
2013-12-20 20:32:18 +00:00
class ConfigOptionBool : public ConfigOption
{
public:
bool value;
ConfigOptionBool() : value(false) {};
operator bool() const { return this->value; };
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-20 20:32:18 +00:00
return std::string(this->value ? "1" : "0");
};
void deserialize(std::string str) {
this->value = (str.compare("1") == 0);
};
};
2014-01-04 23:36:33 +00:00
class ConfigOptionBools : public ConfigOption, public ConfigOptionVector<bool>
2013-12-21 13:27:58 +00:00
{
public:
2014-01-05 12:16:13 +00:00
std::string serialize() const {
2013-12-21 13:27:58 +00:00
std::ostringstream ss;
for (std::vector<bool>::const_iterator it = this->values.begin(); it != this->values.end(); ++it) {
if (it - this->values.begin() != 0) ss << ",";
ss << (*it ? "1" : "0");
}
return ss.str();
};
void deserialize(std::string str) {
this->values.clear();
std::istringstream is(str);
std::string item_str;
while (std::getline(is, item_str, ',')) {
this->values.push_back(item_str.compare("1") == 0);
}
};
2013-12-20 20:32:18 +00:00
};
typedef std::map<std::string,int> t_config_enum_values;
2013-12-21 09:46:43 +00:00
template <class T>
class ConfigOptionEnum : public ConfigOption
2013-12-20 20:32:18 +00:00
{
public:
2013-12-21 09:46:43 +00:00
T value;
2013-12-20 20:32:18 +00:00
2013-12-21 09:46:43 +00:00
operator T() const { return this->value; };
2013-12-20 20:32:18 +00:00
2014-01-05 12:16:13 +00:00
std::string serialize() const {
t_config_enum_values enum_keys_map = ConfigOptionEnum<T>::get_enum_values();
for (t_config_enum_values::iterator it = enum_keys_map.begin(); it != enum_keys_map.end(); ++it) {
if (it->second == static_cast<int>(this->value)) return it->first;
}
return "";
};
void deserialize(std::string str) {
t_config_enum_values enum_keys_map = ConfigOptionEnum<T>::get_enum_values();
assert(enum_keys_map.count(str) > 0);
this->value = static_cast<T>(enum_keys_map[str]);
};
static t_config_enum_values get_enum_values();
2013-12-21 09:46:43 +00:00
};
/* We use this one in DynamicConfig objects, otherwise it's better to use
the specialized ConfigOptionEnum<T> containers. */
class ConfigOptionEnumGeneric : public ConfigOption
{
public:
int value;
t_config_enum_values* keys_map;
operator int() const { return this->value; };
2014-01-05 12:16:13 +00:00
std::string serialize() const {
for (t_config_enum_values::iterator it = this->keys_map->begin(); it != this->keys_map->end(); ++it) {
if (it->second == this->value) return it->first;
}
return "";
};
2013-12-20 20:32:18 +00:00
void deserialize(std::string str) {
assert(this->keys_map->count(str) != 0);
this->value = (*this->keys_map)[str];
};
2013-12-21 13:27:58 +00:00
};
enum ConfigOptionType {
coFloat,
2013-12-21 13:27:58 +00:00
coFloats,
coInt,
2013-12-21 13:27:58 +00:00
coInts,
coString,
coStrings,
2013-12-20 15:37:28 +00:00
coFloatOrPercent,
2013-12-20 19:54:11 +00:00
coPoint,
2013-12-21 13:27:58 +00:00
coPoints,
2013-12-20 20:32:18 +00:00
coBool,
2013-12-21 13:27:58 +00:00
coBools,
coEnum,
};
class ConfigOptionDef
{
public:
ConfigOptionType type;
std::string label;
2014-01-02 21:06:58 +00:00
std::string full_label;
std::string category;
std::string tooltip;
std::string sidetext;
std::string cli;
std::string scope;
t_config_option_key ratio_over;
bool multiline;
bool full_width;
bool readonly;
int height;
int width;
int min;
int max;
std::vector<t_config_option_key> aliases;
std::vector<t_config_option_key> shortcut;
std::vector<std::string> enum_values;
std::vector<std::string> enum_labels;
t_config_enum_values enum_keys_map;
ConfigOptionDef() : multiline(false), full_width(false), readonly(false),
height(-1), width(-1), min(INT_MIN), max(INT_MAX) {};
};
typedef std::map<t_config_option_key,ConfigOptionDef> t_optiondef_map;
class ConfigBase
{
public:
t_optiondef_map* def;
ConfigBase() : def(NULL) {};
bool has(const t_config_option_key opt_key);
2013-12-20 19:54:11 +00:00
virtual ConfigOption* option(const t_config_option_key opt_key, bool create = false) = 0;
virtual void keys(t_config_option_keys *keys) = 0;
2013-12-20 15:37:28 +00:00
void apply(ConfigBase &other, bool ignore_nonexistent = false);
2013-12-20 19:54:11 +00:00
std::string serialize(const t_config_option_key opt_key);
void set_deserialize(const t_config_option_key opt_key, std::string str);
double get_abs_value(const t_config_option_key opt_key);
2014-01-01 16:29:15 +00:00
double get_abs_value(const t_config_option_key opt_key, double ratio_over);
2013-12-20 15:37:28 +00:00
#ifdef SLIC3RXS
SV* as_hash();
2013-12-20 15:37:28 +00:00
SV* get(t_config_option_key opt_key);
2014-01-04 23:36:33 +00:00
SV* get_at(t_config_option_key opt_key, size_t i);
2013-12-20 19:54:11 +00:00
void set(t_config_option_key opt_key, SV* value);
2013-12-20 15:37:28 +00:00
#endif
};
class DynamicConfig : public ConfigBase
{
public:
DynamicConfig() {};
2013-12-20 19:54:11 +00:00
~DynamicConfig();
ConfigOption* option(const t_config_option_key opt_key, bool create = false);
2013-12-20 15:37:28 +00:00
void keys(t_config_option_keys *keys);
void erase(const t_config_option_key opt_key);
2013-12-20 15:37:28 +00:00
private:
2013-12-20 19:54:11 +00:00
DynamicConfig(const DynamicConfig& other); // we disable this by making it private and unimplemented
DynamicConfig& operator= (const DynamicConfig& other); // we disable this by making it private and unimplemented
2013-12-20 15:37:28 +00:00
typedef std::map<t_config_option_key,ConfigOption*> t_options_map;
t_options_map options;
};
class StaticConfig : public ConfigBase
{
public:
2013-12-20 15:37:28 +00:00
void keys(t_config_option_keys *keys);
};
}
#endif