X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fconfiguration_variable.h;h=a7fe8def48169c17c508ca714ffc135a1ea9bfb9;hb=cc7d4db5fe9132c38b919ab073b91d442abad9b6;hp=a61283ecd0155bce6fa5ac0f3acf2150318f2bfc;hpb=4c000c13eecf4cb3d63be304fc0056ddaa35bb21;p=ardour.git

diff --git a/libs/ardour/ardour/configuration_variable.h b/libs/ardour/ardour/configuration_variable.h
index a61283ecd0..a7fe8def48 100644
--- a/libs/ardour/ardour/configuration_variable.h
+++ b/libs/ardour/ardour/configuration_variable.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000-2007 Paul Davis 
+    Copyright (C) 2000-2007 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -20,40 +20,31 @@
 #ifndef __ardour_configuration_variable_h__
 #define __ardour_configuration_variable_h__
 
-#include <sstream>
-#include <ostream>
 #include <iostream>
+#include <sstream>
 
-#include <pbd/xml++.h>
+#include "pbd/xml++.h"
+#include "pbd/convert.h"
+#include "ardour/types.h"
+#include "ardour/utils.h"
 
 namespace ARDOUR {
 
 class ConfigVariableBase {
   public:
-	enum Owner {
-		Default = 0x1,
-		System = 0x2,
-		Config = 0x4,
-		Session = 0x8,
-		Interface = 0x10
-	};
-
-	ConfigVariableBase (std::string str) : _name (str), _owner (Default) {}
-	virtual ~ConfigVariableBase() {}
 
-	std::string name() const { return _name; }
-	Owner owner() const { return _owner; }
+	ConfigVariableBase (std::string str) : _name (str) {}
+	virtual ~ConfigVariableBase() {}
 
-	virtual void add_to_node (XMLNode& node) = 0;
-	virtual bool set_from_node (const XMLNode& node, Owner owner) = 0;
+	std::string name () const { return _name; }
+	void add_to_node (XMLNode&);
+	bool set_from_node (XMLNode const &);
 
-	void show_stored_value (const std::string&);
-	static void set_show_stored_values (bool yn);
+	virtual std::string get_as_string () const = 0;
+	virtual void set_from_string (std::string const &) = 0;
 
   protected:
 	std::string _name;
-	Owner _owner;
-	static bool show_stores;
 
 	void notify ();
 	void miss ();
@@ -63,122 +54,168 @@ template<class T>
 class ConfigVariable : public ConfigVariableBase
 {
   public:
+
 	ConfigVariable (std::string str) : ConfigVariableBase (str) {}
 	ConfigVariable (std::string str, T val) : ConfigVariableBase (str), value (val) {}
 
-	virtual bool set (T val, Owner owner = ARDOUR::ConfigVariableBase::Config) {
+	T get() const {
+		return value;
+	}
+
+	std::string get_as_string () const {
+		std::ostringstream ss;
+		ss << value;
+		return ss.str ();
+	}
+
+	virtual bool set (T val) {
 		if (val == value) {
 			miss ();
 			return false;
 		}
 		value = val;
-		_owner = (ConfigVariableBase::Owner)(_owner |owner);
 		notify ();
 		return true;
 	}
 
-	T get() const {
+	virtual void set_from_string (std::string const & s) {
+		std::stringstream ss;
+		ss << s;
+		ss >> value;
+	}
+
+  protected:
+	virtual T get_for_save() { return value; }
+	T value;
+};
+
+/** Specialisation of ConfigVariable for std::string to cope with whitespace properly */
+template<>
+class ConfigVariable<std::string> : public ConfigVariableBase
+{
+  public:
+
+	ConfigVariable (std::string str) : ConfigVariableBase (str) {}
+	ConfigVariable (std::string str, std::string val) : ConfigVariableBase (str), value (val) {}
+
+	std::string get() const {
 		return value;
 	}
 
-	void add_to_node (XMLNode& node) {
-		std::stringstream ss;
+	std::string get_as_string () const {
+		return value;
+	}
+
+	virtual bool set (std::string val) {
+		if (val == value) {
+			miss ();
+			return false;
+		}
+		value = val;
+		notify ();
+		return true;
+	}
+
+	virtual void set_from_string (std::string const & s) {
+		value = s;
+	}
+
+  protected:
+	virtual std::string get_for_save() { return value; }
+	std::string value;
+};
+
+template<>
+class ConfigVariable<bool> : public ConfigVariableBase
+{
+  public:
+
+	ConfigVariable (std::string str) : ConfigVariableBase (str), value (false) {}
+	ConfigVariable (std::string str, bool val) : ConfigVariableBase (str), value (val) {}
+
+	bool get() const {
+		return value;
+	}
+
+	std::string get_as_string () const {
+		std::ostringstream ss;
 		ss << value;
-		show_stored_value (ss.str());
-		XMLNode* child = new XMLNode ("Option");
-		child->add_property ("name", _name);
-		child->add_property ("value", ss.str());
-		node.add_child_nocopy (*child);
-	}
-	
-	bool set_from_node (const XMLNode& node, Owner owner) {
-
-		if (node.name() == "Config") {
-
-			/* ardour.rc */
-
-			const XMLProperty* prop;
-			XMLNodeList nlist;
-			XMLNodeConstIterator niter;
-			XMLNode* child;
-			
-			nlist = node.children();
-			
-			for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-				
-				child = *niter;
-				
-				if (child->name() == "Option") {
-					if ((prop = child->property ("name")) != 0) {
-						if (prop->value() == _name) {
-							if ((prop = child->property ("value")) != 0) {
-								std::stringstream ss;
-								ss << prop->value();
-								ss >> value;
-								_owner = (ConfigVariableBase::Owner)(_owner |owner);
-								return true;
-							}
-						}
-					}
-				}
-			}
-			
-		} else if (node.name() == "Options") {
-
-			/* session file */
-
-			XMLNodeList olist;
-			XMLNodeConstIterator oiter;
-			XMLNode* option;
-			const XMLProperty* opt_prop;
-			
-			olist = node.children();
-			
-			for (oiter = olist.begin(); oiter != olist.end(); ++oiter) {
-				
-				option = *oiter;
-				
-				if (option->name() == _name) {
-					if ((opt_prop = option->property ("val")) != 0) {
-						std::stringstream ss;
-						ss << opt_prop->value();
-						ss >> value;
-						_owner = (ConfigVariableBase::Owner)(_owner |owner);
-						return true;
-					}
-				}
-			}
+		return ss.str ();
+	}
+
+	virtual bool set (bool val) {
+		if (val == value) {
+			miss ();
+			return false;
 		}
+		value = val;
+		notify ();
+		return true;
+	}
 
-		return false;
+	void set_from_string (std::string const & s) {
+		value = PBD::string_is_affirmative (s);
 	}
 
   protected:
-	virtual T get_for_save() { return value; }
-	T value;
+	virtual bool get_for_save() { return value; }
+	bool value;
 };
 
 template<class T>
 class ConfigVariableWithMutation : public ConfigVariable<T>
 {
   public:
-	ConfigVariableWithMutation (std::string name, T val, T (*m)(T)) 
+	ConfigVariableWithMutation (std::string name, T val, T (*m)(T))
 		: ConfigVariable<T> (name, val), mutator (m) {}
 
-	bool set (T val, ConfigVariableBase::Owner owner) {
+	bool set (T val) {
 		if (unmutated_value != val) {
 			unmutated_value = val;
-			return ConfigVariable<T>::set (mutator (val), owner);
-		} 
+			return ConfigVariable<T>::set (mutator (val));
+		}
 		return false;
 	}
 
+	void set_from_string (std::string const & s) {
+		T v;
+		std::stringstream ss;
+		ss << s;
+		ss >> v;
+		set (v);
+	}
+
   protected:
 	virtual T get_for_save() { return unmutated_value; }
 	T unmutated_value;
 	T (*mutator)(T);
 };
 
+template<>
+class ConfigVariableWithMutation<std::string> : public ConfigVariable<std::string>
+{
+  public:
+	ConfigVariableWithMutation (std::string name, std::string val, std::string (*m)(std::string))
+		: ConfigVariable<std::string> (name, val), mutator (m) {}
+
+	bool set (std::string val) {
+		if (unmutated_value != val) {
+			unmutated_value = val;
+			return ConfigVariable<std::string>::set (mutator (val));
+		}
+		return false;
+	}
+
+	void set_from_string (std::string const & s) {
+		set (s);
+	}
+
+  protected:
+	virtual std::string get_for_save() { return unmutated_value; }
+	std::string unmutated_value;
+	std::string (*mutator)(std::string);
+};
+
 }
 
 #endif /* __ardour_configuration_variable_h__ */