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