2008-12-08 04:50:19 -05:00
|
|
|
/*
|
|
|
|
Copyright (C) 2008 Hans Baier
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
|
|
|
|
$Id$
|
|
|
|
*/
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
#include "midi++/midnam_patch.h"
|
|
|
|
#include <algorithm>
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
#include <iostream>
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
namespace MIDI
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace Name
|
|
|
|
{
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
XMLNode&
|
2008-06-02 17:41:35 -04:00
|
|
|
Patch::get_state (void)
|
|
|
|
{
|
|
|
|
XMLNode* node = new XMLNode("Patch");
|
|
|
|
node->add_property("Number", _number);
|
|
|
|
node->add_property("Name", _name);
|
|
|
|
XMLNode* commands = node->add_child("PatchMIDICommands");
|
2008-08-04 18:37:24 -04:00
|
|
|
for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
|
2008-06-02 17:41:35 -04:00
|
|
|
event != _patch_midi_commands.end();
|
|
|
|
++event) {
|
2008-09-22 12:28:02 -04:00
|
|
|
commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return *node;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
Patch::set_state (const XMLNode& node)
|
|
|
|
{
|
|
|
|
assert(node.name() == "Patch");
|
|
|
|
_number = node.property("Number")->value();
|
|
|
|
_name = node.property("Name")->value();
|
|
|
|
XMLNode* commands = node.child("PatchMIDICommands");
|
|
|
|
assert(commands);
|
|
|
|
const XMLNodeList events = commands->children();
|
|
|
|
for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
|
2008-09-22 12:28:02 -04:00
|
|
|
_patch_midi_commands.push_back(*(new Evoral::MIDIEvent(*(*i))));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-05 19:07:07 -05:00
|
|
|
XMLNode&
|
|
|
|
Note::get_state (void)
|
|
|
|
{
|
2008-12-05 23:38:44 -05:00
|
|
|
XMLNode* node = new XMLNode("Note");
|
2008-12-05 19:07:07 -05:00
|
|
|
node->add_property("Number", _number);
|
|
|
|
node->add_property("Name", _name);
|
|
|
|
|
|
|
|
return *node;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
Note::set_state (const XMLNode& node)
|
|
|
|
{
|
2008-12-05 23:38:44 -05:00
|
|
|
assert(node.name() == "Note");
|
2008-12-05 19:07:07 -05:00
|
|
|
_number = node.property("Number")->value();
|
|
|
|
_name = node.property("Name")->value();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-05 23:38:44 -05:00
|
|
|
XMLNode&
|
|
|
|
NoteNameList::get_state (void)
|
|
|
|
{
|
|
|
|
XMLNode* node = new XMLNode("NoteNameList");
|
|
|
|
node->add_property("Name", _name);
|
|
|
|
|
|
|
|
return *node;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
NoteNameList::set_state (const XMLNode& node)
|
|
|
|
{
|
|
|
|
assert(node.name() == "NoteNameList");
|
|
|
|
_name = node.property("Name")->value();
|
|
|
|
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> notes =
|
|
|
|
node.find("//Note");
|
|
|
|
for (XMLSharedNodeList::const_iterator i = notes->begin(); i != notes->end(); ++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
Note* note = new Note();
|
|
|
|
note->set_state(*(*i));
|
|
|
|
_notes.push_back(*note);
|
2008-12-05 23:38:44 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
XMLNode&
|
2008-06-02 17:41:35 -04:00
|
|
|
PatchBank::get_state (void)
|
|
|
|
{
|
|
|
|
XMLNode* node = new XMLNode("PatchBank");
|
|
|
|
node->add_property("Name", _name);
|
|
|
|
XMLNode* patch_name_list = node->add_child("PatchNameList");
|
2008-08-04 18:37:24 -04:00
|
|
|
for (PatchNameList::iterator patch = _patch_name_list.begin();
|
2008-06-02 17:41:35 -04:00
|
|
|
patch != _patch_name_list.end();
|
|
|
|
++patch) {
|
|
|
|
patch_name_list->add_child_nocopy(patch->get_state());
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return *node;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
PatchBank::set_state (const XMLNode& node)
|
|
|
|
{
|
|
|
|
assert(node.name() == "PatchBank");
|
|
|
|
_name = node.property("Name")->value();
|
|
|
|
XMLNode* patch_name_list = node.child("PatchNameList");
|
|
|
|
assert(patch_name_list);
|
|
|
|
const XMLNodeList patches = patch_name_list->children();
|
|
|
|
for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
Patch* patch = new Patch();
|
|
|
|
patch->set_state(*(*i));
|
|
|
|
_patch_name_list.push_back(*patch);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
XMLNode&
|
2008-06-02 17:41:35 -04:00
|
|
|
ChannelNameSet::get_state (void)
|
|
|
|
{
|
|
|
|
XMLNode* node = new XMLNode("ChannelNameSet");
|
|
|
|
node->add_property("Name", _name);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
XMLNode* available_for_channels = node->add_child("AvailableForChannels");
|
|
|
|
assert(available_for_channels);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
for (uint8_t channel = 0; channel < 16; ++channel) {
|
|
|
|
XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
|
|
|
|
assert(available_channel);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
available_channel->add_property("Channel", (long) channel);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (_available_for_channels.find(channel) != _available_for_channels.end()) {
|
2008-08-04 18:37:24 -04:00
|
|
|
available_channel->add_property("Available", "true");
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
2008-08-04 18:37:24 -04:00
|
|
|
available_channel->add_property("Available", "false");
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
|
|
|
for (PatchBanks::iterator patch_bank = _patch_banks.begin();
|
2008-06-02 17:41:35 -04:00
|
|
|
patch_bank != _patch_banks.end();
|
|
|
|
++patch_bank) {
|
|
|
|
node->add_child_nocopy(patch_bank->get_state());
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return *node;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ChannelNameSet::set_state (const XMLNode& node)
|
|
|
|
{
|
|
|
|
assert(node.name() == "ChannelNameSet");
|
|
|
|
_name = node.property("Name")->value();
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "ChannelNameSet _name: " << _name << endl;
|
2008-06-02 17:41:35 -04:00
|
|
|
const XMLNodeList children = node.children();
|
|
|
|
for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
|
|
|
|
XMLNode* node = *i;
|
|
|
|
assert(node);
|
|
|
|
if (node->name() == "AvailableForChannels") {
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "AvailableForChannels" << endl;
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<XMLSharedNodeList> channels =
|
|
|
|
node->find("//AvailableChannel[@Available = 'true']/@Channel");
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "AvailableForChannels after find" << endl;
|
2008-06-02 17:41:35 -04:00
|
|
|
for(XMLSharedNodeList::const_iterator i = channels->begin();
|
|
|
|
i != channels->end();
|
|
|
|
++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "AvailableForChannels before insert" << endl;
|
2008-06-02 17:41:35 -04:00
|
|
|
_available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "AvailableForChannels after insert" << endl;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
2008-12-09 02:42:19 -05:00
|
|
|
|
|
|
|
// cerr << "before PatchBank" << endl;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (node->name() == "PatchBank") {
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "got PatchBank" << endl;
|
|
|
|
PatchBank* bank = new PatchBank();
|
|
|
|
bank->set_state(*node);
|
|
|
|
_patch_banks.push_back(*bank);
|
|
|
|
// cerr << "after PatchBank pushback" << endl;
|
2008-08-04 18:37:24 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2008-12-09 02:42:19 -05:00
|
|
|
|
|
|
|
// cerr << "ChannelnameSet done" << endl;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-23 14:42:09 -05:00
|
|
|
int
|
|
|
|
CustomDeviceMode::set_state(const XMLNode& a_node)
|
|
|
|
{
|
2008-12-09 02:42:19 -05:00
|
|
|
assert(a_node.name() == "CustomDeviceMode");
|
2008-11-23 14:42:09 -05:00
|
|
|
boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
|
|
|
|
a_node.find("//ChannelNameSetAssign");
|
|
|
|
for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
|
|
|
|
i != channel_name_set_assignments->end();
|
|
|
|
++i) {
|
|
|
|
int channel = atoi((*i)->property("Channel")->value().c_str());
|
|
|
|
string name_set = (*i)->property("NameSet")->value();
|
|
|
|
assert( 1 <= channel && channel <= 16 );
|
|
|
|
_channel_name_set_assignments[channel -1] = name_set;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNode&
|
|
|
|
CustomDeviceMode::get_state(void)
|
|
|
|
{
|
|
|
|
XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
|
|
|
|
custom_device_mode->add_property("Name", _name);
|
|
|
|
XMLNode* channel_name_set_assignments =
|
|
|
|
custom_device_mode->add_child("ChannelNameSetAssignments");
|
|
|
|
for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
|
|
|
|
XMLNode* channel_name_set_assign =
|
|
|
|
channel_name_set_assignments->add_child("ChannelNameSetAssign");
|
|
|
|
channel_name_set_assign->add_property("Channel", i + 1);
|
|
|
|
channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return *custom_device_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MasterDeviceNames::set_state(const XMLNode& a_node)
|
|
|
|
{
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "MasterDeviceNames::set_state Manufacturer" << endl;
|
2008-12-05 23:38:44 -05:00
|
|
|
// Manufacturer
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> manufacturer = a_node.find("//Manufacturer");
|
|
|
|
assert(manufacturer->size() == 1);
|
|
|
|
_manufacturer = manufacturer->front()->content();
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "MasterDeviceNames::set_state models" << endl;
|
2008-12-05 23:38:44 -05:00
|
|
|
// Models
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> models = a_node.find("//Model");
|
|
|
|
assert(models->size() >= 1);
|
|
|
|
for (XMLSharedNodeList::iterator i = models->begin();
|
|
|
|
i != models->end();
|
|
|
|
++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
const XMLNodeList& contents = (*i)->children();
|
|
|
|
assert(contents.size() == 1);
|
|
|
|
XMLNode * content = *(contents.begin());
|
|
|
|
assert(content->is_content());
|
|
|
|
_models.push_back(content->content());
|
2008-12-05 23:38:44 -05:00
|
|
|
}
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "MasterDeviceNames::set_state CustomDeviceModes" << endl;
|
2008-12-05 23:38:44 -05:00
|
|
|
// CustomDeviceModes
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> custom_device_modes = a_node.find("//CustomDeviceMode");
|
|
|
|
for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
|
|
|
|
i != custom_device_modes->end();
|
|
|
|
++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
CustomDeviceMode* custom_device_mode = new CustomDeviceMode();
|
|
|
|
custom_device_mode->set_state(*(*i));
|
|
|
|
_custom_device_modes.push_back(*custom_device_mode);
|
2008-12-05 23:38:44 -05:00
|
|
|
}
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "MasterDeviceNames::set_state ChannelNameSets" << endl;
|
2008-12-05 23:38:44 -05:00
|
|
|
// ChannelNameSets
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> channel_name_sets = a_node.find("//ChannelNameSet");
|
|
|
|
for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
|
|
|
|
i != channel_name_sets->end();
|
|
|
|
++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
ChannelNameSet* channel_name_set = new ChannelNameSet();
|
|
|
|
// cerr << "MasterDeviceNames::set_state ChannelNameSet before set_state" << endl;
|
|
|
|
channel_name_set->set_state(*(*i));
|
|
|
|
_channel_name_sets.push_back(*channel_name_set);
|
2008-12-05 23:38:44 -05:00
|
|
|
}
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "MasterDeviceNames::set_state NoteNameLists" << endl;
|
2008-12-05 23:38:44 -05:00
|
|
|
// NoteNameLists
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> note_name_lists = a_node.find("//NoteNameList");
|
|
|
|
for (XMLSharedNodeList::iterator i = note_name_lists->begin();
|
|
|
|
i != note_name_lists->end();
|
|
|
|
++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
NoteNameList* note_name_list = new NoteNameList();
|
|
|
|
note_name_list->set_state(*(*i));
|
|
|
|
_note_name_lists.push_back(*note_name_list);
|
2008-12-05 23:38:44 -05:00
|
|
|
}
|
|
|
|
|
2008-11-23 14:42:09 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNode&
|
|
|
|
MasterDeviceNames::get_state(void)
|
|
|
|
{
|
|
|
|
static XMLNode nothing("<nothing>");
|
|
|
|
return nothing;
|
|
|
|
}
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
int
|
2008-09-18 20:47:49 -04:00
|
|
|
MIDINameDocument::set_state(const XMLNode& a_node)
|
2008-08-04 18:37:24 -04:00
|
|
|
{
|
2008-12-06 00:00:20 -05:00
|
|
|
// Author
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> author = a_node.find("//Author");
|
|
|
|
assert(author->size() == 1);
|
|
|
|
_author = author->front()->content();
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
// cerr << "MIDINameDocument::set_state befor masterdevicenames" << endl;
|
2008-12-06 00:00:20 -05:00
|
|
|
// MasterDeviceNames
|
|
|
|
boost::shared_ptr<XMLSharedNodeList> master_device_names_list = a_node.find("//MasterDeviceNames");
|
|
|
|
for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
|
|
|
|
i != master_device_names_list->end();
|
|
|
|
++i) {
|
2008-12-09 02:42:19 -05:00
|
|
|
boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
|
|
|
|
// cerr << "MIDINameDocument::set_state before masterdevicenames->set_state" << endl;
|
|
|
|
master_device_names->set_state(*(*i));
|
|
|
|
// cerr << "MIDINameDocument::set_state after masterdevicenames->set_state" << endl;
|
|
|
|
|
|
|
|
for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
|
|
|
|
model != master_device_names->models().end();
|
|
|
|
++model) {
|
|
|
|
// cerr << "MIDINameDocument::set_state inserting model " << *model << endl;
|
|
|
|
_master_device_names_list.insert(
|
|
|
|
std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
|
|
|
|
(*model, master_device_names));
|
|
|
|
|
|
|
|
_all_models.push_back(*model);
|
|
|
|
}
|
2008-12-06 00:00:20 -05:00
|
|
|
}
|
|
|
|
|
2008-09-18 20:47:49 -04:00
|
|
|
return 0;
|
2008-08-04 18:37:24 -04:00
|
|
|
}
|
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
/*
|
|
|
|
const MasterDeviceNames::Models&
|
|
|
|
MIDINameDocument::models(void)
|
|
|
|
{
|
|
|
|
;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
XMLNode&
|
|
|
|
MIDINameDocument::get_state(void)
|
|
|
|
{
|
2008-09-18 20:47:49 -04:00
|
|
|
static XMLNode nothing("<nothing>");
|
|
|
|
return nothing;
|
2008-08-04 18:37:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
} //namespace Name
|
|
|
|
|
|
|
|
} //namespace MIDI
|
|
|
|
|