verovio-doxygen/html/iomei_8h_source.html

 // Name:        iomei.h

 // Author:      Laurent Pugin

 // Created:     2011

 // Copyright (c) Authors and others. All rights reserved.


 #ifndef __VRV_IOMEI_H__

 #define __VRV_IOMEI_H__


 #include <sstream>

 #include <stack>


 //----------------------------------------------------------------------------


 #include "doc.h"

 #include "iobase.h"


 //----------------------------------------------------------------------------


 #include "pugixml.hpp"


 namespace vrv {


 class Abbr;

 class Accid;

 class Add;

 class AltSymInterface;

 class AnchoredText;

 class Annot;

 class AnnotScore;

 class App;

 class AreaPosInterface;

 class Arpeg;

 class Artic;

 class BarLine;

 class Beam;

 class BeamSpan;

 class BeatRpt;

 class BracketSpan;

 class Breath;

 class BTrem;

 class Caesura;

 class Choice;

 class Chord;

 class Clef;

 class ControlElement;

 class Corr;

 class Course;

 class CpMark;

 class Custos;

 class Damage;

 class Del;

 class Dot;

 class Dir;

 class Div;

 class DivLine;

 class DurationInterface;

 class Dynam;

 class Ending;

 class Episema;

 class Expan;

 class Expansion;

 class F;

 class Fb;

 class Fig;

 class Fing;

 class Fermata;

 class FloatingElement;

 class FTrem;

 class GenericLayerElement;

 class Gliss;

 class GraceGrp;

 class Graphic;

 class GrpSym;

 class Hairpin;

 class HalfmRpt;

 class Harm;

 class KeyAccid;

 class KeySig;

 class LinkingInterface;

 class InstrDef;

 class Label;

 class LabelAbbr;

 class Layer;

 class LayerDef;

 class LayerElement;

 class Lb;

 class Lem;

 class Ligature;

 class Liquescent;

 class Lv;

 class Mdiv;

 class Measure;

 class Mensur;

 class MeterSig;

 class MeterSigGrp;

 class MNum;

 class Mordent;

 class MRest;

 class MRpt;

 class MRpt2;

 class MSpace;

 class MultiRest;

 class MultiRpt;

 class Nc;

 class Neume;

 class Note;

 class Num;

 class Octave;

 class OffsetInterface;

 class OffsetSpanningInterface;

 class Orig;

 class Oriscus;

 class Ornam;

 class Ossia;

 class Page;

 class PageElement;

 class PageMilestoneEnd;

 class Pages;

 class Pb;

 class Pedal;

 class PgFoot;

 class PgHead;

 class Phrase;

 class PitchInflection;

 class PitchInterface;

 class Plica;

 class PlistInterface;

 class PositionInterface;

 class Proport;

 class Quilisma;

 class Rdg;

 class Ref;

 class Reg;

 class Reh;

 class Rend;

 class RepeatMark;

 class Rest;

 class Restore;

 class Refrain;

 class RunningElement;

 class Score;

 class ScoreDef;

 class ScoreDefElement;

 class ScoreDefInterface;

 class Sb;

 class Section;

 class Sic;

 class Slur;

 class Space;

 class Staff;

 class Stem;

 class Strophicus;

 class Subst;

 class Supplied;

 class Surface;

 class Svg;

 class Syl;

 class Syllable;

 class Symbol;

 class SymbolDef;

 class SymbolTable;

 class System;

 class SystemElement;

 class SystemMilestoneEnd;

 class TabDurSym;

 class TabGrp;

 class Tempo;

 class Text;

 class TextDirInterface;

 class TextElement;

 class TextLayoutElement;

 class Tie;

 class TimePointInterface;

 class TimeSpanningInterface;

 class Trill;

 class Tuning;

 class Turn;

 class Tuplet;

 class Unclear;

 class Volta;

 class Verse;

 class LyricElement;

 class Zone;


 // Helper enums

 enum class MatchLocation { Before, Here, After };

 enum class RangeMatchLocation { BeforeStart, AtStart, BetweenStartEnd, AtEnd, AfterEnd };


 //----------------------------------------------------------------------------

 // MEIOutput

 //----------------------------------------------------------------------------


 class MEIOutput : public Output {

 public:

     MEIOutput(Doc *doc);

     virtual ~MEIOutput();


     std::string Export() override;


     bool Skip(Object *object) const override;


     bool WriteObject(Object *object) override;

     bool WriteObjectEnd(Object *object) override;


     void SetScoreBasedMEI(bool scoreBasedMEI) { m_scoreBasedMEI = scoreBasedMEI; }


     void SetBasic(bool basic) { m_basic = basic; }

     bool GetBasic() const { return m_basic; }


     bool HasFilter() const;

     void SetFirstPage(int page);

     void SetLastPage(int page);

     void SetFirstMeasure(const std::string &id);

     void SetLastMeasure(const std::string &id);

     void SetMdiv(const std::string &id);

     void ResetFilter();


     bool IsScoreBasedMEI() const { return m_scoreBasedMEI; }

     bool IsPageBasedMEI() const { return !m_scoreBasedMEI; }

     bool IsSerializing() const { return m_serializing; }


     void SetIndent(int indent) { m_indent = indent; }


     void SetIgnoreHeader(bool ignoreHeader) { m_ignoreHeader = ignoreHeader; }


     void SetSerializing(bool serializing) { m_serializing = serializing; }


     void SetRemoveIds(bool removeIds) { m_removeIds = removeIds; }


 private:

     void Reset();


     bool IsTreeObject(Object *object) const;


     bool HasValidFilter() const;

     bool IsMatchingFilter() const;

     void UpdateFilter(Object *object);

     void UpdatePageFilter(Object *object);

     void UpdateMeasureFilter(Object *object);

     void UpdateMdivFilter(Object *object);

     bool ProcessScoreBasedFilter(Object *object);

     bool ProcessScoreBasedFilterEnd(Object *object);

     void PruneAttributes(pugi::xml_node node);


     bool WriteObjectInternal(Object *object, bool useCustomScoreDef);

     bool WriteObjectInternalEnd(Object *object);

     void WriteStackedObjects();

     void WriteStackedObjectsEnd();


     void WriteCustomScoreDef(ScoreDef *scoreDef);

     void AdjustStaffDef(StaffDef *staffDef, Measure *measure);

     bool AdjustLabel(Label *label);


     bool WriteDoc(Doc *doc);


     void WriteRevisionDesc(pugi::xml_node meiHead);


     void WriteXmlId(pugi::xml_node currentNode, Object *object);


     void WriteMdiv(pugi::xml_node currentNode, Mdiv *mdiv);

     void WritePages(pugi::xml_node currentNode, Pages *pages);

     void WriteScore(pugi::xml_node currentNode, Score *score);


     void WriteSection(pugi::xml_node currentNode, Section *section);

     void WriteEnding(pugi::xml_node currentNote, Ending *ending);

     void WriteExpansion(pugi::xml_node currentNote, Expansion *expansion);

     void WritePb(pugi::xml_node currentNode, Pb *pb);

     void WriteSb(pugi::xml_node currentNode, Sb *sb);


     void WritePage(pugi::xml_node currentNode, Page *page);

     void WritePageElement(pugi::xml_node element, PageElement *object);

     void WritePageMilestoneEnd(pugi::xml_node currentNode, PageMilestoneEnd *milestoneEnd);

     void WriteSystem(pugi::xml_node currentNode, System *system);

     void WriteSystemMilestoneEnd(pugi::xml_node currentNode, SystemMilestoneEnd *milestoneEnd);

     void WriteScoreDef(pugi::xml_node currentNode, ScoreDef *scoreDef);

     void WriteGrpSym(pugi::xml_node currentNode, GrpSym *grmSym);

     void WritePgFoot(pugi::xml_node currentNode, PgFoot *pgFoot);

     void WritePgHead(pugi::xml_node currentNode, PgHead *pgHead);

     void WriteDiv(pugi::xml_node currentNode, Div *div);

     void WriteStaffGrp(pugi::xml_node currentNode, StaffGrp *staffGrp);

     void WriteStaffDef(pugi::xml_node currentNode, StaffDef *staffDef);

     void WriteInstrDef(pugi::xml_node currentNode, InstrDef *instrDef);

     void WriteLabel(pugi::xml_node currentNode, Label *label);

     void WriteLabelAbbr(pugi::xml_node currentNode, LabelAbbr *labelAbbr);

     void WriteLayerDef(pugi::xml_node currentNode, LayerDef *layerDef);

     void WriteTuning(pugi::xml_node currentNode, Tuning *tuning);

     void WriteCourse(pugi::xml_node currentNode, Course *course);

     void WriteSymbolTable(pugi::xml_node currentNode, SymbolTable *symbolTable);

     void WriteMeasure(pugi::xml_node currentNode, Measure *measure);

     void WriteMeterSigGrp(pugi::xml_node currentNode, MeterSigGrp *meterSigGrp);

     void WriteFb(pugi::xml_node currentNode, Fb *fb);

     void WriteStaff(pugi::xml_node currentNode, Staff *staff);

     void WriteOStaff(pugi::xml_node currentNode, Staff *oStaff);

     void WriteLayer(pugi::xml_node currentNode, Layer *layer);

     void WriteOssia(pugi::xml_node currentNode, Ossia *ossia);


     void WriteAccid(pugi::xml_node currentNode, Accid *accid);

     void WriteArtic(pugi::xml_node currentNode, Artic *artic);

     void WriteBarLine(pugi::xml_node currentNode, BarLine *barLine);

     void WriteBeam(pugi::xml_node currentNode, Beam *beam);

     void WriteBeatRpt(pugi::xml_node currentNode, BeatRpt *beatRpt);

     void WriteBTrem(pugi::xml_node currentNode, BTrem *bTrem);

     void WriteChord(pugi::xml_node currentNode, Chord *chord);

     void WriteClef(pugi::xml_node currentNode, Clef *clef);

     void WriteCustos(pugi::xml_node currentNode, Custos *custos);

     void WriteDivLine(pugi::xml_node currentNode, DivLine *divLine);

     void WriteDot(pugi::xml_node currentNode, Dot *dot);

     void WriteEpisema(pugi::xml_node currentNode, Episema *episema);

     void WriteFTrem(pugi::xml_node currentNode, FTrem *fTrem);

     void WriteGenericLayerElement(pugi::xml_node currentNode, GenericLayerElement *element);

     void WriteGraceGrp(pugi::xml_node currentNode, GraceGrp *graceGrp);

     void WriteHalfmRpt(pugi::xml_node currentNode, HalfmRpt *halfmRpt);

     void WriteKeyAccid(pugi::xml_node currentNode, KeyAccid *keyAccid);

     void WriteKeySig(pugi::xml_node currentNode, KeySig *keySig);

     void WriteLigature(pugi::xml_node currentNode, Ligature *ligature);

     void WriteLiquescent(pugi::xml_node currentNode, Liquescent *liquescent);

     void WriteMensur(pugi::xml_node currentNode, Mensur *mensur);

     void WriteMeterSig(pugi::xml_node currentNode, MeterSig *meterSig);

     void WriteMRest(pugi::xml_node currentNode, MRest *mRest);

     void WriteMRpt(pugi::xml_node currentNode, MRpt *mRpt);

     void WriteMRpt2(pugi::xml_node currentNode, MRpt2 *mRpt2);

     void WriteMSpace(pugi::xml_node currentNode, MSpace *mSpace);

     void WriteMultiRest(pugi::xml_node currentNode, MultiRest *multiRest);

     void WriteMultiRpt(pugi::xml_node currentNode, MultiRpt *multiRpt);

     void WriteNc(pugi::xml_node currentNode, Nc *nc);

     void WriteNeume(pugi::xml_node currentNode, Neume *neume);

     void WriteNote(pugi::xml_node currentNode, Note *note);

     void WriteOriscus(pugi::xml_node currentNode, Oriscus *oriscus);

     void WritePlica(pugi::xml_node currentNode, Plica *plica);

     void WriteProport(pugi::xml_node currentNode, Proport *proport);

     void WriteQuilisma(pugi::xml_node currentNode, Quilisma *quilisma);

     void WriteStrophicus(pugi::xml_node currentNode, Strophicus *strophicus);

     void WriteRest(pugi::xml_node currentNode, Rest *rest);

     void WriteSpace(pugi::xml_node currentNode, Space *space);

     void WriteStem(pugi::xml_node currentNode, Stem *stem);

     void WriteSyllable(pugi::xml_node currentNode, Syllable *syllable);

     void WriteTabDurSym(pugi::xml_node currentNode, TabDurSym *tabDurSym);

     void WriteTabGrp(pugi::xml_node currentNode, TabGrp *tabGrp);

     void WriteTuplet(pugi::xml_node currentNode, Tuplet *tuplet);


     void WriteAnchoredText(pugi::xml_node currentNode, AnchoredText *anchoredText);

     void WriteAnnotScore(pugi::xml_node currentNode, AnnotScore *annotScore);

     void WriteArpeg(pugi::xml_node currentNode, Arpeg *arpeg);

     void WriteBeamSpan(pugi::xml_node currentNode, BeamSpan *beamSpan);

     void WriteBracketSpan(pugi::xml_node currentNode, BracketSpan *bracketSpan);

     void WriteBreath(pugi::xml_node currentNode, Breath *breath);

     void WriteCaesura(pugi::xml_node currentNode, Caesura *caesura);

     void WriteCpMark(pugi::xml_node currentNode, CpMark *cpMark);

     void WriteDir(pugi::xml_node currentNode, Dir *dir);

     void WriteDynam(pugi::xml_node currentNode, Dynam *dynam);

     void WriteFermata(pugi::xml_node currentNode, Fermata *fermata);

     void WriteFing(pugi::xml_node currentNode, Fing *fing);

     void WriteGliss(pugi::xml_node currentNode, Gliss *gliss);

     void WriteHairpin(pugi::xml_node currentNode, Hairpin *hairpin);

     void WriteHarm(pugi::xml_node currentNode, Harm *harm);

     void WriteLv(pugi::xml_node currentNode, Lv *lv);

     void WriteMNum(pugi::xml_node currentNode, MNum *mnum);

     void WriteMordent(pugi::xml_node currentNode, Mordent *mordent);

     void WriteOctave(pugi::xml_node currentNode, Octave *octave);

     void WriteOrnam(pugi::xml_node currentNode, Ornam *ornam);

     void WritePedal(pugi::xml_node currentNode, Pedal *pedal);

     void WritePhrase(pugi::xml_node currentNode, Phrase *phrase);

     void WritePitchInflection(pugi::xml_node currentNode, PitchInflection *pitchInflection);

     void WriteReh(pugi::xml_node currentNode, Reh *reh);

     void WriteRepeatMark(pugi::xml_node currentNode, RepeatMark *repeatMark);

     void WriteSlur(pugi::xml_node currentNode, Slur *slur);

     void WriteTempo(pugi::xml_node currentNode, Tempo *tempo);

     void WriteTie(pugi::xml_node currentNode, Tie *tie);

     void WriteTrill(pugi::xml_node currentNode, Trill *trill);

     void WriteTurn(pugi::xml_node currentNode, Turn *turn);


     void WriteF(pugi::xml_node currentNode, F *f);

     void WriteFig(pugi::xml_node currentNode, Fig *fig);

     void WriteLb(pugi::xml_node currentNode, Lb *lb);

     void WriteNum(pugi::xml_node currentNode, Num *num);

     void WriteRend(pugi::xml_node currentNode, Rend *rend);

     void WriteSvg(pugi::xml_node currentNode, Svg *svg);

     void WriteSymbol(pugi::xml_node currentNode, Symbol *symbol);

     void WriteSymbolDef(pugi::xml_node currentNode, SymbolDef *symbolDef);

     void WriteText(pugi::xml_node currentNode, Text *text);


     void WriteAbbr(pugi::xml_node currentNode, Abbr *abbr);

     void WriteAdd(pugi::xml_node currentNode, Add *add);

     void WriteAnnot(pugi::xml_node currentNode, Annot *annot);

     void WriteApp(pugi::xml_node currentNode, App *app);

     void WriteChoice(pugi::xml_node currentNode, Choice *choice);

     void WriteCorr(pugi::xml_node currentNode, Corr *corr);

     void WriteDamage(pugi::xml_node currentNode, Damage *damage);

     void WriteDel(pugi::xml_node currentNode, Del *del);

     void WriteExpan(pugi::xml_node currentNode, Expan *expan);

     void WriteLem(pugi::xml_node currentNode, Lem *lem);

     void WriteOrig(pugi::xml_node currentNode, Orig *orig);

     void WriteRdg(pugi::xml_node currentNode, Rdg *rdg);

     void WriteRef(pugi::xml_node currentNode, Ref *Ref);

     void WriteReg(pugi::xml_node currentNode, Reg *Reg);

     void WriteRestore(pugi::xml_node currentNode, Restore *restore);

     void WriteSic(pugi::xml_node currentNode, Sic *sic);

     void WriteSubst(pugi::xml_node currentNode, Subst *subst);

     void WriteSupplied(pugi::xml_node currentNode, Supplied *supplied);

     void WriteUnclear(pugi::xml_node currentNode, Unclear *unclear);


     void WriteRefrain(pugi::xml_node currentNode, Refrain *refrain);

     void WriteVolta(pugi::xml_node currentNode, Volta *volta);

     void WriteVerse(pugi::xml_node currentNode, Verse *verse);

     void WriteLyricElement(pugi::xml_node currentNode, LyricElement *lyricElement);

     void WriteSyl(pugi::xml_node currentNode, Syl *syl);

     void WriteZone(pugi::xml_node currentNode, Zone *zone);

     void WriteSurface(pugi::xml_node currentNode, Surface *surface);

     void WriteFacsimile(pugi::xml_node currentNode, Facsimile *facsimile);

     void WriteGraphic(pugi::xml_node currentNode, Graphic *graphic);


     void WriteUnsupportedAttr(pugi::xml_node currentNode, Object *object);


     void WriteControlElement(pugi::xml_node element, ControlElement *object);

     void WriteEditorialElement(pugi::xml_node element, EditorialElement *object);

     void WriteLayerElement(pugi::xml_node element, LayerElement *object);

     void WriteTextLayoutElement(pugi::xml_node element, TextLayoutElement *object);

     void WriteRunningElement(pugi::xml_node element, RunningElement *object);

     void WriteScoreDefElement(pugi::xml_node element, ScoreDefElement *object);

     void WriteSystemElement(pugi::xml_node element, SystemElement *object);

     void WriteTextElement(pugi::xml_node element, TextElement *object);

     //

     void WriteAltSymInterface(pugi::xml_node currentNode, AltSymInterface *interface);

     void WriteAreaPosInterface(pugi::xml_node currentNode, AreaPosInterface *interface);

     void WriteDurationInterface(pugi::xml_node currentNode, DurationInterface *interface);

     void WriteLinkingInterface(pugi::xml_node currentNode, LinkingInterface *interface);

     void WriteFacsimileInterface(pugi::xml_node element, FacsimileInterface *interface);

     void WriteOffsetInterface(pugi::xml_node currentNode, OffsetInterface *interface);

     void WriteOffsetSpanningInterface(pugi::xml_node currentNode, OffsetSpanningInterface *interface);

     void WritePitchInterface(pugi::xml_node currentNode, PitchInterface *interface);

     void WritePlistInterface(pugi::xml_node currentNode, PlistInterface *interface);

     void WritePositionInterface(pugi::xml_node currentNode, PositionInterface *interface);

     void WriteScoreDefInterface(pugi::xml_node currentNode, ScoreDefInterface *interface);

     void WriteTextDirInterface(pugi::xml_node currentNode, TextDirInterface *interface);

     void WriteTimePointInterface(pugi::xml_node currentNode, TimePointInterface *interface);

     void WriteTimeSpanningInterface(pugi::xml_node currentNode, TimeSpanningInterface *interface);


     std::u32string EscapeSMuFL(std::u32string data);


     std::string IDToMeiStr(Object *element);

     std::string DocTypeToStr(DocType type);


 public:

     //

 protected:

     pugi::xml_node m_currentNode;

     std::list<pugi::xml_node> m_nodeStack;


 private:

     int m_indent;

     bool m_scoreBasedMEI;

     bool m_basic;

     bool m_serializing;


     pugi::xml_node m_mei;

     std::stack<Object *> m_boundaries;

     std::deque<Object *> m_objectStack;


     bool m_hasFilter;

     MatchLocation m_filterMatchLocation;

     Object *m_firstFilterMatch;

     int m_firstPage;

     int m_currentPage;

     int m_lastPage;

     std::string m_firstMeasureID;

     std::string m_lastMeasureID;

     RangeMatchLocation m_measureFilterMatchLocation;

     std::string m_mdivID;

     MatchLocation m_mdivFilterMatchLocation;


     bool m_ignoreHeader;

     bool m_removeIds;

     SetOfConstObjects m_referredObjects;

 };


 //----------------------------------------------------------------------------

 // MEIOutputExtended

 //----------------------------------------------------------------------------


 class MEIOutputExtended : public MEIOutput {

 public:

     MEIOutputExtended(Doc *doc);


     jsonxx::Object ExportScoreDef();


 private:

     jsonxx::Object ToJson(const pugi::xml_document &doc);

 };


 //----------------------------------------------------------------------------

 // MEIInput

 //----------------------------------------------------------------------------


 class MEIInput : public Input {

 public:

     // constructors and destructors

     MEIInput(Doc *doc);

     virtual ~MEIInput();


     bool Import(const std::string &mei) override;


     void SetDeserializing(bool deserializing) { m_deserializing = deserializing; }


 private:

     bool ReadDoc(pugi::xml_node root);

     bool ReadIncipits(pugi::xml_node root);


     bool ReadMdiv(Object *parent, pugi::xml_node parentNode, bool isVisible);

     bool ReadMdivChildren(Object *parent, pugi::xml_node parentNode, bool isVisible);

     bool ReadScore(Object *parent, pugi::xml_node parentNode);

     bool ReadScoreScoreDef(Object *parent, pugi::xml_node parentNode);


     bool ReadPages(Object *parent, pugi::xml_node parentNode);

     bool ReadPage(Object *parent, pugi::xml_node parentNode);

     bool ReadPageChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadPageMilestoneEnd(Object *parent, pugi::xml_node milestoneEnd);

     bool ReadSystem(Object *parent, pugi::xml_node system);

     bool ReadSystemChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadSystemMilestoneEnd(Object *parent, pugi::xml_node milestoneEnd);


     bool ReadSection(Object *parent, pugi::xml_node section);

     bool ReadSectionChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadEnding(Object *parent, pugi::xml_node ending);

     bool ReadExpansion(Object *parent, pugi::xml_node expansion);

     bool ReadPb(Object *parent, pugi::xml_node pb);

     bool ReadSb(Object *parent, pugi::xml_node sb);


     bool ReadScoreDef(Object *parent, pugi::xml_node scoreDef);

     bool ReadScoreDefChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadGrpSym(Object *parent, pugi::xml_node grpSym);

     bool ReadPgFoot(Object *parent, pugi::xml_node pgFoot);

     bool ReadPgHead(Object *parent, pugi::xml_node pgHead);

     bool ReadDiv(Object *parent, pugi::xml_node div);

     bool ReadRunningChildren(Object *parent, pugi::xml_node parentNode, Object *filter = NULL);

     bool ReadStaffGrp(Object *parent, pugi::xml_node staffGrp);

     bool ReadStaffGrpChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadStaffDef(Object *parent, pugi::xml_node staffDef);

     bool ReadStaffDefChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadInstrDef(Object *parent, pugi::xml_node instrDef);

     bool ReadLabel(Object *parent, pugi::xml_node label);

     bool ReadLabelAbbr(Object *parent, pugi::xml_node labelAbbr);

     bool ReadTuning(Object *parent, pugi::xml_node tuning);

     bool ReadOssia(Object *parent, pugi::xml_node ossia);

     bool ReadTuningChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadCourse(Object *parent, pugi::xml_node course);

     bool ReadSymbolTable(Object *parent, pugi::xml_node parentNode);

     bool ReadMeasure(Object *parent, pugi::xml_node measure);

     bool ReadMeasureChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadMeterSigGrp(Object *parent, pugi::xml_node meterSigGrp);

     bool ReadMeterSigGrpChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadFb(Object *parent, pugi::xml_node fb);

     bool ReadFbChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadNum(Object *parent, pugi::xml_node parentNode);

     bool ReadStaff(Object *parent, pugi::xml_node staff);

     bool ReadOStaff(Object *parent, pugi::xml_node oStaff);

     bool ReadStaffChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadLayer(Object *parent, pugi::xml_node layer);

     bool ReadLayerDef(Object *parent, pugi::xml_node layerDef);

     bool ReadLayerDefChildren(Object *parent, pugi::xml_node parentNode);

     bool ReadLayerChildren(Object *parent, pugi::xml_node parentNode, Object *filter = NULL);

     bool ReadTextChildren(Object *parent, pugi::xml_node parentNode, Object *filter = NULL);

     bool ReadSymbolDefChildren(Object *parent, pugi::xml_node parentNode, Object *filter = NULL);


     bool ReadAccid(Object *parent, pugi::xml_node accid);

     bool ReadArtic(Object *parent, pugi::xml_node artic);

     bool ReadBarLine(Object *parent, pugi::xml_node barLine);

     bool ReadBeam(Object *parent, pugi::xml_node beam);

     bool ReadBeatRpt(Object *parent, pugi::xml_node beatRpt);

     bool ReadBTrem(Object *parent, pugi::xml_node bTrem);

     bool ReadChord(Object *parent, pugi::xml_node chord);

     bool ReadClef(Object *parent, pugi::xml_node clef);

     bool ReadCustos(Object *parent, pugi::xml_node custos);

     bool ReadDivLine(Object *parent, pugi::xml_node divLine);

     bool ReadDot(Object *parent, pugi::xml_node dot);

     bool ReadEpisema(Object *parent, pugi::xml_node episema);

     bool ReadFTrem(Object *parent, pugi::xml_node fTrem);

     bool ReadGenericLayerElement(Object *parent, pugi::xml_node element);

     bool ReadGraceGrp(Object *parent, pugi::xml_node graceGrp);

     bool ReadHalfmRpt(Object *parent, pugi::xml_node halfmRpt);

     bool ReadKeyAccid(Object *parent, pugi::xml_node keyAccid);

     bool ReadKeySig(Object *parent, pugi::xml_node keySig);

     bool ReadLigature(Object *parent, pugi::xml_node ligature);

     bool ReadLiquescent(Object *parent, pugi::xml_node liquescent);

     bool ReadMensur(Object *parent, pugi::xml_node mensur);

     bool ReadMeterSig(Object *parent, pugi::xml_node meterSig);

     bool ReadMRest(Object *parent, pugi::xml_node mRest);

     bool ReadMRpt(Object *parent, pugi::xml_node mRpt);

     bool ReadMRpt2(Object *parent, pugi::xml_node mRpt2);

     bool ReadMSpace(Object *parent, pugi::xml_node mSpace);

     bool ReadMultiRest(Object *parent, pugi::xml_node multiRest);

     bool ReadMultiRpt(Object *parent, pugi::xml_node multiRpt);

     bool ReadNc(Object *parent, pugi::xml_node nc);

     bool ReadNeume(Object *parent, pugi::xml_node note);

     bool ReadNote(Object *parent, pugi::xml_node note);

     bool ReadOriscus(Object *parent, pugi::xml_node oriscus);

     bool ReadPlica(Object *parent, pugi::xml_node plica);

     bool ReadProport(Object *parent, pugi::xml_node proport);

     bool ReadQuilisma(Object *parent, pugi::xml_node quilisma);

     bool ReadRefrain(Object *parent, pugi::xml_node refrain);

     bool ReadRest(Object *parent, pugi::xml_node rest);

     bool ReadSpace(Object *parent, pugi::xml_node space);

     bool ReadStem(Object *parent, pugi::xml_node stem);

     bool ReadStrophicus(Object *parent, pugi::xml_node strophicus);

     bool ReadSyl(Object *parent, pugi::xml_node syl);

     bool ReadSyllable(Object *parent, pugi::xml_node syllable);

     bool ReadTabDurSym(Object *parent, pugi::xml_node tabDurSym);

     bool ReadTabGrp(Object *parent, pugi::xml_node tabGrp);

     bool ReadTuplet(Object *parent, pugi::xml_node tuplet);

     bool ReadVolta(Object *parent, pugi::xml_node volta);

     bool ReadVerse(Object *parent, pugi::xml_node verse);

     void ReadLyricElement(pugi::xml_node element, LyricElement *lyricElement);


     bool ReadAnchoredText(Object *parent, pugi::xml_node anchoredText);

     bool ReadArpeg(Object *parent, pugi::xml_node arpeg);

     bool ReadBeamSpan(Object *parent, pugi::xml_node beamSpan);

     bool ReadBracketSpan(Object *parent, pugi::xml_node bracketSpan);

     bool ReadBreath(Object *parent, pugi::xml_node breath);

     bool ReadCaesura(Object *parent, pugi::xml_node caesura);

     bool ReadCpMark(Object *parent, pugi::xml_node cpMark);

     bool ReadDir(Object *parent, pugi::xml_node dir, bool isStageDir = false);

     bool ReadDynam(Object *parent, pugi::xml_node dynam);

     bool ReadFermata(Object *parent, pugi::xml_node fermata);

     bool ReadFing(Object *parent, pugi::xml_node fing);

     bool ReadGliss(Object *parent, pugi::xml_node gliss);

     bool ReadHairpin(Object *parent, pugi::xml_node hairpin);

     bool ReadHarm(Object *parent, pugi::xml_node harm);

     bool ReadLv(Object *parent, pugi::xml_node lv);

     bool ReadMNum(Object *parent, pugi::xml_node mnum);

     bool ReadMordent(Object *parent, pugi::xml_node mordent);

     bool ReadOctave(Object *parent, pugi::xml_node octave);

     bool ReadOrnam(Object *parent, pugi::xml_node ornam);

     bool ReadPedal(Object *parent, pugi::xml_node pedal);

     bool ReadPhrase(Object *parent, pugi::xml_node phrase);

     bool ReadPitchInflection(Object *parent, pugi::xml_node pitchInflection);

     bool ReadRepeatMark(Object *parent, pugi::xml_node repeatMark);

     bool ReadReh(Object *parent, pugi::xml_node reh);

     bool ReadSlur(Object *parent, pugi::xml_node slur);

     bool ReadTempo(Object *parent, pugi::xml_node tempo);

     bool ReadTie(Object *parent, pugi::xml_node tie);

     bool ReadTrill(Object *parent, pugi::xml_node trill);

     bool ReadTurn(Object *parent, pugi::xml_node turn);


     bool ReadF(Object *parent, pugi::xml_node f);

     bool ReadFig(Object *parent, pugi::xml_node fig);

     bool ReadLb(Object *parent, pugi::xml_node lb);

     bool ReadRend(Object *parent, pugi::xml_node rend);

     bool ReadSvg(Object *parent, pugi::xml_node svg);

     bool ReadSymbol(Object *parent, pugi::xml_node symbol);

     bool ReadSymbolDef(Object *parent, pugi::xml_node symbolDef);

     bool ReadText(Object *parent, pugi::xml_node text, bool trimLeft, bool trimRight);


     bool ReadEditorialElement(Object *parent, pugi::xml_node app, EditorialLevel level, Object *filter = NULL);

     bool ReadAbbr(Object *parent, pugi::xml_node abbr, EditorialLevel level, Object *filter = NULL);

     bool ReadAdd(Object *parent, pugi::xml_node add, EditorialLevel level, Object *filter = NULL);

     bool ReadAnnot(Object *parent, pugi::xml_node annot);

     bool ReadAnnotScore(Object *parent, pugi::xml_node annot);

     bool ReadApp(Object *parent, pugi::xml_node app, EditorialLevel level, Object *filter = NULL);

     bool ReadAppChildren(Object *parent, pugi::xml_node parentNode, EditorialLevel level, Object *filter = NULL);

     bool ReadChoice(Object *parent, pugi::xml_node choice, EditorialLevel level, Object *filter = NULL);

     bool ReadChoiceChildren(Object *parent, pugi::xml_node parentNode, EditorialLevel level, Object *filter = NULL);

     bool ReadCorr(Object *parent, pugi::xml_node corr, EditorialLevel level, Object *filter = NULL);

     bool ReadDamage(Object *parent, pugi::xml_node damage, EditorialLevel level, Object *filter = NULL);

     bool ReadDel(Object *parent, pugi::xml_node del, EditorialLevel level, Object *filter = NULL);

     bool ReadExpan(Object *parent, pugi::xml_node expan, EditorialLevel level, Object *filter = NULL);

     bool ReadLem(Object *parent, pugi::xml_node lem, EditorialLevel level, Object *filter = NULL);

     bool ReadOrig(Object *parent, pugi::xml_node orig, EditorialLevel level, Object *filter = NULL);

     bool ReadRdg(Object *parent, pugi::xml_node rdg, EditorialLevel level, Object *filter = NULL);

     bool ReadRef(Object *parent, pugi::xml_node ref, EditorialLevel level, Object *filter = NULL);

     bool ReadReg(Object *parent, pugi::xml_node reg, EditorialLevel level, Object *filter = NULL);

     bool ReadRestore(Object *parent, pugi::xml_node restore, EditorialLevel level, Object *filter = NULL);

     bool ReadSic(Object *parent, pugi::xml_node sic, EditorialLevel level, Object *filter = NULL);

     bool ReadSubst(Object *parent, pugi::xml_node subst, EditorialLevel level, Object *filter = NULL);

     bool ReadSubstChildren(Object *parent, pugi::xml_node parentNode, EditorialLevel level, Object *filter = NULL);

     bool ReadSupplied(Object *parent, pugi::xml_node supplied, EditorialLevel level, Object *filter = NULL);

     bool ReadUnclear(Object *parent, pugi::xml_node unclear, EditorialLevel level, Object *filter = NULL);

     bool ReadEditorialChildren(Object *parent, pugi::xml_node supplied, EditorialLevel level, Object *filter = NULL);


     bool ReadControlElement(pugi::xml_node element, ControlElement *object);

     bool ReadEditorialElement(pugi::xml_node element, EditorialElement *object);

     bool ReadLayerElement(pugi::xml_node element, LayerElement *object);

     bool ReadTextLayoutElement(pugi::xml_node element, TextLayoutElement *object);

     bool ReadRunningElement(pugi::xml_node element, RunningElement *object);

     bool ReadScoreDefElement(pugi::xml_node element, ScoreDefElement *object);

     bool ReadSystemElement(pugi::xml_node element, SystemElement *object);

     bool ReadTextElement(pugi::xml_node element, TextElement *object);


     bool ReadAltSymInterface(pugi::xml_node element, AltSymInterface *interface);

     bool ReadAreaPosInterface(pugi::xml_node element, AreaPosInterface *interface);

     bool ReadDurationInterface(pugi::xml_node element, DurationInterface *interface);

     bool ReadLinkingInterface(pugi::xml_node element, LinkingInterface *interface);

     bool ReadFacsimileInterface(pugi::xml_node element, FacsimileInterface *interface);

     bool ReadOffsetInterface(pugi::xml_node element, OffsetInterface *interface);

     bool ReadOffsetSpanningInterface(pugi::xml_node element, OffsetSpanningInterface *interface);

     bool ReadPitchInterface(pugi::xml_node element, PitchInterface *interface);

     bool ReadPlistInterface(pugi::xml_node element, PlistInterface *interface);

     bool ReadPositionInterface(pugi::xml_node element, PositionInterface *interface);

     bool ReadScoreDefInterface(pugi::xml_node element, ScoreDefInterface *interface);

     bool ReadTextDirInterface(pugi::xml_node element, TextDirInterface *interface);

     bool ReadTimePointInterface(pugi::xml_node element, TimePointInterface *interface);

     bool ReadTimeSpanningInterface(pugi::xml_node element, TimeSpanningInterface *interface);


     bool ReadFacsimile(Doc *doc, pugi::xml_node facsimile);

     bool ReadGraphic(Object *parent, pugi::xml_node graphic);

     bool ReadSurface(Facsimile *parent, pugi::xml_node surface);

     bool ReadTupletSpanAsTuplet(Measure *measure, pugi::xml_node tupletSpan);

     bool ReadZone(Surface *parent, pugi::xml_node zone);


     void ReadUnsupportedAttr(pugi::xml_node element, Object *object);


     bool IsAnnotScore(pugi::xml_node element);


     bool IsEditorialElementName(std::string elementName);


     void NormalizeAttributes(pugi::xml_node &xmlElement);


     bool ReadScoreBasedMei(pugi::xml_node element, Score *parent);


     void SetMeiID(pugi::xml_node element, Object *object);

     DocType StrToDocType(std::string type);

     std::u32string LeftTrim(std::u32string str);

     std::u32string RightTrim(std::u32string str);

     bool ReadXMLComment(Object *object, pugi::xml_node element);


     // to MEI 5.0.0

     void UpgradeKeySigTo_5_0(pugi::xml_node keySig);

     void UpgradePageTo_5_0(Page *page);

     void UpgradePgHeadFootTo_5_0(pugi::xml_node element);

     void UpgradeMeasureTo_5_0(pugi::xml_node measure);

     void UpgradeMeterSigTo_5_0(pugi::xml_node meterSig, MeterSig *vrvMeterSig);

     void UpgradeScoreDefElementTo_5_0(pugi::xml_node scoreDefElement);

     void UpgradeStaffTo_5_0(pugi::xml_node staff);

     void UpgradeLayerElementTo_5_0(pugi::xml_node element);

     void UpgradeRendTo_5_0(pugi::xml_node element);

     // to MEI 4.0.0

     void UpgradeBeatRptTo_4_0_0(pugi::xml_node beatRpt, BeatRpt *vrvBeatRpt);

     void UpgradeDurGesTo_4_0_0(pugi::xml_node element, DurationInterface *interface);

     void UpgradeFTremTo_4_0_0(pugi::xml_node fTrem, FTrem *vrvFTrem);

     void UpgradeMensurTo_5_0(pugi::xml_node mensur, Mensur *vrvMensur);

     void UpgradeMordentTo_4_0_0(pugi::xml_node mordent, Mordent *vrvMordent);

     void UpgradeScoreDefElementTo_4_0_0(pugi::xml_node scoreDefElement, ScoreDefElement *vrvScoreDefElement);

     void UpgradeStaffDefTo_4_0_0(pugi::xml_node staffDef, StaffDef *vrvStaffDef);

     void UpgradeStaffGrpTo_4_0_0(pugi::xml_node staffGrp, StaffGrp *vrvStaffGrp);

     void UpgradeTurnTo_4_0_0(pugi::xml_node turn, Turn *vrvTurn);

     // to MEI 3.0.0 (Page-Based MEI only)

     void UpgradeMeasureTo_3_0_0(Measure *measure, System *system);

     void UpgradePageTo_3_0_0(Page *page, Doc *doc);


     void ReadAccidAttr(pugi::xml_node node, Object *object);


 public:

     //

 private:

     std::string m_filename;


     meiVersion_MEIVERSION m_meiversion;


     bool m_readingScoreBased;


     bool m_hasScoreDef;


     bool IsAllowed(std::string element, Object *filterParent);


     pugi::xml_node m_selectedMdiv;


     std::string m_comment;


     bool m_deserializing;


     //----------------//

     // Static members //

     //----------------//


     static const std::vector<std::string> s_editorialElementNames;

 };


 //----------------------------------------------------------------------------

 // MEIInputExtended

 //----------------------------------------------------------------------------


 class MEIInputExtended : public MEIInput {

 public:

     MEIInputExtended(Doc *doc);


     void ImportScoreDef(const jsonxx::Object &scoreDef);


 private:

     pugi::xml_document FromJson(const jsonxx::Object &json);

 };


 } // namespace vrv


 #endif

vrv::Abbr
Definition: abbr.h:20

vrv::Accid
This class models the MEI <accid> element.
Definition: accid.h:41

vrv::Add
Definition: add.h:20

vrv::AltSymInterface
This class is an interface for elements having a @altsym It is not an abstract class but should not b...
Definition: altsyminterface.h:30

vrv::AnchoredText
This class is an interface for <anchoredText> elements at the measure level.
Definition: anchoredtext.h:25

vrv::Annot
This class models the MEI <annot> element.
Definition: annot.h:23

vrv::AnnotScore
This class models the MEI <annot> element where @type is score.
Definition: annotscore.h:24

vrv::App
Definition: app.h:19

vrv::AreaPosInterface
This class is an interface for elements implementing vertically and horizontally positionned elements...
Definition: areaposinterface.h:26

vrv::Arpeg
This class models the MEI <arpeg> element.
Definition: arpeg.h:31

vrv::Artic
Definition: artic.h:31

vrv::BTrem
This class models the MEI <bTrem> element.
Definition: btrem.h:27

vrv::BarLine
This class models the MEI <barLine> element.
Definition: barline.h:34

vrv::Beam
Definition: beam.h:284

vrv::BeamSpan
This class models the MEI <beamSpan> element.
Definition: beamspan.h:36

vrv::BeatRpt
This class models the MEI <beatRpt> element.
Definition: beatrpt.h:25

vrv::BracketSpan
This class models the MEI <bracketSpan> element.
Definition: bracketspan.h:28

vrv::Breath
This class models the MEI <breath> element.
Definition: breath.h:24

vrv::Caesura
This class models the MEI <caesura> element.
Definition: caesura.h:29

vrv::Choice
Definition: choice.h:20

vrv::Chord
This class represents a collection of notes in the same layer with the same onset time.
Definition: chord.h:44

vrv::Clef
This class models the MEI <clef> element.
Definition: clef.h:41

vrv::ControlElement
This class represents elements appearing within a measure.
Definition: controlelement.h:35

vrv::Corr
Definition: corr.h:20

vrv::Course
This class models the MEI <course> element.
Definition: course.h:23

vrv::CpMark
This class models the MEI <cpMark> element.
Definition: cpmark.h:26

vrv::Custos
Definition: custos.h:31

vrv::Damage
Definition: damage.h:20

vrv::Del
Definition: del.h:20

vrv::Dir
This class models the MEI <dir> element.
Definition: dir.h:33

vrv::Div
This class represents an MEI Div.
Definition: div.h:24

vrv::DivLine
This class models the MEI <divLine> element.
Definition: divline.h:33

vrv::Doc
This class is a hold the data and corresponds to the model of a MVC design pattern.
Definition: doc.h:41

vrv::Dot
Definition: dot.h:23

vrv::DurationInterface
This class is an interface for elements with duration, such as notes and rests.
Definition: durationinterface.h:39

vrv::Dynam
Definition: dynam.h:33

vrv::EditorialElement
This class is a base class for the editorial element containing musical content, for example <rgd> or...
Definition: editorial.h:43

vrv::Ending
This class represents a MEI ending.
Definition: ending.h:33

vrv::Episema
Definition: episema.h:29

vrv::Expan
Definition: expan.h:20

vrv::Expansion
This class represents a MEI expansion.
Definition: expansion.h:26

vrv::F
This class models the MEI <f> element.
Definition: f.h:24

vrv::FTrem
This class models the MEI <fTrem> element.
Definition: ftrem.h:25

vrv::Facsimile
Implements the facsimile element in MEI.
Definition: facsimile.h:31

vrv::FacsimileInterface
Definition: facsimileinterface.h:27

vrv::Fb
This class models the MEI <fb> element.
Definition: fb.h:23

vrv::Fermata
This class models the MEI <fermata> element.
Definition: fermata.h:32

vrv::Fig
This class models the MEI <fig> element.
Definition: fig.h:23

vrv::Fing
This class models the MEI <fing> element.
Definition: fing.h:25

vrv::GenericLayerElement
This class holds generic elements existing within MEI <layer> but not supported by Verovio.
Definition: genericlayerelement.h:22

vrv::Gliss
This class models the MEI <gliss> element.
Definition: gliss.h:28

vrv::GraceGrp
Definition: gracegrp.h:20

vrv::Graphic
Implements the graphic element in MEI.
Definition: graphic.h:30

vrv::GrpSym
This class represents a MEI grpSym.
Definition: grpsym.h:30

vrv::Hairpin
This class models the MEI <hairpin> element.
Definition: hairpin.h:32

vrv::HalfmRpt
This class models the MEI <halfmRpt> element.
Definition: halfmrpt.h:27

vrv::Harm
This class models the MEI <harm> element.
Definition: harm.h:32

vrv::Input
This class is a base class for input classes.
Definition: iobase.h:73

vrv::InstrDef
This class models the MEI <instrDef> element.
Definition: instrdef.h:28

vrv::KeyAccid
This class models the MEI <keyAccid> element.
Definition: keyaccid.h:33

vrv::KeySig
This class models the MEI <keySig> element.
Definition: keysig.h:51

vrv::LabelAbbr
This class models the MEI <labelAbbr> element.
Definition: labelabbr.h:22

vrv::Label
This class models the MEI <label> element.
Definition: label.h:22

vrv::LayerDef
Definition: layerdef.h:18

vrv::LayerElement
This class is a base class for the Layer (<layer>) content.
Definition: layerelement.h:51

vrv::Layer
This class represents a layer in a laid-out score (Doc).
Definition: layer.h:40

vrv::Lb
This class models the MEI <lb>
Definition: lb.h:23

vrv::Lem
Definition: lem.h:20

vrv::Ligature
This class represents a collection of notes in the same layer with successive onset times,...
Definition: ligature.h:28

vrv::LinkingInterface
This class is an interface for elements having a link It is not an abstract class but should not be i...
Definition: linkinginterface.h:31

vrv::Liquescent
Definition: liquescent.h:28

vrv::Lv
This class models the MEI <lv> element.
Definition: lv.h:22

vrv::LyricElement
Shared implementation for note-attached verse and refrain lyrics.
Definition: lyricelement.h:33

vrv::MEIInputExtended
Extended MEIInput for partial import.
Definition: iomei.h:1065

vrv::MEIInput
This class is a file input stream for reading MEI files.
Definition: iomei.h:662

vrv::MEIInput::SetDeserializing
void SetDeserializing(bool deserializing)
Setter for the page-based deserialization flag (default is false).
Definition: iomei.h:673

vrv::MEIOutputExtended
Extended MEIOutput for partial exports.
Definition: iomei.h:640

vrv::MEIOutput
This class is a file output stream for writing MEI files.
Definition: iomei.h:202

vrv::MEIOutput::SetSerializing
void SetSerializing(bool serializing)
Setter for the page-based serialization flag (default is false)
Definition: iomei.h:278

vrv::MEIOutput::SetRemoveIds
void SetRemoveIds(bool removeIds)
Setter for remove ids flag for the MEI output (default is false)
Definition: iomei.h:283

vrv::MEIOutput::m_nodeStack
std::list< pugi::xml_node > m_nodeStack
Xml node stack.
Definition: iomei.h:594

vrv::MEIOutput::SetIndent
void SetIndent(int indent)
Setter for indent for the MEI output (default is 3, -1 for tabs)
Definition: iomei.h:268

vrv::MEIOutput::SetIgnoreHeader
void SetIgnoreHeader(bool ignoreHeader)
Setter for ignore header flag for the MEI output (default is false)
Definition: iomei.h:273

vrv::MEIOutput::m_currentNode
pugi::xml_node m_currentNode
Current xml element.
Definition: iomei.h:592

vrv::MEIOutput::Skip
bool Skip(Object *object) const override
Method for skipping under certain circumstances.

vrv::MEIOutput::Export
std::string Export() override
The main method for exporting the file to MEI.

vrv::MEIOutput::HasFilter
bool HasFilter() const
Score based filtering by measure, page or mdiv.

vrv::MEIOutput::WriteObject
bool WriteObject(Object *object) override
The main method for writing objects.

vrv::MEIOutput::WriteObjectEnd
bool WriteObjectEnd(Object *object) override
Dummy object method that must be overridden in child class.

vrv::MNum
This class models the MEI <mNum> element.
Definition: mnum.h:31

vrv::MRest
This class models the MEI <mRest> element.
Definition: mrest.h:36

vrv::MRpt2
This class models the MEI <mRpt2> element.
Definition: mrpt2.h:26

vrv::MRpt
This class models the MEI <mRpt> element.
Definition: mrpt.h:26

vrv::MSpace
This class models the MEI <space> element.
Definition: mspace.h:22

vrv::Mdiv
This class represent a <mdiv> in page-based MEI.
Definition: mdiv.h:29

vrv::Measure
This class represents a measure in a page-based score (Doc).
Definition: measure.h:46

vrv::Mensur
This class models the MEI <mensur> element.
Definition: mensur.h:34

vrv::MeterSigGrp
This class represents a MEI meterSigGrp.
Definition: metersiggrp.h:32

vrv::MeterSig
This class models the MEI <meterSig> element.
Definition: metersig.h:34

vrv::Mordent
This class models the MEI <mordent> element.
Definition: mordent.h:33

vrv::MultiRest
This class models the MEI <multiRest> element.
Definition: multirest.h:32

vrv::MultiRpt
This class models the MEI <multiRpt> element.
Definition: multirpt.h:25

vrv::Nc
This class models the MEI <nc> element.
Definition: nc.h:43

vrv::Neume
This class models the MEI <neume> element.
Definition: neume.h:60

vrv::Note
This class models the MEI <note> element.
Definition: note.h:69

vrv::Num
This class models the MEI <num> element.
Definition: num.h:24

vrv::Object
This class represents a basic object.
Definition: object.h:66

vrv::Octave
This class models the MEI <octave> element.
Definition: octave.h:31

vrv::OffsetInterface
This class is an interface for elements having a single visual offset, such as arpeg,...
Definition: offsetinterface.h:28

vrv::OffsetSpanningInterface
This class is an interface for elements having spanning visual offsets, such as slur,...
Definition: offsetinterface.h:72

vrv::Orig
Definition: orig.h:20

vrv::Oriscus
Definition: oriscus.h:28

vrv::Ornam
This class models the MEI <ornam> element.
Definition: ornam.h:31

vrv::Ossia
This class represents an ossia.
Definition: ossia.h:28

vrv::Output
This class is a base class for output classes.
Definition: iobase.h:31

vrv::PageElement
This class represents elements appearing within a page.
Definition: pageelement.h:25

vrv::Page
This class represents a page in a laid-out score (Doc).
Definition: page.h:31

vrv::PageMilestoneEnd
This class models an end milestone element and has no MEI equivalent.
Definition: pagemilestone.h:26

vrv::Pages
This class represent a <pages> in page-based MEI.
Definition: pages.h:27

vrv::Pb
This class represents a MEI pb in score-based MEI.
Definition: pb.h:25

vrv::Pedal
This class models the MEI <pedal> element.
Definition: pedal.h:34

vrv::PgFoot
This class represents an MEI pgFoot.
Definition: pgfoot.h:22

vrv::PgHead
This class represents an MEI pgHead.
Definition: pghead.h:22

vrv::Phrase
Definition: phrase.h:19

vrv::PitchInflection
This class models the MEI <dir> element.
Definition: pitchinflection.h:23

vrv::PitchInterface
This class is an interface for elements with pitch, such as notes and neumes.
Definition: pitchinterface.h:28

vrv::Plica
Definition: plica.h:20

vrv::PlistInterface
This class is an interface for elements having a single time point, such as tempo,...
Definition: plistinterface.h:29

vrv::PositionInterface
This class is an interface for elements with a position on the staff, such as rests.
Definition: positioninterface.h:30

vrv::Proport
This class models the MEI <proport> element.
Definition: proport.h:23

vrv::Quilisma
Definition: quilisma.h:28

vrv::Rdg
Definition: rdg.h:20

vrv::Ref
This class models the MEI <ref> element.
Definition: ref.h:23

vrv::Refrain
Recurring note-attached lyrics, such as a chorus.
Definition: refrain.h:19

vrv::Reg
Definition: reg.h:20

vrv::Reh
This class models the MEI <reh> element.
Definition: reh.h:30

vrv::Rend
This class models the MEI <rend> element.
Definition: rend.h:33

vrv::RepeatMark
This class models the MEI <ornam> element.
Definition: repeatmark.h:32

vrv::Rest
This class models the MEI <rest> element.
Definition: rest.h:49

vrv::Restore
Definition: restore.h:20

vrv::RunningElement
This class represents running elements (headers and footers).
Definition: runningelement.h:28

vrv::Sb
This class represents a MEI sb in score-based MEI.
Definition: sb.h:25

vrv::ScoreDefElement
This class is a base class for MEI scoreDef or staffDef elements.
Definition: scoredef.h:43

vrv::ScoreDef
This class represents a MEI scoreDef.
Definition: scoredef.h:136

vrv::ScoreDefInterface
This class is an interface for elements implementing score attributes, such as <scoreDef>,...
Definition: scoredefinterface.h:42

vrv::Score
This class represent a <score> in MEI.
Definition: score.h:30

vrv::Section
This class represents a MEI section.
Definition: section.h:28

vrv::Sic
Definition: sic.h:20

vrv::Slur
Definition: slur.h:59

vrv::Space
This class models the MEI <space> element.
Definition: space.h:23

vrv::StaffDef
This class represents a MEI staffDef.
Definition: staffdef.h:37

vrv::StaffGrp
This class represents a MEI staffGrp.
Definition: staffgrp.h:39

vrv::Staff
This class represents a staff in a laid-out score (Doc).
Definition: staff.h:110

vrv::Stem
This class models a stem as a layer element part and as MEI <stem> element.
Definition: stem.h:27

vrv::Strophicus
Definition: strophicus.h:27

vrv::Subst
Definition: subst.h:22

vrv::Supplied
Definition: supplied.h:20

vrv::Surface
Implements the surface element in MEI.
Definition: surface.h:30

vrv::Svg
Definition: svg.h:20

vrv::Syl
Syl is a TimeSpanningInterface for managing syllable connectors.
Definition: syl.h:38

vrv::Syllable
This class models the MEI <mensur> element.
Definition: syllable.h:25

vrv::SymbolDef
Definition: symboldef.h:20

vrv::Symbol
This class models the MEI <symbol> element.
Definition: symbol.h:25

vrv::SymbolTable
Definition: symboltable.h:20

vrv::SystemElement
This class represents elements appearing within a measure.
Definition: systemelement.h:26

vrv::System
This class represents a system in a laid-out score (Doc).
Definition: system.h:36

vrv::SystemMilestoneEnd
This class models an end milestone element at the system level.
Definition: systemmilestone.h:28

vrv::TabDurSym
This class models the MEI <tabDurSym> element.
Definition: tabdursym.h:29

vrv::TabGrp
This class models the MEI <tabGrp> element.
Definition: tabgrp.h:24

vrv::Tempo
This class is an interface for <tempo> elements at the measure level.
Definition: tempo.h:33

vrv::TextDirInterface
This class is an interface for elements implementing a text directive, such as <dir>,...
Definition: textdirinterface.h:26

vrv::TextElement
Definition: textelement.h:22

vrv::Text
This class models CDATA (text)
Definition: text.h:23

vrv::TextLayoutElement
This class represents a text element featuring horizontal and vertical layout.
Definition: textlayoutelement.h:24

vrv::Tie
This class models the MEI <tie> element.
Definition: tie.h:32

vrv::TimePointInterface
This class is an interface for elements having a single time point, such as tempo,...
Definition: timeinterface.h:39

vrv::TimeSpanningInterface
This class is an interface for spanning elements, such as slur, hairpin, etc.
Definition: timeinterface.h:145

vrv::Trill
This class models the MEI <trill> element.
Definition: trill.h:35

vrv::Tuning
This class models the MEI <tuning> element.
Definition: tuning.h:23

vrv::Tuplet
Definition: tuplet.h:33

vrv::Turn
This class models the MEI <turn> element.
Definition: turn.h:33

vrv::Unclear
Definition: unclear.h:20

vrv::Verse
Definition: verse.h:21

vrv::Volta
Sung text for a specific iteration of a repeated section of music.
Definition: volta.h:26

vrv::Zone
Implements the zone element in MEI.
Definition: zone.h:30