libs/midi++2/midnam_patch.cc

   1 #include "midi++/midnam_patch.h"
   2 #include <algorithm>
   3
   4 namespace MIDI
   5 {
   6
   7 namespace Name
   8 {
   9
  10 XMLNode&
  11 Patch::get_state (void)
  12 {
  13         XMLNode* node = new XMLNode("Patch");
  14         node->add_property("Number", _number);
  15         node->add_property("Name",   _name);
  16         XMLNode* commands = node->add_child("PatchMIDICommands");
  17         for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
  18             event != _patch_midi_commands.end();
  19             ++event) {
  20                 commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
  21         }
  22
  23         return *node;
  24 }
  25
  26 int
  27 Patch::set_state (const XMLNode& node)
  28 {
  29         assert(node.name() == "Patch");
  30         _number = node.property("Number")->value();
  31         _name   = node.property("Name")->value();
  32         XMLNode* commands = node.child("PatchMIDICommands");
  33         assert(commands);
  34         const XMLNodeList events = commands->children();
  35         for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
  36                 _patch_midi_commands.push_back(*(new Evoral::MIDIEvent(*(*i))));
  37         }
  38
  39         return 0;
  40 }
  41
  42 XMLNode&
  43 PatchBank::get_state (void)
  44 {
  45         XMLNode* node = new XMLNode("PatchBank");
  46         node->add_property("Name",   _name);
  47         XMLNode* patch_name_list = node->add_child("PatchNameList");
  48         for (PatchNameList::iterator patch = _patch_name_list.begin();
  49             patch != _patch_name_list.end();
  50             ++patch) {
  51                 patch_name_list->add_child_nocopy(patch->get_state());
  52         }
  53
  54         return *node;
  55 }
  56
  57 int
  58 PatchBank::set_state (const XMLNode& node)
  59 {
  60         assert(node.name() == "PatchBank");
  61         _name   = node.property("Name")->value();
  62         XMLNode* patch_name_list = node.child("PatchNameList");
  63         assert(patch_name_list);
  64         const XMLNodeList patches = patch_name_list->children();
  65         for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
  66                 Patch patch;
  67                 patch.set_state(*(*i));
  68                 _patch_name_list.push_back(patch);
  69         }
  70
  71         return 0;
  72 }
  73
  74 XMLNode&
  75 ChannelNameSet::get_state (void)
  76 {
  77         XMLNode* node = new XMLNode("ChannelNameSet");
  78         node->add_property("Name",   _name);
  79
  80         XMLNode* available_for_channels = node->add_child("AvailableForChannels");
  81         assert(available_for_channels);
  82
  83         for (uint8_t channel = 0; channel < 16; ++channel) {
  84                 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
  85                 assert(available_channel);
  86
  87                 available_channel->add_property("Channel", (long) channel);
  88
  89                 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
  90                         available_channel->add_property("Available", "true");
  91                 } else {
  92                         available_channel->add_property("Available", "false");
  93                 }
  94         }
  95
  96         for (PatchBanks::iterator patch_bank = _patch_banks.begin();
  97             patch_bank != _patch_banks.end();
  98             ++patch_bank) {
  99                 node->add_child_nocopy(patch_bank->get_state());
 100         }
 101
 102         return *node;
 103 }
 104
 105 int
 106 ChannelNameSet::set_state (const XMLNode& node)
 107 {
 108         assert(node.name() == "ChannelNameSet");
 109         _name   = node.property("Name")->value();
 110         const XMLNodeList children = node.children();
 111         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
 112                 XMLNode* node = *i;
 113                 assert(node);
 114                 if (node->name() == "AvailableForChannels") {
 115                         boost::shared_ptr<XMLSharedNodeList> channels =
 116                                 node->find("//AvailableChannel[@Available = 'true']/@Channel");
 117                         for(XMLSharedNodeList::const_iterator i = channels->begin();
 118                             i != channels->end();
 119                             ++i) {
 120                                 _available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
 121                         }
 122                 }
 123
 124                 if (node->name() == "PatchBank") {
 125                         PatchBank bank;
 126                         bank.set_state(*node);
 127                         _patch_banks.push_back(bank);
 128                 }
 129         }
 130
 131         return 0;
 132 }
 133
 134 int
 135 MIDINameDocument::set_state(const XMLNode& a_node)
 136 {
 137         return 0;
 138 }
 139
 140 XMLNode&
 141 MIDINameDocument::get_state(void)
 142 {
 143         static XMLNode nothing("<nothing>");
 144         return nothing;
 145 }
 146
 147
 148 } //namespace Name
 149
 150 } //namespace MIDI
 151