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 "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 void
  72 MidiPatchManager::add_midnam_files_from_directory(const std::string& directory_path)
  73 {
  74         vector<std::string> result;
  75         find_files_matching_pattern (result, directory_path, "*.midnam");
  76
  77         info << "Loading " << result.size() << " MIDI patches from " << directory_path
  78              << endmsg;
  79
  80         for (vector<std::string>::const_iterator i = result.begin(); i != result.end(); ++i) {
  81                 add_midi_name_document (*i);
  82         }
  83 }
  84
  85 void
  86 MidiPatchManager::remove_search_path (const Searchpath& search_path)
  87 {
  88         for (Searchpath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
  89
  90                 if (!_search_path.contains(*i)) {
  91                         continue;
  92                 }
  93
  94                 remove_midnam_files_from_directory(*i);
  95
  96                 _search_path.remove_directory (*i);
  97         }
  98 }
  99
 100 void
 101 MidiPatchManager::remove_midnam_files_from_directory(const std::string& directory_path)
 102 {
 103         vector<std::string> result;
 104         find_files_matching_pattern (result, directory_path, "*.midnam");
 105
 106         info << "Unloading " << result.size() << " MIDI patches from "
 107              << directory_path << endmsg;
 108
 109         for (vector<std::string>::const_iterator i = result.begin(); i != result.end(); ++i) {
 110                 remove_midi_name_document (*i);
 111         }
 112 }
 113
 114 bool
 115 MidiPatchManager::add_midi_name_document (const std::string& file_path)
 116 {
 117         boost::shared_ptr<MIDINameDocument> document;
 118         try {
 119                 document = boost::shared_ptr<MIDINameDocument>(new MIDINameDocument(file_path));
 120         }
 121         catch (...) {
 122                 error << "Error parsing MIDI patch file " << file_path << endmsg;
 123                 return false;
 124         }
 125         for (MIDINameDocument::MasterDeviceNamesList::const_iterator device =
 126                  document->master_device_names_by_model().begin();
 127              device != document->master_device_names_by_model().end();
 128              ++device) {
 129                 if (_documents.find(device->first) != _documents.end()) {
 130                         warning << string_compose(_("Duplicate MIDI device `%1' in `%2' ignored"),
 131                                                   device->first,
 132                                                   file_path) << endmsg;
 133                         continue;
 134                 }
 135
 136                 _documents[device->first] = document;
 137                 _master_devices_by_model[device->first] = device->second;
 138
 139                 _all_models.insert(device->first);
 140                 const std::string& manufacturer = device->second->manufacturer();
 141                 if (_devices_by_manufacturer.find(manufacturer) ==
 142                     _devices_by_manufacturer.end()) {
 143                         MIDINameDocument::MasterDeviceNamesList empty;
 144                         _devices_by_manufacturer.insert(std::make_pair(manufacturer, empty));
 145                 }
 146                 _devices_by_manufacturer[manufacturer].insert(
 147                     std::make_pair(device->first, device->second));
 148
 149                 // TODO: handle this gracefully.
 150                 assert(_documents.count(device->first) == 1);
 151                 assert(_master_devices_by_model.count(device->first) == 1);
 152         }
 153         return true;
 154 }
 155
 156 bool
 157 MidiPatchManager::remove_midi_name_document (const std::string& file_path)
 158 {
 159         bool removed = false;
 160         for (MidiNameDocuments::iterator i = _documents.begin(); i != _documents.end();) {
 161                 if (i->second->file_path() == file_path) {
 162
 163                         boost::shared_ptr<MIDINameDocument> document = i->second;
 164
 165                         _documents.erase(i++);
 166
 167                         for (MIDINameDocument::MasterDeviceNamesList::const_iterator device =
 168                                  document->master_device_names_by_model().begin();
 169                              device != document->master_device_names_by_model().end();
 170                              ++device) {
 171
 172                                 _master_devices_by_model.erase(device->first);
 173
 174                                 _all_models.erase(device->first);
 175
 176                                 const std::string& manufacturer = device->second->manufacturer();
 177
 178                                 _devices_by_manufacturer[manufacturer].erase(device->first);
 179                         }
 180                         removed = true;
 181                 } else {
 182                         ++i;
 183                 }
 184         }
 185         return removed;
 186 }