Verovio
Source code documentation
Public Member Functions | Protected Member Functions | Static Protected Member Functions | List of all members
vrv::HumdrumInput Class Reference
Inheritance diagram for vrv::HumdrumInput:
vrv::Input

Public Member Functions

 HumdrumInput (vrv::Doc *doc)
 
bool Import (const std::string &humdrum) override
 
void parseEmbeddedOptions (vrv::Doc *doc)
 
void finalizeDocument (vrv::Doc *doc)
 
std::string GetHumdrumString ()
 
std::string GetMeiString ()
 
- Public Member Functions inherited from vrv::Input
 Input (Doc *doc)
 
void SetOutputFormat (const std::string &format)
 
std::string GetOutputFormat ()
 
LayoutInformation GetLayoutInformation ()
 Getter for layoutInformation flag that is set to true during import if layout information is found (and not to be ignored).
 

Protected Member Functions

void clear ()
 
bool convertHumdrum ()
 
void setupMeiDocument ()
 
int getMeasureEndLine (int startline)
 
bool convertSystemMeasure (int &line)
 
bool convertMeasureStaves (int startline, int endline)
 
bool convertMeasureStaff (int track, int startline, int endline, int n, int layercount)
 
void setupSystemMeasure (int startline, int endline)
 
bool convertStaffLayer (int track, int startline, int endline, int layerindex)
 
int getMeasureNumber (int startline, int endline)
 
bool fillContentsOfLayer (int track, int startline, int endline, int layerindex)
 
void calculateLayout ()
 
void setSystemMeasureStyle (int startline, int endline)
 
std::vector< int > getStaffLayerCounts ()
 
void prepareStaffGroups (int top, int bot)
 
void setClef (StaffDef *staff, const std::string &clef, hum::HTp cleftok=NULL, hum::HTp striatok=NULL)
 
void setDynamicTransposition (int staffindex, StaffDef *staff, const std::string &itranspose)
 
void setTransposition (StaffDef *staffDef, const std::string &transpose)
 
void setTimeSig (StaffDef *part, const std::string &timesig, const std::string &metersig="", hum::HTp partstart=NULL, hum::HTp timetok=NULL, hum::HTp metertok=NULL)
 
void fillStaffInfo (hum::HTp staffstart, int staffnumber, int staffcount)
 
void storeStaffLayerTokensForMeasure (int startline, int endline)
 
void calculateReverseKernIndex ()
 
void prepareTimeSigDur (int &top, int &bot)
 
void printMeasureTokens ()
 
int characterCount (const std::string &text, char symbol)
 
int characterCount (hum::HTp token, char symbol)
 
int characterCountInSubtoken (hum::HTp token, char symbol)
 
int characterCountInSubtoken (const std::string &text, char symbol)
 
bool emptyMeasures ()
 
bool hasFullMeasureRest (std::vector< hum::HTp > &layerdata, hum::HumNum timesigdur, hum::HumNum measuredur)
 
void convertNote (vrv::Note *note, hum::HTp token, int staffadj, int staffindex, int subtoken=-1)
 
void addCautionaryAccidental (Accid *accid, hum::HTp token, int acount)
 
void convertRest (vrv::Rest *rest, hum::HTp token, int subtoken, int staffindex)
 
void convertMRest (MRest *rest, hum::HTp token, int subtoken, int staffindex)
 
void processTieStart (Note *note, hum::HTp token, const std::string &tstring, int subindex)
 
void processTieEnd (Note *note, hum::HTp token, const std::string &tstring, int subindex)
 
void addFermata (hum::HTp token, vrv::Object *parent=NULL)
 
void addBreath (hum::HTp token, vrv::Object *parent=NULL)
 
void addTrill (vrv::Object *linked, hum::HTp token)
 
void addTurn (hum::HTp token, const std::string &tok, int noteIndex)
 
void addMordent (vrv::Object *linked, hum::HTp token)
 
void addOrnaments (vrv::Object *object, hum::HTp token)
 
void addArpeggio (vrv::Object *object, hum::HTp token)
 
void getTimingInformation (std::vector< hum::HumNum > &prespace, std::vector< hum::HTp > &layerdata, hum::HumNum layerstarttime, hum::HumNum layerendtime)
 
void convertChord (Chord *chord, hum::HTp token, int staffindex)
 
void prepareVerses ()
 
void checkForOmd (int startline, int endline)
 
void handleOttavaMark (hum::HTp token, Note *note)
 
void handlePedalMark (hum::HTp token)
 
void handleLigature (hum::HTp token)
 
void handleColoration (hum::HTp token)
 
void prepareBeamAndTupletGroups (std::vector< humaux::HumdrumBeamAndTuplet > &tg, const std::vector< hum::HTp > &layerdata)
 
void assignScalingToTupletGroup (std::vector< humaux::HumdrumBeamAndTuplet * > &tggroup)
 
void printGroupInfo (const std::vector< humaux::HumdrumBeamAndTuplet > &tg)
 
void insertTuplet (std::vector< std::string > &elements, std::vector< void * > &pointers, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< hum::HTp > layerdata, int layerindex, bool suppressTupletNumber, bool suppressBracketTuplet)
 
vrv::Beam * insertBeam (std::vector< std::string > &elements, std::vector< void * > &pointers, const humaux::HumdrumBeamAndTuplet &tg)
 
vrv::Beam * insertGBeam (std::vector< std::string > &elements, std::vector< void * > &pointers, const humaux::HumdrumBeamAndTuplet &tg)
 
void analyzeLayerBeams (std::vector< int > &beamnum, std::vector< int > &gbeamnum, const std::vector< hum::HTp > &layerdata)
 
void storeBreaksec (std::vector< int > &beamstate, std::vector< int > &gbeamstate, const std::vector< hum::HTp > &layerdata, bool grace=false)
 
void setBeamDirection (int direction, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< hum::HTp > &layerdata, int layerindex, bool grace)
 
void handleGroupStarts (const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< std::string > &elements, std::vector< void * > &pointers, std::vector< hum::HTp > &layerdata, int layerindex)
 
bool checkForTremolo (std::vector< hum::HTp > &layerdata, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, int startindex)
 
void handleGroupEnds (const humaux::HumdrumBeamAndTuplet &tg, std::vector< std::string > &elements, std::vector< void * > &pointers)
 
void handleStaffStateVariables (hum::HTp token)
 
void handleStaffDynamStateVariables (hum::HTp token)
 
void removeTuplet (std::vector< std::string > &elements, std::vector< void * > &pointers)
 
void removeGBeam (std::vector< std::string > &elements, std::vector< void * > &pointers)
 
void removeBeam (std::vector< std::string > &elements, std::vector< void * > &pointers)
 
vrv::Clef * insertClefElement (std::vector< std::string > &elements, std::vector< void * > &pointers, hum::HTp clef, hum::HTp lastnote)
 
void insertMeterSigElement (std::vector< std::string > &elements, std::vector< void * > &pointers, std::vector< hum::HTp > &layeritems, int index)
 
void processSlurs (hum::HTp token)
 
std::string generateSlurId (hum::HTp token, int count, int number)
 
void processPhrases (hum::HTp token)
 
int getSlurEndNumber (hum::HTp startslur, int slurstartnumber)
 
void addHarmFloatsForMeasure (int startine, int endline)
 
void addFingeringsForMeasure (int startline, int endline)
 
void insertFingerNumberInMeasure (const std::string &text, int staffindex, hum::HTp token, int maxstaff, bool aboveQ)
 
void addStringNumbersForMeasure (int startline, int endline)
 
void addFiguredBassForMeasure (int startline, int endline)
 
void processDynamics (hum::HTp token, int staffindex)
 
void processDirections (hum::HTp token, int staffindex)
 
void processLinkedDirection (int index, hum::HTp token, int staffindex)
 
void processGlobalDirections (hum::HTp token, int staffindex)
 
void processChordSignifiers (Chord *chord, hum::HTp token, int staffindex)
 
hum::HumNum getMeasureTstamp (hum::HTp token, int staffindex, hum::HumNum frac=0)
 
hum::HumNum getMeasureTstamp (hum::HTp token, hum::HumNum extraduration, int staffindex, hum::HumNum frac=0)
 
hum::HumNum getMeasureTstampPlusDur (hum::HTp token, int staffindex, hum::HumNum fract=0)
 
hum::HumNum getMeasureEndTstamp (int staffindex)
 
hum::HumNum getMeasureFactor (int staffindex)
 
hum::HTp getPreviousDataToken (hum::HTp token)
 
hum::HTp getHairpinEnd (hum::HTp token, const std::string &endchar)
 
hum::HTp getDecrescendoEnd (hum::HTp token)
 
hum::HTp getCrescendoEnd (hum::HTp token)
 
int getMeasureDifference (hum::HTp starttok, hum::HTp endtok)
 
int getMeasureDifference (hum::HTp starttok, hum::HumNum meterunit, hum::HumNum tieduration, hum::HumNum &tstamp)
 
void storeOriginalClefMensurationKeyApp ()
 
void addSpace (std::vector< std::string > &elements, std::vector< void * > &pointers, hum::HumNum duration, const std::string &typestring="")
 
void setLocationId (vrv::Object *object, hum::HTp token, int subtoken=-1)
 
void setLocationId (vrv::Object *object, int lineindex, int fieldindex, int subtokenindex)
 
std::string getLocationId (vrv::Object *object, hum::HTp token, int subtoken=-1)
 
std::string getLocationId (Object *object, int lineindex, int fieldindex, int subtokenindex)
 
std::string getLocationId (const std::string &prefix, hum::HTp token, int subtoken=-1)
 
std::string getLocationId (const std::string &prefix, int lineindex, int fieldindex, int subtokenindex)
 
void setLocationIdNSuffix (vrv::Object *object, hum::HTp token, int number)
 
void setSlurLocationId (vrv::Object *object, hum::HTp slurstart, hum::HTp slurend, int eindex, const std::string &prefix="")
 
void setTieLocationId (vrv::Object *object, hum::HTp tiestart, int sindex, hum::HTp tieend, int eindex)
 
void setBeamLocationId (vrv::Object *object, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< hum::HTp > &layerdata, int startindex)
 
void setTupletLocationId (vrv::Object *object, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< hum::HTp > &layerdata, int startindex)
 
void addMidiTempo (vrv::ScoreDef *scoreDef, hum::HTp kernpart, int top, int bot)
 
void addInstrumentDefinition (vrv::StaffDef *staffdef, hum::HTp partstart)
 
void addOrnamentMarkers (hum::HTp token)
 
void setNextLeftBarStyle (data_BARRENDITION style)
 
void parseSignifiers (hum::HumdrumFile &infile)
 
std::string getAutoClef (hum::HTp partstart, int partnumber)
 
void colorNote (vrv::Note *note, hum::HTp token, const std::string &subtoken, int line, int field)
 
void colorRest (vrv::Rest *rest, const std::string &token, int line, int field)
 
void colorVerse (Verse *verse, std::string &token)
 
std::string getSpineColor (int line, int field)
 
void checkForColorSpine (hum::HumdrumFile &infile)
 
std::vector< int > analyzeMultiRest (hum::HumdrumFile &infile)
 
bool analyzeBreaks (hum::HumdrumFile &infile)
 
void addSystemClefKeyTimeChange (int startline, int endline)
 
void prepareSections ()
 
int getDirection (const std::string &token, const std::string &target)
 
void resolveTupletBeamTie (std::vector< humaux::HumdrumBeamAndTuplet > &tg)
 
void resolveTupletBeamStartTie (std::vector< humaux::HumdrumBeamAndTuplet > &tg, int index)
 
void resolveTupletBeamEndTie (std::vector< humaux::HumdrumBeamAndTuplet > &tg, int index)
 
void mergeTupletsCuttingBeam (std::vector< humaux::HumdrumBeamAndTuplet > &tg)
 
void embedQstampInClass (vrv::Note *note, hum::HTp token, const std::string &tstring)
 
void embedQstampInClass (vrv::Rest *note, hum::HTp token, const std::string &tstring)
 
void embedQstampInClass (vrv::MRest *mrest, hum::HTp token, const std::string &tstring)
 
void embedQstampInClass (vrv::Space *irest, hum::HTp token, const std::string &tstring)
 
void embedPitchInformationInClass (vrv::Note *note, const std::string &token)
 
void embedTieInformation (Note *note, const std::string &token)
 
void splitSyllableBySpaces (std::vector< std::string > &vtext, char spacer=' ')
 
void addDefaultTempo (ScoreDef *scoreDef)
 
int getChordNoteCount (hum::HTp token)
 
bool isLeftmostSystemArpeggio (hum::HTp token)
 
bool isLeftmostStaffArpeggio (hum::HTp token)
 
std::vector< hum::HTp > getSystemArpeggioTokens (hum::HTp token)
 
std::vector< hum::HTp > getStaffArpeggioTokens (hum::HTp token)
 
void addDirection (const std::string &text, const std::string &placement, bool bold, bool italic, hum::HTp token, int staffindex, int justification=0, const std::string &color="", int vgroup=-1, const std::string &label="")
 
bool addTempoDirection (const std::string &text, const std::string &placement, bool bold, bool italic, hum::HTp token, int staffindex, int justification, const std::string &color)
 
bool setTempoContent (Tempo *tempo, const std::string &text)
 
bool setLabelContent (Label *label, const std::string &text)
 
std::vector< std::string > convertMusicSymbolNameToSmuflName (const std::string &text)
 
void processTerminalLong (hum::HTp token)
 
void processTerminalBreve (hum::HTp token)
 
void removeCharacter (hum::HTp token, char removechar)
 
std::string getSystemDecoration (const std::string &tag)
 
bool processStaffDecoration (const std::string &decoration)
 
int getStaffNumberLabel (hum::HTp spinestart)
 
int getGroupNumberLabel (hum::HTp spinestart)
 
int getPartNumberLabel (hum::HTp spinestart)
 
bool isFirstTokenOnStaff (hum::HTp token)
 
bool hasAboveParameter (hum::HTp token, const std::string &category)
 
bool hasAboveParameter (hum::HTp token, const std::string &category, int &output)
 
bool hasBelowParameter (hum::HTp token, const std::string &category)
 
bool hasBelowParameter (hum::HTp token, const std::string &category, int &output)
 
bool hasCenterParameter (hum::HTp token, const std::string &category, int &output)
 
void prepareHeaderFooter ()
 
bool prepareHeader (std::vector< std::pair< std::string, std::string >> &biblist, std::map< std::string, std::string > &refmap)
 
bool prepareFooter (std::vector< std::pair< std::string, std::string >> &biblist, std::map< std::string, std::string > &refmap)
 
std::string processReferenceTemplate (const std::string &input, std::vector< std::pair< std::string, std::string >> &biblist, std::map< std::string, std::string > &refmap)
 
std::string processTemplateOperator (const std::string &value, const std::string &op)
 
std::string automaticHeaderLeft (std::vector< std::pair< std::string, std::string >> &biblist, std::map< std::string, std::string > &refmap, int linecount)
 
std::string automaticHeaderCenter (std::vector< std::pair< std::string, std::string >> &biblist, std::map< std::string, std::string > &refmap)
 
std::string automaticHeaderRight (std::vector< std::pair< std::string, std::string >> &biblist, std::map< std::string, std::string > &refmap, int &linecount)
 
void convertMensuralToken (std::vector< std::string > &elements, std::vector< void * > &pointers, hum::HTp token, int staffindex)
 
void initializeSpineColor (hum::HumdrumFile &infile)
 
void setStemLength (Note *note, hum::HTp token)
 
void storeExpansionLists (Section *section, hum::HTp starting)
 
int getStaffAdjustment (hum::HTp token)
 
void calculateNoteIdForSlur (std::string &idstring, std::vector< pair< int, int >> &sortednotes, int index)
 
void promoteInstrumentNamesToGroup ()
 
void promoteInstrumentsForStaffGroup (StaffGrp *group)
 
void promoteInstrumentAbbreviationsToGroup ()
 
void promoteInstrumentAbbreviationsForStaffGroup (StaffGrp *group)
 
void setGroupSymbol (StaffGrp *sg, staffGroupingSym_SYMBOL symbol)
 
std::string getInstrumentName (StaffDef *sd)
 
std::string getInstrumentAbbreviation (StaffDef *sd)
 
std::string getInstrumentClass (hum::HTp start)
 
void removeInstrumentName (StaffDef *sd)
 
void removeInstrumentAbbreviation (StaffDef *sd)
 
std::string getStartIdForOttava (hum::HTp token)
 
std::string getEndIdForOttava (hum::HTp token)
 
void prepareInitialOttavas (hum::HTp measure)
 
void linkFingeringToNote (Fing *fing, hum::HTp token, int xstaffindex)
 
bool checkForTupletForcedBreak (const std::vector< hum::HTp > &duritems, int index)
 
void extractSlurNoteAttachmentInformation (std::vector< std::pair< int, bool >> &data, hum::HTp token, char slurtype)
 
void extractPhraseNoteAttachmentInformation (std::vector< std::pair< int, bool >> &data, hum::HTp token, char phrasetype)
 
bool getNoteStateSlur (hum::HTp token, int slurnumber)
 
bool getNoteStatePhrase (hum::HTp token, int phrasenumber)
 
void assignVerticalGroup (Pedal *ped, hum::HTp token)
 
void storeAcclev (const std::string value, int staffindex)
 
void storeStemInterpretation (const std::string &value, int staffindex, int layernumber)
 
bool getBooleanParameter (hum::HTp token, const std::string &category, const std::string &key)
 
std::string getStringParameter (hum::HTp token, const std::string &category, const std::string &key)
 
bool shouldHideBeamBracket (const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< hum::HTp > &layerdata, int layerindex)
 
void checkBeamWith (Beam *beam, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, std::vector< hum::HTp > &layerdata, int startindex)
 
std::string getTrackText (hum::HTp token)
 
void checkForLayoutBreak (int line)
 
std::string removeCommas (const std::string &input)
 
void extractNullInformation (vector< bool > &nulls, hum::HumdrumFile &infile)
 
void initializeIgnoreVector (hum::HumdrumFile &infile)
 
bool hasIndent (hum::HTp tok)
 
void prepareNonStandardKeySignature (KeySig *vrvkeysig, const std::string &ks, hum::HTp keytok)
 
void fixLargeTuplets (std::vector< humaux::HumdrumBeamAndTuplet > &tg)
 
void addSlurLineStyle (Slur *element, hum::HTp token, int slurindex)
 
void addTieLineStyle (Tie *element, hum::HTp token, int noteindex)
 
void setAccid (Accid *accid, const std::string &loaccid)
 
bool phraseIsInvisible (hum::HTp token, int pindex)
 
hum::HumNum getLeftNoteDuration (hum::HTp token)
 
void checkClefBufferForSameAs ()
 
void suppressBufferedClef (int index)
 
void addExplicitStemDirection (FTrem *ftrem, hum::HTp start)
 
void addSlur (FTrem *ftrem, hum::HTp start, hum::HTp ending)
 
void addFTremSlurs ()
 
std::vector< int > getStaffNumbers (std::string &deco)
 
int insertRepetitionElement (std::vector< string > &elements, std::vector< void * > &pointers, std::vector< hum::HTp > tokens, int index)
 
void setRepeatSlashes (BeatRpt *repeat, std::vector< hum::HTp > &tokens, int index)
 
std::string getLabelFromInstrumentCode (hum::HTp icode, const std::string &transpose)
 
void checkForGlobalRehearsal (int line)
 
bool isBlackNotation (hum::HTp starting)
 
std::string checkNoteForScordatura (const std::string &token)
 
bool checkForScordatura (hum::HumdrumFile &infile)
 
void adjustMeasureTimings (hum::HumdrumFile &infile)
 
void fillEmptyLayer (int staffindex, int layerindex, std::vector< std::string > &elements, std::vector< void * > &pointers)
 
bool processOverfillingNotes (hum::HTp token)
 
bool isNextBarIgnored (hum::HTp token)
 
void hideTerminalBarlines (hum::HumdrumFile &infile)
 
void hideBarlinesInTiedGroup (hum::HTp startnote)
 
int getMultiEndline (int startindex)
 
void processHangingTieEnd (Note *note, hum::HTp token, const std::string &tstring, int subindex, hum::HumNum meterunit)
 
void processHangingTieStarts ()
 
void processHangingTieStart (humaux::HumdrumTie &tieinfo)
 
bool atEndingBoundaryStart (hum::HTp token)
 
bool atEndingBoundaryEnd (hum::HTp token)
 
Tie * tieToPreviousItem (hum::HTp token, int subindex, hum::HumNum meterunit, Measure *measure=NULL)
 
Tie * addHangingTieToNextItem (hum::HTp token, int subindex, hum::HumNum meterunit, Measure *measure)
 
bool inDifferentEndings (hum::HTp token1, hum::HTp token2)
 
bool checkIfSlurIsInvisible (hum::HTp stoken, int snumber, hum::HTp etoken, int enumber)
 
void checkForTupletMergesAndSplits (std::vector< int > &tupletgroups, std::vector< hum::HTp > &duritems, std::vector< hum::HumNum > &durations, std::vector< bool > &durforce)
 
bool hasLayoutParameter (hum::HTp token, const std::string &category, const std::string &param)
 
void assignTupletScalings (std::vector< humaux::HumdrumBeamAndTuplet > &tg)
 
std::string getLayoutParameter (hum::HTp token, const std::string &category, const std::string &catkey, const std::string &trueString, const std::string &falseString="")
 
void analyzeClefNulls (hum::HumdrumFile &infile)
 
void markAdjacentNullsWithClef (hum::HTp clef)
 
void markOtherClefsAsChange (hum::HTp clef)
 
int getCurrentLayerCount (hum::HTp token)
 
void checkForBreak (hum::HumdrumFile &infile, int line)
 
bool hasMensuralStaff (hum::HLp line)
 
int getNextBarlineIndex (hum::HumdrumFile &infile, int startline)
 
std::string escapeFreeAmpersand (const std::string &value)
 
void addHairpinAccent (hum::HTp token)
 
void handleCustos (std::vector< string > &elements, std::vector< void * > &pointers, std::vector< hum::HTp > tokens, int index)
 
hum::HTp getAssociatedDynamSpine (hum::HTp stafftok)
 
hum::HTp getPreviousStaffToken (hum::HTp parttok)
 
void checkForVerseLabels (hum::HTp token)
 
std::vector< hum::HTp > getVerseLabels (hum::HTp token, int staff)
 
std::vector< hum::HTp > getVerseAbbrLabels (hum::HTp token, int staff)
 
std::string getVerseLabelText (hum::HTp token)
 
void addPlicaUp (Note *note)
 
void addPlicaDown (Note *note)
 
void setLayoutSlurDirection (Slur *slur, hum::HTp token)
 
void setFontStyle (Rend *rend, const std::string &fontstyle)
 
void setFontWeight (Rend *rend, const std::string &fontweight)
 
void importVerovioOptions (Doc *doc)
 
void adjustChordNoteDurations (Chord *chord, std::vector< Note * > &notes, std::vector< string > &tstrings)
 
void adjustChordNoteDuration (Note *note, hum::HumNum hdur, int dur, int dots, hum::HumNum chorddur, const std::string &tstring, hum::HumNum factor)
 
void setNoteMeiDur (Note *note, int meidur)
 
void storeExpansionListsInChoice (Section *section, std::vector< hum::HTp > &expansions)
 
double getMmTempo (hum::HTp token, bool checklast=false)
 
double getMmTempoForward (hum::HTp token)
 
bool isNearOmd (hum::HTp token)
 
void handleTempoChange (hum::HTp token)
 
bool hasTempoTextAfter (hum::HTp token)
 
bool isTempoishText (hum::HTp token)
 
bool isLastStaffTempo (hum::HTp token)
 
void addMensuralQuality (Note *note, hum::HTp token)
 
bool checkForMens (hum::HumdrumFile &infile)
 
bool layerOnlyContainsNullStuff (std::vector< hum::HTp > &data)
 
int getNoteStaff (hum::HTp token, int homestaff)
 
void addBarLineElement (hum::HTp bartok, std::vector< std::string > &elements, std::vector< void * > &pointers)
 
void prepareFingerings (hum::HumdrumFile &infile)
 
void prepareFingerings (hum::HTp fstart)
 
std::string getLoColor (hum::HTp token, const std::string &category, int subtoken=0)
 
bool isTieAllowedToHang (hum::HTp token)
 
void analyzeVerseColor (hum::HumdrumFile &infile)
 
void analyzeVerseColor (hum::HTp &token)
 
void processHangingTieEnds ()
 
bool checkForInvisibleBeam (Beam *beam, const std::vector< humaux::HumdrumBeamAndTuplet > &tgs, int layerindex)
 
void insertBeamSpan (hum::HTp token)
 
std::string getDataTokenId (hum::HTp token)
 
void checkForFingeredHarmonic (Chord *chord, hum::HTp token)
 
double getGlobalTempoScaling (hum::HumdrumFile &infile)
 
bool isTacet (hum::HTp spinestart)
 
void storeBeamSpansInStartingMeasure ()
 
hum::HTp getNextNonNullDataOrMeasureToken (hum::HTp tok)
 
void setBeamSpanPlist (BeamSpan *beamspan, hum::HTp starttok, hum::HTp etok)
 
void checkMeterSigParameters (MeterSig *msig, hum::HTp timesigtok)
 
bool checkForJoin (Note *note, hum::HTp token)
 
bool checkForLayerJoin (int staffindex, int layerindex)
 
void storeTupletAndBeamInfoInTokens (std::vector< humaux::HumdrumBeamAndTuplet > &tgs)
 
std::vector< hum::HTp > getBeamNotes (hum::HTp token, int beamstart)
 
bool checkForBeamSameas (Beam *beam, std::vector< hum::HTp > &layerdata, int layerindex)
 
bool checkForBeamStemSameas (std::vector< hum::HTp > &layerdata, int layerindex)
 
void processInterpretationStuff (hum::HTp token, int staffindex)
 
void insertGlissandos (std::vector< hum::HTp > &tokens)
 
void createGlissando (hum::HTp glissStart, hum::HTp glissEnd)
 
void setSmuflContent (Symbol *symbol, const std::string &name)
 
data_DURATION oneOverDenominatorToDur (int denominator)
 
bool isExpressibleDuration (hum::HumNum duration)
 
pair< data_DURATION, int > getDurAndDots (hum::HumNum duration)
 
void checkForClefStyling (Clef *clef, hum::HTp token)
 
void setClefColorOrEditorial (hum::HTp token, Clef *clef, std::vector< std::string > &elements, std::vector< void * > &pointers)
 
void setClefOctaveDisplacement (Clef *clef, const std::string &token)
 
void setClefBasicShape (Clef *clef, const std::string &tok)
 
void setClefStaffLine (Clef *clef, const std::string &tok)
 
void analyzeHarmInterpretations (hum::HTp starttok)
 
void analyzeDegreeInterpretations (hum::HTp starttok)
 
void analyzeTextInterpretation (hum::HTp starttok)
 
void addHarmLabel (hum::HumNum timestamp, const std::string &label, const std::string &labelStyle, const std::string &n, const std::string &place, int staffNum)
 
std::u32string getMoveableDoName (hum::HTp token, int degree, int semitones)
 
void setFontsizeForHarm (Harm *harm, const std::string &fontsize)
 
void setFontStyleForHarm (Harm *harm, const std::string &style)
 
std::u32string addSemitoneAdjustmentsToDeg (hum::HTp token, int arrowQ, int accidQ, int solfegeQ, int sharps, int flats)
 
int hasParallelNote (hum::HTp token)
 
void setHarmContent (Rend *rend, hum::HTp token)
 
std::string removeRecipFromHarmContent (const std::string &input)
 
void setMxHarmContent (Rend *rend, const std::string &content)
 
void setDegreeContent (Rend *rend, hum::HTp token, int n=0)
 
std::u32string cleanStringString (const std::string &content)
 
std::vector< std::u32string > cleanFBString (std::vector< std::string > &pieces, hum::HTp token)
 
std::u32string cleanFBString2 (std::vector< std::string > &pieces, hum::HTp token)
 
std::vector< std::string > splitFBString (const std::string &content, const std::string &separator=" ")
 
std::u32string getVisualFBAccidental (int accidental)
 
std::u32string convertFBNumber (const std::string &input, hum::HTp token)
 
void checkForLineContinuations (hum::HTp token)
 
std::u32string convertNumberToWstring (int number)
 
void appendTextToRend (Rend *rend, const std::string &content)
 
void parseMultiVerovioOptions (std::map< std::string, std::string > &parameters, const std::string &input)
 
void addSforzandoToNote (hum::HTp token, int staffindex)
 
void addDynamicsMark (hum::HTp dyntok, hum::HTp token, hum::HLp line, const std::string &letters, int staffindex, int staffadj, int trackdiff)
 
bool hasNoStaves (hum::HumdrumFile &infile)
 
hum::HTp getVisualKeySignature (hum::HTp keysigtok)
 
bool isNotAtStartOfMeasure (std::vector< hum::HTp > &layerdata, int index)
 
void analyzeFingerings (hum::HumdrumFile &infile)
 
void analyzeFingerings (hum::HTp sstart)
 
void insertMidMeasureKeySignature (int staffindex, std::vector< std::string > &elements, std::vector< void * > &pointers, hum::HTp token)
 
int getKeySignatureNumber (const std::string &humkeysig)
 
int getStaffNumForSpine (hum::HTp token)
 
bool checkIfReversedSpineOrder (std::vector< hum::HTp > &staffstarts)
 
bool hasOmdText (int startline, int endline)
 
void processMeiOptions (hum::HumdrumFile &infile)
 
std::string getInstrumentNumber (hum::HTp icode)
 
void insertTextWithNewlines (Label *label, const std::string &text)
 
bool hasBounceAfter (hum::HTp token)
 
bool hasBounceBefore (hum::HTp token)
 
void analyzeDefaultLayoutStyles (hum::HumdrumFile &infile)
 
std::string getDefaultLayoutParameter (const std::string &category, const std::string &parameter)
 
void createHeader ()
 
void createFileDesc (pugi::xml_node meiHead)
 
void createDigitalSource (pugi::xml_node sourceDesc)
 
void createPrintedSource (pugi::xml_node sourceDesc)
 
void createRecordedSource (pugi::xml_node sourceDesc)
 
void createUnpublishedSource (pugi::xml_node sourceDesc)
 
void createEncodingDesc (pugi::xml_node meiHead)
 
void createWorkList (pugi::xml_node meiHead)
 
void createHumdrumVerbatimExtMeta (pugi::xml_node meiHead)
 
void createBackMatter ()
 
void createSimpleTitleElement ()
 
void createSimpleComposerElements ()
 
void createTitleElements (pugi::xml_node element)
 
void createComposerElements (pugi::xml_node element)
 
void fillInIsoDate (pugi::xml_node element, const std::string &dateString)
 
std::map< std::string, std::string > isoDateAttributesFromHumdrumDate (const std::string &inHumdrumDate, bool edtf=false)
 
DateConstruct dateConstructFromHumdrumDate (const std::string &dateString)
 
std::map< std::string, std::string > isoDateAttributesFromDateConstruct (const DateConstruct &dateConstruct, bool edtf, bool isEdgeOfDateConstructRange=false)
 
std::string isoDateFromDateWithErrors (const DateWithErrors &dateWithErrors, bool edtf)
 
DateWithErrors dateWithErrorsFromHumdrumDate (const std::string &dateString)
 
bool sanityCheckDate (int year, int month, int day, int hour, int minute, int second)
 
std::string stripDateError (std::string &value)
 
std::string getTextListLanguage (const std::vector< HumdrumReferenceItem > &textItems)
 
std::map< std::string, std::vector< HumdrumReferenceItem > > getAllReferenceItems (hum::HumdrumFile &infile)
 
std::vector< HumdrumReferenceItem > getReferenceItems (const std::string &key)
 
bool anyReferenceItemsExist (const std::vector< string > &keys)
 
int getBestItem (const std::vector< HumdrumReferenceItem > &items, const std::string &requiredLanguage)
 
bool isStandardHumdrumKey (const std::string &key)
 
void appendText (pugi::xml_node element, std::string text)
 
void addDefaultTempoDist (double distance)
 
template<class ELEMENT >
void verticalRest (ELEMENT rest, const std::string &token)
 Templates ///////////////////////////////////////////////////////////.
 
template<class ELEMENT >
void setKeySig (int partindex, ELEMENT element, const std::string &keysig, hum::HTp keysigtok, hum::HTp keytok, bool secondary)
 
template<class ELEMENT >
void setKeySig (ELEMENT *element, hum::HTp keysigtok)
 
template<class PARENT , class CHILD >
void appendElement (PARENT parent, CHILD child)
 
template<class ELEMENT >
void addArticulations (ELEMENT element, hum::HTp token)
 
template<class ELEMENT >
hum::HumNum convertRhythm (ELEMENT element, hum::HTp token, int subtoken=-1)
 
template<class ELEMENT >
void setRhythmFromDuration (ELEMENT element, hum::HumNum dur)
 
template<class ELEMENT >
void setVisualAndGesturalRhythmFromDuration (ELEMENT element, hum::HumNum visdur, hum::HumNum gesdur)
 
template<class ELEMENT >
hum::HumNum convertMensuralRhythm (ELEMENT element, hum::HTp token, int subtoken=-1)
 
template<class ELEMENT >
hum::HumNum setDuration (ELEMENT element, hum::HumNum duration)
 
template<class ELEMENT >
void setStaff (ELEMENT element, int staffnum)
 
template<class ELEMENT >
void setStaffBetween (ELEMENT element, int staffnum)
 
template<class ELEMENT >
void setN (ELEMENT element, int nvalue, hum::HTp tok=NULL)
 
template<class ELEMENT >
void assignAutomaticStem (ELEMENT element, hum::HTp tok, int staffindex)
 
template<class ELEMENT >
KeySig * getKeySig (ELEMENT element)
 
template<class ELEMENT >
MeterSig * getMeterSig (ELEMENT element)
 
template<class ELEMENT >
Clef * getClef (ELEMENT element)
 
template<class ELEMENT >
Mensur * getMensur (ELEMENT element, hum::HTp token=NULL)
 
template<class ELEMENT >
void insertPhrase (ELEMENT phrase, hum::HTp phrasestart, hum::HTp phraseend, Measure *startmeasure, std::vector< pair< int, int >> &endchordsorted, std::vector< std::pair< int, int >> &startchordsorted, std::vector< pair< int, bool >> &phrasestartnoteinfo, std::vector< pair< int, bool >> &phraseendnoteinfo, int ndex, std::vector< std::vector< int >> &phraseindex, int i, int j, std::vector< int > &startpitches, std::vector< int > &endpitches, std::vector< bool > &indexused)
 
template<class ELEMENT >
void convertVerses (ELEMENT element, hum::HTp token)
 
template<class ELEMENT >
void setTimeSig (ELEMENT element, hum::HTp timesigtok, hum::HTp metersigtok, int staffindex)
 
template<class ELEMENT >
void addChildBackMeasureOrSection (ELEMENT element)
 
template<class ELEMENT >
void addChildMeasureOrSection (ELEMENT element, Measure *measure=NULL)
 
template<class CHILD >
void appendElement (const std::vector< std::string > &name, const std::vector< void * > &pointers, CHILD child)
 
void popElementStack (std::vector< std::string > &elements, std::vector< void * > &pointers)
 
template<class ELEMENT >
void addTextElement (ELEMENT *element, const std::string &content, const std::string &fontstyle="", bool addSpacer=true, const std::string &label="")
 
template<class ELEMENT >
void addMusicSymbol (ELEMENT *element, const std::string &musictext)
 
template<class ELEMENT >
void checkForAutoStem (ELEMENT element, hum::HTp token)
 
template<class ELEMENT >
void appendTypeTag (ELEMENT *element, const std::string &tag)
 
template<class ELEMENT >
void setPlaceRelStaff (ELEMENT *element, const std::string &place, bool showplace=false)
 
template<class ELEMENT >
void setPlaceRelEvent (ELEMENT *element, const std::string &place, bool showplace=false)
 
template<class ELEMENT >
void setMeterSymbol (ELEMENT *element, const std::string &metersig, int staffindex, hum::HTp partstart=NULL, hum::HTp metertok=NULL)
 
template<class ELEMENT >
void setMensurationSymbol (ELEMENT *element, const std::string &metersig, int staffindex, hum::HTp mensurtok=NULL)
 
template<class ELEMENT >
void setInstrumentName (ELEMENT *staffdef, const std::string &name, hum::HTp labeltok=NULL)
 
template<class ELEMENT >
void setInstrumentAbbreviation (ELEMENT *staffdef, const std::string &name, hum::HTp abbrtok)
 
template<class ELEMENT >
void addDurRecip (ELEMENT element, const std::string &ttoken)
 
template<class ELEMENT >
void addFermata (ELEMENT *rest, const std::string &tstring)
 
template<class ELEMENT >
void storeExpansionList (ELEMENT *parent, hum::HTp etok)
 
template<class ELEMENT >
void setWrittenAccidentalUpper (ELEMENT element, const std::string &value)
 
template<class ELEMENT >
void setWrittenAccidentalLower (ELEMENT element, const std::string &value)
 
template<class ELEMENT >
void attachToToken (ELEMENT *element, hum::HTp token)
 
template<class ELEMENT >
void setAttachmentType (ELEMENT *element, hum::HTp token)
 
template<class ELEMENT >
void setFontsize (ELEMENT *element, const std::string &percentage, const std::string &original)
 
template<class ELEMENT >
void setTstamp (ELEMENT *element, const string &value)
 
template<class ELEMENT >
void setEnclosure (ELEMENT *element, const string &value)
 

Static Protected Member Functions

static std::string unescapeHtmlEntities (const std::string &input)
 Static functions ////////////////////////////////////////////////////.
 
static void WriteUTF8 (std::ostream &Out, unsigned int Ch)
 
static void UnquoteHTML (std::istream &In, std::ostream &Out)
 
static hum::HumNum removeFactorsOfTwo (hum::HumNum value, int &tcount, int &bcount)
 
static int getDotPowerOfTwo (hum::HumNum value)
 
static int nextLowerPowerOfTwo (int x)
 
static hum::HumNum nextHigherPowerOfTwo (hum::HumNum x)
 
static std::string getDateString ()
 
static bool replace (std::string &str, const std::string &oldStr, const std::string &newStr)
 
static bool replace (std::u32string &str, const std::u32string &oldStr, const std::u32string &newStr)
 

Additional Inherited Members

- Protected Attributes inherited from vrv::Input
Doc * m_doc
 
LayoutInformation m_layoutInformation
 Indicates if we have layout information in the file loaded. More...
 
std::string m_outformat = "mei"
 
The documentation for this class was generated from the following file: