libs/midi++2/midnam_patch.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 <algorithm>
  22 #include <iostream>
  23
  24 #include "midi++/midnam_patch.h"
  25 #include "pbd/convert.h"
  26
  27 using namespace std;
  28
  29 namespace MIDI
  30 {
  31
  32 namespace Name
  33 {
  34
  35 XMLNode&
  36 Patch::get_state (void)
  37 {
  38         XMLNode* node = new XMLNode("Patch");
  39         node->add_property("Number", _number);
  40         node->add_property("Name",   _name);
  41         /*
  42         XMLNode* commands = node->add_child("PatchMIDICommands");
  43         for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
  44             event != _patch_midi_commands.end();
  45             ++event) {
  46                 commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
  47         }
  48         */
  49
  50         return *node;
  51 }
  52
  53 void initialize_primary_key_from_commands (PatchPrimaryKey& id, const XMLNode* node)
  54 {
  55         const XMLNodeList events = node->children();
  56         for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
  57                 XMLNode* node = *i;
  58                 if (node->name() == "ControlChange") {
  59                         string control = node->property("Control")->value();
  60                         assert(control != "");
  61                         string value = node->property("Value")->value();
  62                         assert(value != "");
  63
  64                         if (control == "0") {
  65                                 id.msb = PBD::atoi(value);
  66                         } else if (control == "32") {
  67                                 id.lsb = PBD::atoi(value);
  68                         }
  69                 } else if (node->name() == "ProgramChange") {
  70                         string number = node->property("Number")->value();
  71                         assert(number != "");
  72                         id.program_number = PBD::atoi(number);
  73                 }
  74         }
  75 }
  76
  77
  78 int
  79 Patch::set_state (const XMLNode& node)
  80 {
  81         assert(node.name() == "Patch");
  82         _number = node.property("Number")->value();
  83         _name   = node.property("Name")->value();
  84         XMLNode* commands = node.child("PatchMIDICommands");
  85
  86         if (commands) {
  87                 initialize_primary_key_from_commands(_id, commands);
  88         } else {
  89                 string program_change = node.property("ProgramChange")->value();
  90                 assert(program_change.length());
  91                 assert(_bank);
  92                 assert(_bank->patch_primary_key());
  93                 if ( _bank && _bank->patch_primary_key() ) {
  94                         _id.msb = _bank->patch_primary_key()->msb;
  95                         _id.lsb = _bank->patch_primary_key()->lsb;
  96                         _id.program_number = PBD::atoi(program_change);
  97                 }
  98         }
  99
 100         cerr << "deserialized Patch: name: " <<  _name << " msb: " << _id.msb << " lsb: " << _id.lsb << " program " << _id.program_number << endl;
 101         // TODO: handle that more gracefully
 102         assert(_id.is_sane());
 103
 104         return 0;
 105 }
 106
 107 XMLNode&
 108 Note::get_state (void)
 109 {
 110         XMLNode* node = new XMLNode("Note");
 111         node->add_property("Number", _number);
 112         node->add_property("Name",   _name);
 113
 114         return *node;
 115 }
 116
 117 int
 118 Note::set_state (const XMLNode& node)
 119 {
 120         assert(node.name() == "Note");
 121         _number = node.property("Number")->value();
 122         _name   = node.property("Name")->value();
 123
 124         return 0;
 125 }
 126
 127 XMLNode&
 128 NoteNameList::get_state (void)
 129 {
 130         XMLNode* node = new XMLNode("NoteNameList");
 131         node->add_property("Name",   _name);
 132
 133         return *node;
 134 }
 135
 136 int
 137 NoteNameList::set_state (const XMLNode& node)
 138 {
 139         assert(node.name() == "NoteNameList");
 140         _name   = node.property("Name")->value();
 141
 142         boost::shared_ptr<XMLSharedNodeList> notes =
 143                                         node.find("//Note");
 144         for (XMLSharedNodeList::const_iterator i = notes->begin(); i != notes->end(); ++i) {
 145                 boost::shared_ptr<Note> note(new Note());
 146                 note->set_state(*(*i));
 147                 _notes.push_back(note);
 148         }
 149
 150         return 0;
 151 }
 152
 153
 154 XMLNode&
 155 PatchBank::get_state (void)
 156 {
 157         XMLNode* node = new XMLNode("PatchBank");
 158         node->add_property("Name",   _name);
 159         XMLNode* patch_name_list = node->add_child("PatchNameList");
 160         for (PatchNameList::iterator patch = _patch_name_list.begin();
 161             patch != _patch_name_list.end();
 162             ++patch) {
 163                 patch_name_list->add_child_nocopy((*patch)->get_state());
 164         }
 165
 166         return *node;
 167 }
 168
 169 int
 170 PatchBank::set_state (const XMLNode& node)
 171 {
 172         assert(node.name() == "PatchBank");
 173         _name   = node.property("Name")->value();
 174
 175         XMLNode* commands = node.child("MIDICommands");
 176         if (commands) {
 177                 _id = new PatchPrimaryKey();
 178                 initialize_primary_key_from_commands(*_id, commands);
 179         }
 180
 181         XMLNode* patch_name_list = node.child("PatchNameList");
 182         assert(patch_name_list);
 183         const XMLNodeList patches = patch_name_list->children();
 184         for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
 185                 boost::shared_ptr<Patch> patch(new Patch(this));
 186                 patch->set_state(*(*i));
 187                 _patch_name_list.push_back(patch);
 188         }
 189
 190         return 0;
 191 }
 192
 193 XMLNode&
 194 ChannelNameSet::get_state (void)
 195 {
 196         XMLNode* node = new XMLNode("ChannelNameSet");
 197         node->add_property("Name",   _name);
 198
 199         XMLNode* available_for_channels = node->add_child("AvailableForChannels");
 200         assert(available_for_channels);
 201
 202         for (uint8_t channel = 0; channel < 16; ++channel) {
 203                 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
 204                 assert(available_channel);
 205
 206                 available_channel->add_property("Channel", (long) channel);
 207
 208                 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
 209                         available_channel->add_property("Available", "true");
 210                 } else {
 211                         available_channel->add_property("Available", "false");
 212                 }
 213         }
 214
 215         for (PatchBanks::iterator patch_bank = _patch_banks.begin();
 216             patch_bank != _patch_banks.end();
 217             ++patch_bank) {
 218                 node->add_child_nocopy((*patch_bank)->get_state());
 219         }
 220
 221         return *node;
 222 }
 223
 224 int
 225 ChannelNameSet::set_state (const XMLNode& node)
 226 {
 227         assert(node.name() == "ChannelNameSet");
 228         _name   = node.property("Name")->value();
 229         // cerr << "ChannelNameSet _name: " << _name << endl;
 230         const XMLNodeList children = node.children();
 231         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
 232                 XMLNode* node = *i;
 233                 assert(node);
 234                 if (node->name() == "AvailableForChannels") {
 235                         // cerr << "AvailableForChannels" << endl;
 236                         boost::shared_ptr<XMLSharedNodeList> channels =
 237                                 node->find("//AvailableChannel[@Available = 'true']/@Channel");
 238                         // cerr << "AvailableForChannels after find" << endl;
 239                         for(XMLSharedNodeList::const_iterator i = channels->begin();
 240                             i != channels->end();
 241                             ++i) {
 242                                 // cerr << "AvailableForChannels before insert" << endl;
 243                                 _available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
 244                                 // cerr << "AvailableForChannels after insert" << endl;
 245                         }
 246                 }
 247
 248                 // cerr << "before PatchBank" << endl;
 249
 250                 if (node->name() == "PatchBank") {
 251                         // cerr << "got PatchBank" << endl;
 252                         boost::shared_ptr<PatchBank> bank(new PatchBank());
 253                         bank->set_state(*node);
 254                         _patch_banks.push_back(bank);
 255                         const PatchBank::PatchNameList& patches = bank->patch_name_list();
 256                         for (PatchBank::PatchNameList::const_iterator patch = patches.begin();
 257                              patch != patches.end();
 258                              ++patch) {
 259                                 _patch_map[(*patch)->patch_primary_key()] = *patch;
 260                                 _patch_list.push_back((*patch)->patch_primary_key());
 261                         }
 262                         // cerr << "after PatchBank pushback" << endl;
 263                 }
 264         }
 265
 266         // cerr << "ChannelnameSet done" << endl;
 267
 268         return 0;
 269 }
 270
 271 int
 272 CustomDeviceMode::set_state(const XMLNode& a_node)
 273 {
 274         assert(a_node.name() == "CustomDeviceMode");
 275
 276         _name = a_node.property("Name")->value();
 277
 278         boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
 279                 a_node.find("//ChannelNameSetAssign");
 280         for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
 281             i != channel_name_set_assignments->end();
 282             ++i) {
 283                 int channel = atoi((*i)->property("Channel")->value().c_str());
 284                 string name_set = (*i)->property("NameSet")->value();
 285                 assert( 1 <= channel && channel <= 16 );
 286                 _channel_name_set_assignments[channel - 1] = name_set;
 287         }
 288         return 0;
 289 }
 290
 291 XMLNode&
 292 CustomDeviceMode::get_state(void)
 293 {
 294         XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
 295         custom_device_mode->add_property("Name",   _name);
 296         XMLNode* channel_name_set_assignments =
 297                 custom_device_mode->add_child("ChannelNameSetAssignments");
 298         for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
 299                 XMLNode* channel_name_set_assign =
 300                         channel_name_set_assignments->add_child("ChannelNameSetAssign");
 301                 channel_name_set_assign->add_property("Channel", i + 1);
 302                 channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
 303         }
 304
 305         return *custom_device_mode;
 306 }
 307
 308 int
 309 MasterDeviceNames::set_state(const XMLNode& a_node)
 310 {
 311         // cerr << "MasterDeviceNames::set_state Manufacturer" << endl;
 312         // Manufacturer
 313         boost::shared_ptr<XMLSharedNodeList> manufacturer = a_node.find("//Manufacturer");
 314         assert(manufacturer->size() == 1);
 315         _manufacturer = manufacturer->front()->content();
 316
 317         // cerr << "MasterDeviceNames::set_state models" << endl;
 318         // Models
 319         boost::shared_ptr<XMLSharedNodeList> models = a_node.find("//Model");
 320         assert(models->size() >= 1);
 321         for (XMLSharedNodeList::iterator i = models->begin();
 322              i != models->end();
 323              ++i) {
 324                 const XMLNodeList& contents = (*i)->children();
 325                 assert(contents.size() == 1);
 326                 XMLNode * content = *(contents.begin());
 327                 assert(content->is_content());
 328                 _models.push_back(content->content());
 329         }
 330
 331         // cerr << "MasterDeviceNames::set_state CustomDeviceModes" << endl;
 332         // CustomDeviceModes
 333         boost::shared_ptr<XMLSharedNodeList> custom_device_modes = a_node.find("//CustomDeviceMode");
 334         for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
 335              i != custom_device_modes->end();
 336              ++i) {
 337                 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
 338                 custom_device_mode->set_state(*(*i));
 339
 340                 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
 341                 _custom_device_mode_names.push_back(custom_device_mode->name());
 342         }
 343
 344         // cerr << "MasterDeviceNames::set_state ChannelNameSets" << endl;
 345         // ChannelNameSets
 346         boost::shared_ptr<XMLSharedNodeList> channel_name_sets = a_node.find("//ChannelNameSet");
 347         for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
 348              i != channel_name_sets->end();
 349              ++i) {
 350                 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
 351                 // cerr << "MasterDeviceNames::set_state ChannelNameSet before set_state" << endl;
 352                 channel_name_set->set_state(*(*i));
 353                 _channel_name_sets[channel_name_set->name()] = channel_name_set;
 354         }
 355
 356         // cerr << "MasterDeviceNames::set_state NoteNameLists" << endl;
 357         // NoteNameLists
 358         boost::shared_ptr<XMLSharedNodeList> note_name_lists = a_node.find("//NoteNameList");
 359         for (XMLSharedNodeList::iterator i = note_name_lists->begin();
 360              i != note_name_lists->end();
 361              ++i) {
 362                 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
 363                 note_name_list->set_state(*(*i));
 364                 _note_name_lists.push_back(note_name_list);
 365         }
 366
 367         return 0;
 368 }
 369
 370 XMLNode&
 371 MasterDeviceNames::get_state(void)
 372 {
 373         static XMLNode nothing("<nothing>");
 374         return nothing;
 375 }
 376
 377 int
 378 MIDINameDocument::set_state(const XMLNode& a_node)
 379 {
 380         // Author
 381         boost::shared_ptr<XMLSharedNodeList> author = a_node.find("//Author");
 382         assert(author->size() == 1);
 383         _author = author->front()->content();
 384
 385         // cerr << "MIDINameDocument::set_state befor masterdevicenames" << endl;
 386         // MasterDeviceNames
 387         boost::shared_ptr<XMLSharedNodeList> master_device_names_list = a_node.find("//MasterDeviceNames");
 388         for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
 389              i != master_device_names_list->end();
 390              ++i) {
 391                 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
 392                 // cerr << "MIDINameDocument::set_state before masterdevicenames->set_state" << endl;
 393                 master_device_names->set_state(*(*i));
 394                 // cerr << "MIDINameDocument::set_state after masterdevicenames->set_state" << endl;
 395
 396                 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
 397                      model != master_device_names->models().end();
 398                      ++model) {
 399                         // cerr << "MIDINameDocument::set_state inserting model " << *model << endl;
 400                                 _master_device_names_list.insert(
 401                                                 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
 402                                                          (*model,      master_device_names));
 403
 404                                 _all_models.push_back(*model);
 405                 }
 406         }
 407
 408         return 0;
 409 }
 410
 411 XMLNode&
 412 MIDINameDocument::get_state(void)
 413 {
 414         static XMLNode nothing("<nothing>");
 415         return nothing;
 416 }
 417
 418
 419 } //namespace Name
 420
 421 } //namespace MIDI
 422