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