libs/ardour/midi_patch_manager.cc

   1 /*
   2     Copyright (C) 2008 Hans Baier
   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     $Id$
  19 */
  20
  21 #include <boost/shared_ptr.hpp>
  22
  23 #include <glibmm/fileutils.h>
  24
  25 #include "pbd/file_utils.h"
  26 #include "pbd/error.h"
  27
  28 #include "ardour/midi_patch_manager.h"
  29
  30 #include "ardour/search_paths.h"
  31
  32 #include "pbd/i18n.h"
  33
  34 using namespace std;
  35 using namespace ARDOUR;
  36 using namespace MIDI;
  37 using namespace MIDI::Name;
  38 using namespace PBD;
  39
  40 MidiPatchManager* MidiPatchManager::_manager = 0;
  41
  42 MidiPatchManager::MidiPatchManager ()
  43 {
  44         add_search_path(midi_patch_search_path ());
  45 }
  46
  47 void
  48 MidiPatchManager::add_search_path (const Searchpath& search_path)
  49 {
  50         for (Searchpath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
  51
  52                 if (_search_path.contains(*i)) {
  53                         // already processed files from this path
  54                         continue;
  55                 }
  56
  57                 if (!Glib::file_test (*i, Glib::FILE_TEST_EXISTS)) {
  58                         continue;
  59                 }
  60
  61                 if (!Glib::file_test (*i, Glib::FILE_TEST_IS_DIR)) {
  62                         continue;
  63                 }
  64
  65                 add_midnam_files_from_directory (*i);
  66
  67                 _search_path.add_directory (*i);
  68         }
  69 }
  70
  71 bool
  72 MidiPatchManager::add_custom_midnam (const std::string& id, const std::string& midnam)
  73 {
  74         boost::shared_ptr<MIDINameDocument> document;
  75         document = boost::shared_ptr<MIDINameDocument>(new MIDINameDocument());
  76         XMLTree mxml;
  77         if (mxml.read_buffer (midnam, true)) {
  78                 if (0 == document->set_state (mxml, *mxml.root())) {
  79                         document->set_file_path ("custom:" + id);
  80                         add_midi_name_document (document);
  81                         return true;
  82                 }
  83         }
  84         return false;
  85 }
  86
  87 bool
  88 MidiPatchManager::remove_custom_midnam (const std::string& id)
  89 {
  90         return remove_midi_name_document ("custom:" + id);
  91 }
  92
  93 void
  94 MidiPatchManager::add_midnam_files_from_directory(const std::string& directory_path)
  95 {
  96         vector<std::string> result;
  97         find_files_matching_pattern (result, directory_path, "*.midnam");
  98
  99         info << string_compose(
 100                         P_("Loading %1 MIDI patch from %2", "Loading %1 MIDI patches from %2", result.size()),
 101                         result.size(), directory_path)
 102              << endmsg;
 103
 104         for (vector<std::string>::const_iterator i = result.begin(); i != result.end(); ++i) {
 105                 load_midi_name_document (*i);
 106         }
 107 }
 108
 109 void
 110 MidiPatchManager::remove_search_path (const Searchpath& search_path)
 111 {
 112         for (Searchpath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
 113
 114                 if (!_search_path.contains(*i)) {
 115                         continue;
 116                 }
 117
 118                 remove_midnam_files_from_directory(*i);
 119
 120                 _search_path.remove_directory (*i);
 121         }
 122 }
 123
 124 void
 125 MidiPatchManager::remove_midnam_files_from_directory(const std::string& directory_path)
 126 {
 127         vector<std::string> result;
 128         find_files_matching_pattern (result, directory_path, "*.midnam");
 129
 130         info << string_compose(
 131                         P_("Unloading %1 MIDI patch from %2", "Unloading %1 MIDI patches from %2", result.size()),
 132                         result.size(), directory_path)
 133              << endmsg;
 134
 135         for (vector<std::string>::const_iterator i = result.begin(); i != result.end(); ++i) {
 136                 remove_midi_name_document (*i);
 137         }
 138 }
 139
 140 bool
 141 MidiPatchManager::load_midi_name_document (const std::string& file_path)
 142 {
 143         boost::shared_ptr<MIDINameDocument> document;
 144         try {
 145                 document = boost::shared_ptr<MIDINameDocument>(new MIDINameDocument(file_path));
 146         }
 147         catch (...) {
 148                 error << string_compose(_("Error parsing MIDI patch file %1"), file_path)
 149                       << endmsg;
 150                 return false;
 151         }
 152         return add_midi_name_document (document);
 153 }
 154
 155 boost::shared_ptr<MIDINameDocument>
 156 MidiPatchManager::document_by_model(std::string model_name) const
 157 {
 158         MidiNameDocuments::const_iterator i = _documents.find (model_name);
 159         if (i != _documents.end ()) {
 160                 return i->second;
 161         }
 162         return boost::shared_ptr<MIDINameDocument> ();
 163 }
 164
 165 bool
 166 MidiPatchManager::add_midi_name_document (boost::shared_ptr<MIDINameDocument> document)
 167 {
 168         for (MIDINameDocument::MasterDeviceNamesList::const_iterator device =
 169                  document->master_device_names_by_model().begin();
 170              device != document->master_device_names_by_model().end();
 171              ++device) {
 172                 if (_documents.find(device->first) != _documents.end()) {
 173                         warning << string_compose(_("Duplicate MIDI device `%1' in `%2' ignored"),
 174                                                   device->first,
 175                                                   document->file_path()) << endmsg;
 176                         continue;
 177                 }
 178
 179                 _documents[device->first] = document;
 180                 _master_devices_by_model[device->first] = device->second;
 181
 182                 _all_models.insert(device->first);
 183                 const std::string& manufacturer = device->second->manufacturer();
 184                 if (_devices_by_manufacturer.find(manufacturer) ==
 185                     _devices_by_manufacturer.end()) {
 186                         MIDINameDocument::MasterDeviceNamesList empty;
 187                         _devices_by_manufacturer.insert(std::make_pair(manufacturer, empty));
 188                 }
 189                 _devices_by_manufacturer[manufacturer].insert(
 190                     std::make_pair(device->first, device->second));
 191
 192                 // TODO: handle this gracefully.
 193                 assert(_documents.count(device->first) == 1);
 194                 assert(_master_devices_by_model.count(device->first) == 1);
 195         }
 196
 197         PatchesChanged(); /* EMIT SIGNAL */
 198         return true;
 199 }
 200
 201 bool
 202 MidiPatchManager::remove_midi_name_document (const std::string& file_path)
 203 {
 204         bool removed = false;
 205         for (MidiNameDocuments::iterator i = _documents.begin(); i != _documents.end();) {
 206                 if (i->second->file_path() == file_path) {
 207
 208                         boost::shared_ptr<MIDINameDocument> document = i->second;
 209
 210                         cout << string_compose(_("Removing MIDI patch file %1"), file_path) << "\n";
 211                         info << string_compose(_("Removing MIDI patch file %1"), file_path) << endmsg;
 212
 213                         i = _documents.erase(i);
 214
 215                         for (MIDINameDocument::MasterDeviceNamesList::const_iterator device =
 216                                  document->master_device_names_by_model().begin();
 217                              device != document->master_device_names_by_model().end();
 218                              ++device) {
 219
 220                                 _master_devices_by_model.erase(device->first);
 221
 222                                 _all_models.erase(device->first);
 223
 224                                 const std::string& manufacturer = device->second->manufacturer();
 225
 226                                 _devices_by_manufacturer[manufacturer].erase(device->first);
 227                         }
 228                         removed = true;
 229                 } else {
 230                         ++i;
 231                 }
 232         }
 233         if (removed) {
 234                 PatchesChanged(); /* EMIT SIGNAL */
 235         }
 236         return removed;
 237 }