libs/ardour/configuration.cc

   1 /*
   2     Copyright (C) 1999-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <unistd.h>
  21 #include <cstdio> /* for snprintf, grrr */
  22
  23 #include <glib.h>
  24 #include <glib/gstdio.h> /* for g_stat() */
  25 #include <glibmm/miscutils.h>
  26
  27 #include "pbd/failed_constructor.h"
  28 #include "pbd/xml++.h"
  29 #include "pbd/filesystem.h"
  30 #include "pbd/file_utils.h"
  31
  32 #include "midi++/manager.h"
  33
  34 #include "ardour/ardour.h"
  35 #include "ardour/configuration.h"
  36 #include "ardour/audio_diskstream.h"
  37 #include "ardour/control_protocol_manager.h"
  38 #include "ardour/filesystem_paths.h"
  39
  40 #include "i18n.h"
  41
  42 using namespace ARDOUR;
  43 using namespace std;
  44 using namespace PBD;
  45
  46 /* this is global so that we do not have to indirect through an object pointer
  47    to reference it.
  48 */
  49
  50 namespace ARDOUR {
  51     float speed_quietning = 0.251189; // -12dB reduction for ffwd or rewind
  52 }
  53
  54 Configuration::Configuration ()
  55         :
  56 /* construct variables */
  57 #undef  CONFIG_VARIABLE
  58 #undef  CONFIG_VARIABLE_SPECIAL
  59 #define CONFIG_VARIABLE(Type,var,name,value) var (name,value),
  60 #define CONFIG_VARIABLE_SPECIAL(Type,var,name,value,mutator) var (name,value,mutator),
  61 #include "ardour/configuration_vars.h"
  62 #undef  CONFIG_VARIABLE
  63 #undef  CONFIG_VARIABLE_SPECIAL
  64
  65
  66         current_owner (ConfigVariableBase::Default)
  67 {
  68         _control_protocol_state = 0;
  69 }
  70
  71 Configuration::~Configuration ()
  72 {
  73 }
  74
  75 void
  76 Configuration::set_current_owner (ConfigVariableBase::Owner owner)
  77 {
  78         current_owner = owner;
  79 }
  80
  81 int
  82 Configuration::load_state ()
  83 {
  84         bool found = false;
  85
  86         sys::path system_rc_file;
  87         struct stat statbuf;
  88
  89         /* load system configuration first */
  90
  91         if (find_file_in_search_path (ardour_search_path() + system_config_search_path(),
  92                         "ardour_system.rc", system_rc_file) )
  93         {
  94                 XMLTree tree;
  95                 found = true;
  96
  97                 string rcfile = system_rc_file.to_string();
  98
  99                 /* stupid XML Parser hates empty files */
 100
 101                 if (g_stat (rcfile.c_str(), &statbuf)) {
 102                         return -1;
 103                 }
 104
 105                 if (statbuf.st_size != 0) {
 106                         cerr << string_compose (_("loading system configuration file %1"), rcfile) << endl;
 107
 108                         if (!tree.read (rcfile.c_str())) {
 109                                 error << string_compose(_("Ardour: cannot read system configuration file \"%1\""), rcfile) << endmsg;
 110                                 return -1;
 111                         }
 112
 113                         current_owner = ConfigVariableBase::System;
 114
 115                         if (set_state (*tree.root())) {
 116                                 error << string_compose(_("Ardour: system configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
 117                                 return -1;
 118                         }
 119                 } else {
 120                         error << _("your system Ardour configuration file is empty. This probably means that there as an error installing Ardour") << endmsg;
 121                 }
 122         }
 123
 124         /* now load configuration file for user */
 125
 126         sys::path user_rc_file;
 127
 128         if (find_file_in_search_path (ardour_search_path() + user_config_directory(),
 129                         "ardour.rc", user_rc_file))
 130         {
 131                 XMLTree tree;
 132
 133                 string rcfile = user_rc_file.to_string();
 134
 135                 /* stupid XML parser hates empty files */
 136
 137                 if (g_stat (rcfile.c_str(), &statbuf)) {
 138                         return -1;
 139                 }
 140
 141                 if (statbuf.st_size != 0) {
 142                         cerr << string_compose (_("loading user configuration file %1"), rcfile) << endl;
 143
 144                         if (!tree.read (rcfile)) {
 145                                 error << string_compose(_("Ardour: cannot read configuration file \"%1\""), rcfile) << endmsg;
 146                                 return -1;
 147                         }
 148
 149                         current_owner = ConfigVariableBase::Config;
 150
 151                         if (set_state (*tree.root())) {
 152                                 error << string_compose(_("Ardour: user configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
 153                                 return -1;
 154                         }
 155                 } else {
 156                         warning << _("your Ardour configuration file is empty. This is not normal.") << endmsg;
 157                 }
 158         }
 159
 160         if (!found)
 161                 error << "Ardour: could not find configuration file (ardour.rc), canvas will look broken." << endmsg;
 162
 163         return 0;
 164 }
 165
 166 int
 167 Configuration::save_state()
 168 {
 169         XMLTree tree;
 170
 171         try
 172         {
 173                 sys::create_directories (user_config_directory ());
 174         }
 175         catch (const sys::filesystem_error& ex)
 176         {
 177                 error << "Could not create user configuration directory" << endmsg;
 178                 return -1;
 179         }
 180
 181         sys::path rcfile_path(user_config_directory());
 182
 183         rcfile_path /= "ardour.rc";
 184         const string rcfile = rcfile_path.to_string();
 185
 186         // this test seems bogus?
 187         if (rcfile.length()) {
 188                 tree.set_root (&get_state());
 189                 if (!tree.write (rcfile.c_str())){
 190                         error << string_compose (_("Config file %1 not saved"), rcfile) << endmsg;
 191                         return -1;
 192                 }
 193         }
 194
 195         return 0;
 196 }
 197
 198 void
 199 Configuration::add_instant_xml(XMLNode& node)
 200 {
 201         Stateful::add_instant_xml (node, user_config_directory ());
 202 }
 203
 204 XMLNode*
 205 Configuration::instant_xml(const string& node_name)
 206 {
 207         return Stateful::instant_xml (node_name, user_config_directory ());
 208 }
 209
 210
 211 bool
 212 Configuration::save_config_options_predicate (ConfigVariableBase::Owner owner)
 213 {
 214         /* only save things that were in the config file to start with */
 215         return owner & ConfigVariableBase::Config;
 216 }
 217
 218 XMLNode&
 219 Configuration::get_state ()
 220 {
 221         XMLNode* root;
 222         LocaleGuard lg (X_("POSIX"));
 223
 224         root = new XMLNode("Ardour");
 225
 226         MIDI::Manager::PortMap::const_iterator i;
 227         const MIDI::Manager::PortMap& ports = MIDI::Manager::instance()->get_midi_ports();
 228
 229         for (i = ports.begin(); i != ports.end(); ++i) {
 230                 root->add_child_nocopy(i->second->get_state());
 231         }
 232
 233         root->add_child_nocopy (get_variables (sigc::mem_fun (*this, &Configuration::save_config_options_predicate), "Config"));
 234
 235         if (_extra_xml) {
 236                 root->add_child_copy (*_extra_xml);
 237         }
 238
 239         root->add_child_nocopy (ControlProtocolManager::instance().get_state());
 240
 241         return *root;
 242 }
 243
 244 XMLNode&
 245 Configuration::get_variables (sigc::slot<bool,ConfigVariableBase::Owner> predicate, std::string which_node)
 246 {
 247         XMLNode* node;
 248         LocaleGuard lg (X_("POSIX"));
 249
 250         node = new XMLNode(which_node);
 251
 252 #undef  CONFIG_VARIABLE
 253 #undef  CONFIG_VARIABLE_SPECIAL
 254 #define CONFIG_VARIABLE(type,var,Name,value) \
 255          if (node->name() == "Config") { if (predicate (var.owner())) { var.add_to_node (*node); }}
 256 #define CONFIG_VARIABLE_SPECIAL(type,var,Name,value,mutator) \
 257          if (node->name() == "Config") { if (predicate (var.owner())) { var.add_to_node (*node); }}
 258 #include "ardour/configuration_vars.h"
 259 #undef  CONFIG_VARIABLE
 260 #undef  CONFIG_VARIABLE_SPECIAL
 261
 262         return *node;
 263 }
 264
 265 int
 266 Configuration::set_state (const XMLNode& root)
 267 {
 268         if (root.name() != "Ardour") {
 269                 return -1;
 270         }
 271
 272         XMLNodeList nlist = root.children();
 273         XMLNodeConstIterator niter;
 274         XMLNode *node;
 275
 276         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 277
 278                 node = *niter;
 279
 280                 if (node->name() == "MIDI-port") {
 281
 282                         try {
 283
 284                                 MIDI::Port::Descriptor desc (*node);
 285                                 map<string,XMLNode>::iterator x;
 286                                 if ((x = midi_ports.find (desc.tag)) != midi_ports.end()) {
 287                                         midi_ports.erase (x);
 288                                 }
 289                                 midi_ports.insert (pair<string,XMLNode>(desc.tag,*node));
 290                         }
 291
 292                         catch (failed_constructor& err) {
 293                                 warning << _("ill-formed MIDI port specification in ardour rcfile (ignored)") << endmsg;
 294                         }
 295
 296                 } else if (node->name() == "Config") {
 297
 298                         set_variables (*node, ConfigVariableBase::Config);
 299
 300                 } else if (node->name() == "Extra") {
 301                         _extra_xml = new XMLNode (*node);
 302
 303                 } else if (node->name() == ControlProtocolManager::state_node_name) {
 304                         _control_protocol_state = new XMLNode (*node);
 305                 }
 306         }
 307
 308         Diskstream::set_disk_io_chunk_frames (minimum_disk_io_bytes.get() / sizeof (Sample));
 309
 310         return 0;
 311 }
 312
 313 void
 314 Configuration::set_variables (const XMLNode& node, ConfigVariableBase::Owner owner)
 315 {
 316 #undef  CONFIG_VARIABLE
 317 #undef  CONFIG_VARIABLE_SPECIAL
 318 #define CONFIG_VARIABLE(type,var,name,value) \
 319          if (var.set_from_node (node, owner)) { \
 320                  ParameterChanged (name); \
 321          }
 322 #define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) \
 323          if (var.set_from_node (node, owner)) { \
 324                  ParameterChanged (name); \
 325          }
 326
 327 #include "ardour/configuration_vars.h"
 328 #undef  CONFIG_VARIABLE
 329 #undef  CONFIG_VARIABLE_SPECIAL
 330
 331 }
 332 void
 333 Configuration::map_parameters (sigc::slot<void,const char*> theSlot)
 334 {
 335 #undef  CONFIG_VARIABLE
 336 #undef  CONFIG_VARIABLE_SPECIAL
 337 #define CONFIG_VARIABLE(type,var,name,value)                 theSlot (name);
 338 #define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) theSlot (name);
 339 #include "ardour/configuration_vars.h"
 340 #undef  CONFIG_VARIABLE
 341 #undef  CONFIG_VARIABLE_SPECIAL
 342 }
 343
 344 bool ConfigVariableBase::show_stores = false;
 345
 346 void
 347 ConfigVariableBase::set_show_stored_values (bool yn)
 348 {
 349         show_stores = yn;
 350 }
 351
 352 void
 353 ConfigVariableBase::show_stored_value (const string& str)
 354 {
 355         if (show_stores) {
 356                 cerr << "Config variable " << _name << " stored as " << str << endl;
 357         }
 358 }
 359
 360 void
 361 ConfigVariableBase::notify ()
 362 {
 363         // placeholder for any debugging desired when a config variable is modified
 364 }
 365
 366 void
 367 ConfigVariableBase::miss ()
 368 {
 369         // placeholder for any debugging desired when a config variable
 370         // is set but to the same value as it already has
 371 }
 372