//_______________________________________________________________________________
bool xmlreader::endElement (const char* eltName)
{
debug("endElement", eltName);
Sxmlelement top = fStack.top();
fStack.pop();
return top->getName() == eltName;
}
//------------------------------------------------------------------------
// creates a part containing 'count' measures
//------------------------------------------------------------------------
Sxmlelement makePart(int count) {
Sxmlelement part = factory::instance().create(k_part);
part->add (newAttribute("id", kPartID));
for (int i=1; i<=count; i++) // and 'count' times
part->push (makemeasure(i)); // adds a new measure to the part
return part;
}
//------------------------------------------------------------------------
Sxmlelement musicxmlfactory::newrest (int duration, const char* type)
{
Sxmlelement elt = element(k_note);
if (duration) elt->push(element(k_duration, duration));
if (type) elt->push(element(k_type, type));
return elt;
}
//------------------------------------------------------------------------
// the function that creates and writes the score
//------------------------------------------------------------------------
static Sxmlelement randomMusic(int measuresCount) {
Sxmlelement score = factory::instance().create(k_score_partwise);
score->push (newElement(k_movement_title, "Random Music"));
score->push (makeIdentification());
score->push (makePartList());
score->push(makePart(measuresCount)); // adds a part to the score
return score;
}
//------------------------------------------------------------------------
Sxmlelement musicxmlfactory::newdynamics (int type, const char* placement)
{
Sxmlelement dynamics = element (k_dynamics);
if (placement)
dynamics->add (attribute( "placement", placement));
dynamics->push (element(type));
return dynamics;
}
//------------------------------------------------------------------------
Sxmlelement musicxmlfactory::scorepart (const char* id, const char* name, const char* abbrev)
{
Sxmlelement part = element(k_score_part);
part->add (attribute("id", id));
if (name) part->push (element(k_part_name, name));
if (abbrev) part->push (element(k_part_abbreviation, abbrev));
return part;
}
void unrolled_xml_tree_browser::visitStart( Sxmlelement& elt)
{
bool forward = fForward;
if (forward) enter(*elt);
ctree<xmlelement>::literator iter;
for (iter = elt->lbegin(); iter != elt->lend(); iter++)
browse(**iter);
if (forward) leave(*elt);
}
//------------------------------------------------------------------------
Sxmlelement musicxmlfactory::getSubElement (Sxmlelement elt, int type) const
{
vector<Sxmlelement>& subelts = elt->elements();
for (unsigned int i=0; i < subelts.size(); i++) {
if (subelts[i]->getType() == type)
return subelts[i];
}
Sxmlelement sub = element(type);
elt->push (sub);
return sub;
}
//------------------------------------------------------------------------
void musicxmlfactory::encoding(const char* software)
{
Sxmlelement encoding = element (k_encoding);
if (software) encoding->push (element(k_software, software));
string lib = "MusicXML Library version ";
lib += musicxmllibVersionStr();
encoding->push (element(k_software, lib.c_str()));
encoding->push (element (k_encoding_date, timestring()));
fIdentification->push (encoding);
}
//------------------------------------------------------------------------
void musicxmlfactory::header (const char* worknumber, const char* worktitle, const char* movementnumber, const char* movementtitle)
{
if (worknumber || worktitle) {
Sxmlelement work = element(k_work);
if (worknumber) work->push (element(k_work_number, worknumber));
if (worktitle) work->push (element(k_work_title, worktitle));
fRoot->push (work);
}
if (movementnumber) fRoot->push (element(k_movement_number, movementnumber));
if (movementtitle) fRoot->push (element(k_movement_title, movementtitle));
}
//------------------------------------------------------------------------
void musicxmlfactory::addpart (const Sxmlelement& part)
{
switch (part->getType()) {
case k_score_part:
fPartList->push(part);
break;
case k_part:
fRoot->push(part);
break;
default:
cerr << "musicxmlfactory::addpart unexpected type " << part->getType() << endl;
}
}
//------------------------------------------------------------------------
// creates the part list element
//------------------------------------------------------------------------
static Sxmlelement makePartList() {
Sxmlelement partlist = factory::instance().create(k_part_list);
Sxmlelement scorepart = factory::instance().create(k_score_part);
scorepart->add (newAttribute("id", kPartID));
scorepart->push (newElement(k_part_name, "Part name"));
Sxmlelement scoreinstr = factory::instance().create(k_score_instrument);
scoreinstr->add (newAttribute("id", "I1"));
scoreinstr->push (newElement(k_instrument_name, "Any instr."));
scorepart->push (scoreinstr);
partlist->push(scorepart);
return partlist;
}
//------------------------------------------------------------------------
void musicxmlfactory::tie (Sxmlelement start, Sxmlelement stop)
{
Sxmlelement tieStart = element (k_tie);
tieStart->add (attribute ("type", "start"));
start->push (tieStart);
Sxmlelement tiedStart = element (k_tied);
tiedStart->add (attribute ("type", "start"));
addnotation (start, tiedStart);
Sxmlelement tieStop = element (k_tie);
tieStop->add (attribute ("type", "stop"));
stop->push (tieStop);
Sxmlelement tiedStop = element (k_tied);
tiedStop->add (attribute ("type", "stop"));
addnotation (stop, tiedStop);
}
//______________________________________________________________________________
void xml2guidovisitor::addPosition ( Sxmlelement elt, Sguidoelement& tag, int yoffset)
{
float posx = elt->getAttributeFloatValue("default-x", 0) + elt->getAttributeFloatValue("relative-x", 0);
if (posx) {
posx = (posx / 10) * 2; // convert to half spaces
stringstream s;
s << "dx=" << posx << "hs";
tag->add (guidoparam::create(s.str(), false));
}
float posy = elt->getAttributeFloatValue("default-y", 0) + elt->getAttributeFloatValue("relative-y", 0);
if (posy) {
posy = (posy / 10) * 2; // convert to half spaces
posy += yoffset; // anchor point convertion (defaults to upper line in xml)
stringstream s;
s << "dy=" << posy << "hs";
tag->add (guidoparam::create(s.str(), false));
}
}
//_______________________________________________________________________________
static void test3(Sxmlelement elt)
{
cerr << "test3: insert a note before the par notes" << endl;
ctree<xmlelement>::iterator next, iter = elt->begin();
int note=1;
while (iter != elt->end()) {
Sxmlelement xml = *iter;
assert (xml);
if (xml->getType() == k_note) {
if (!(note & 1)) {
Sxmlelement note = factory::instance().create(k_note);
iter = elt->insert(iter, note);
iter++;
}
note++;
}
iter++;
}
}
//------------------------------------------------------------------------
Sxmlelement musicxmlfactory::newnote (const char* step, float alter, int octave, int duration, const char* type)
{
Sxmlelement elt = element(k_note);
Sxmlelement pitch = element(k_pitch);
pitch->push (element (k_step, step));
if (alter) pitch->push (element (k_alter, alter));
pitch->push (element (k_octave, octave));
elt->push(pitch);
if (duration) elt->push(element(k_duration, duration));
if (type) elt->push(element(k_type, type));
return elt;
}
//------------------------------------------------------------------------
static Sxmlelement makeAttributes() {
Sxmlelement attributes = factory::instance().create(k_attributes);
attributes->push (newElementI(k_divisions, kDivision));
Sxmlelement time = factory::instance().create(k_time);
time->push (newElement(k_beats, "4"));
time->push (newElement(k_beat_type, "4"));
attributes->push (time);
Sxmlelement clef = factory::instance().create(k_clef);
clef->push (newElement(k_sign, "G"));
clef->push (newElement(k_line, "2"));
attributes->push (clef);
return attributes;
}
//------------------------------------------------------------------------
void musicxmlfactory::addgroup (int number, const char* name, const char* abbrev, bool groupbarline, vector<Sxmlelement>& parts)
{
Sxmlelement groupStart = element(k_part_group);
groupStart->add (attribute ("number", number));
groupStart->add (attribute ("type", "start"));
if (name) groupStart->push (element(k_group_name, name));
if (abbrev) groupStart->push (element(k_group_abbreviation, abbrev));
if (groupbarline) groupStart->push (element(k_group_barline, "yes"));
fPartList->push (groupStart);
for (vector<Sxmlelement>::const_iterator i = parts.begin(); i != parts.end(); i++)
addpart(*i);
Sxmlelement groupStop = element(k_part_group);
groupStop->add (attribute ("number", number));
groupStop->add (attribute ("type", "stop"));
fPartList->push (groupStop);
}
//------------------------------------------------------------------------
// creates the identification element
//------------------------------------------------------------------------
static Sxmlelement makeIdentification() {
Sxmlelement id = factory::instance().create(k_identification);
Sxmlelement encoding = factory::instance().create(k_encoding);
Sxmlelement creator = newElement(k_creator, "Georg Chance");
creator->add(newAttribute("type", "Composer"));
id->push (creator);
encoding->push (newElement(k_software, "MusicXML Library v2"));
id->push (encoding);
return id;
}
//------------------------------------------------------------------------
void musicxmlfactory::maketuplet(int actual, int normal, const std::vector<Sxmlelement>& notes)
{
if (notes.empty()) return;
Sxmlelement timemod = element(k_time_modification);
timemod->push (element (k_actual_notes, actual));
timemod->push (element (k_normal_notes, normal));
for (unsigned int i=0; i < notes.size(); i++)
notes[i]->push(timemod);
Sxmlelement notations = getNotations (notes[0]);
Sxmlelement tuplet = element (k_tuplet);
tuplet->add (attribute ("type", "start"));
notations->push (tuplet);
notations = getNotations (notes[notes.size()-1]);
tuplet = element (k_tuplet);
tuplet->add (attribute ("type", "stop"));
notations->push (tuplet);
}
//------------------------------------------------------------------------
Sxmlelement musicxmlfactory::newbarline (const char* location, const char* barstyle, const char *repeat)
{
Sxmlelement barline = element (k_barline);
if (location)
barline->add (attribute( "location", location));
if (barstyle)
barline->push (element(k_bar_style, barstyle));
if (repeat) {
Sxmlelement repeatelt = (element(k_repeat));
repeatelt->add (attribute( "direction", repeat));
barline->push (repeatelt);
}
return barline;
}
//_______________________________________________________________________________
static void test1(Sxmlelement elt)
{
cerr << "test1: iterate thru the tree" << endl;
ctree<xmlelement>::iterator iter = elt->begin();
cerr << "=> test1: iterate thru the tree" << endl;
while (iter != elt->end()) {
Sxmlelement xml = *iter;
if (xml)
cerr << " element type " << xml->getType()
<< " - " << xml->getName()
<< " - size: " << xml->size() << endl;
else
cerr << "iterate thru unknown element type " << endl;
iter++;
}
}
//_______________________________________________________________________________
static void test2(Sxmlelement elt)
{
cerr << "test2: erasing all the par measures" << endl;
ctree<xmlelement>::iterator next, iter = elt->begin();
int measure=1;
while (iter != elt->end()) {
Sxmlelement xml = *iter;
next = iter;
next++;
assert (xml);
if (xml->getType() == k_software) {
next = elt->erase(iter);
}
else if (xml->getType() == k_measure) {
if (!(measure & 1)) {
next = elt->erase(iter);
}
measure++;
}
iter = next;
}
}
//------------------------------------------------------------------------
static TElement __retainElt (Sxmlelement elt) { elt->addReference(); return (TElement)elt; }
//------------------------------------------------------------------------
static Sxmlelement newElementI(int type, int value)
{
Sxmlelement elt = factory::instance().create(type);
elt->setValue (value);
return elt;
}
//_______________________________________________________________________________
static void count(Sxmlelement elt, int type)
{
predicate p(type);
cerr << " count of type " << type << " elements: "
<< count_if(elt->begin(), elt->end(), p) << endl;
}
virtual bool operator () (const Sxmlelement elt) const {
return elt->getType() == fType;
}
//_______________________________________________________________________________
void xmlreader::newProcessingInstruction (const char* pi)
{
Sxmlelement elt = factory::instance().create("pi");
elt->setValue(pi);
fStack.top()->push(elt);
}
//_______________________________________________________________________________
void xmlreader::newComment (const char* comment)
{
Sxmlelement elt = factory::instance().create("comment");
elt->setValue(comment);
fStack.top()->push(elt);
}
//------------------------------------------------------------------------
// creates a measure containing random notes
// the function takes the measure number as an argument
//------------------------------------------------------------------------
static Sxmlelement makemeasure(unsigned long num) {
Sxmlelement measure = factory::instance().create(k_measure);
measure->add (newAttributeI("number", num));
if (num==1) { // creates specific elements of the first measure
measure->push(makeAttributes()); // division, time, clef...
}
for (int i = 0; i < 4; i++) { // next adds 4 quarter notes
Sxmlelement note = factory::instance().create(k_note); // creates the note
Sxmlelement pitch = factory::instance().create(k_pitch); // creates a pitch
pitch->push (newElement(k_step, randomNote())); // sets the pitch to a random value
pitch->push (newElementI(k_octave, 4 + getrandom(2))); // sets the octave to a random value
note->push (pitch); // adds the pitch to the note
note->push (newElementI(k_duration, kDivision)); // sets the note duration to a quarter note
note->push (newElement(k_type, "quarter")); // creates the graphic elements of the note
measure->push (note); // and finally adds the note to the measure
}
return measure;
}