Verovio
Source code documentation
functorinterface.h
1 // Name: functorinterface.h
3 // Author: David Bauer
4 // Created: 2022
5 // Copyright (c) Authors and others. All rights reserved.
7 
8 #ifndef __VRV_FUNCTOR_INTERFACE_H__
9 #define __VRV_FUNCTOR_INTERFACE_H__
10 
11 #include "vrvdef.h"
12 
13 namespace vrv {
14 
15 class Accid;
16 class Alignment;
17 class AlignmentReference;
18 class AnchoredText;
19 class AnnotScore;
20 class Arpeg;
21 class Artic;
22 class BarLine;
23 class Beam;
24 class BeamSpan;
25 class BeatRpt;
26 class BracketSpan;
27 class Breath;
28 class BTrem;
29 class Caesura;
30 class Chord;
31 class Clef;
32 class ControlElement;
33 class Course;
34 class CpMark;
35 class Custos;
36 class Dir;
37 class Div;
38 class Dot;
39 class Dots;
40 class Doc;
41 class Dynam;
42 class EditorialElement;
43 class Ending;
44 class Expansion;
45 class F;
46 class Facsimile;
47 class Fb;
48 class Fermata;
49 class Fing;
50 class Fig;
51 class Flag;
52 class FloatingObject;
53 class FTrem;
54 class GenericLayerElement;
55 class Gliss;
56 class GraceAligner;
57 class GraceGrp;
58 class Graphic;
59 class GrpSym;
60 class Hairpin;
61 class HalfmRpt;
62 class Harm;
63 class HorizontalAligner;
64 class InstrDef;
65 class KeyAccid;
66 class KeySig;
67 class Label;
68 class LabelAbbr;
69 class Layer;
70 class LayerDef;
71 class LayerElement;
72 class Lb;
73 class Ligature;
74 class Lv;
75 class Mdiv;
76 class Measure;
77 class MeasureAligner;
78 class Mensur;
79 class MeterSig;
80 class MeterSigGrp;
81 class Mordent;
82 class MNum;
83 class MRest;
84 class MRpt;
85 class MRpt2;
86 class MSpace;
87 class MultiRest;
88 class MultiRpt;
89 class Nc;
90 class Neume;
91 class Note;
92 class Num;
93 class Object;
94 class Octave;
95 class Ornam;
96 class Page;
97 class PageElement;
98 class PageMilestoneEnd;
99 class Pages;
100 class Pb;
101 class Pedal;
102 class PgFoot;
103 class PgHead;
104 class Phrase;
105 class PitchInflection;
106 class Plica;
107 class Proport;
108 class RepeatMark;
109 class Reh;
110 class Rend;
111 class Rest;
112 class RunningElement;
113 class Sb;
114 class Score;
115 class ScoreDef;
116 class ScoreDefElement;
117 class Section;
118 class Slur;
119 class Space;
120 class Staff;
121 class StaffAlignment;
122 class StaffDef;
123 class StaffGrp;
124 class Stem;
125 class Surface;
126 class Svg;
127 class Syl;
128 class Syllable;
129 class Symbol;
130 class System;
131 class SystemAligner;
132 class SystemElement;
133 class SystemMilestoneEnd;
134 class TabDurSym;
135 class TabGrp;
136 class Tempo;
137 class Text;
138 class TextElement;
139 class TextLayoutElement;
140 class Tie;
141 class TimestampAligner;
142 class TimestampAttr;
143 class Trill;
144 class Tuning;
145 class Tuplet;
146 class TupletBracket;
147 class TupletNum;
148 class Turn;
149 class Verse;
150 class Zone;
151 
152 //----------------------------------------------------------------------------
153 // FunctorInterface
154 //----------------------------------------------------------------------------
155 
160 class FunctorInterface {
161 public:
166  FunctorInterface() {}
167  virtual ~FunctorInterface() = default;
169 
174  virtual FunctorCode VisitObject(Object *) { return FUNCTOR_CONTINUE; }
175  virtual FunctorCode VisitObjectEnd(Object *) { return FUNCTOR_CONTINUE; }
176  virtual FunctorCode VisitDoc(Doc *doc);
177  virtual FunctorCode VisitDocEnd(Doc *doc);
179 
184  virtual FunctorCode VisitCourse(Course *course);
185  virtual FunctorCode VisitCourseEnd(Course *course);
186  virtual FunctorCode VisitGrpSym(GrpSym *grpSym);
187  virtual FunctorCode VisitGrpSymEnd(GrpSym *grpSym);
188  virtual FunctorCode VisitInstrDef(InstrDef *instrDef);
189  virtual FunctorCode VisitInstrDefEnd(InstrDef *instrDef);
190  virtual FunctorCode VisitLabel(Label *label);
191  virtual FunctorCode VisitLabelEnd(Label *label);
192  virtual FunctorCode VisitLabelAbbr(LabelAbbr *labelAbbr);
193  virtual FunctorCode VisitLabelAbbrEnd(LabelAbbr *labelAbbr);
194  virtual FunctorCode VisitLayer(Layer *layer);
195  virtual FunctorCode VisitLayerEnd(Layer *layer);
196  virtual FunctorCode VisitLayerDef(LayerDef *layerDef);
197  virtual FunctorCode VisitLayerDefEnd(LayerDef *layerDef);
198  virtual FunctorCode VisitMeasure(Measure *measure);
199  virtual FunctorCode VisitMeasureEnd(Measure *measure);
200  virtual FunctorCode VisitPage(Page *page);
201  virtual FunctorCode VisitPageEnd(Page *page);
202  virtual FunctorCode VisitPages(Pages *pages);
203  virtual FunctorCode VisitPagesEnd(Pages *pages);
204  virtual FunctorCode VisitPb(Pb *pb);
205  virtual FunctorCode VisitPbEnd(Pb *pb);
206  virtual FunctorCode VisitSb(Sb *sb);
207  virtual FunctorCode VisitSbEnd(Sb *sb);
208  virtual FunctorCode VisitScoreDef(ScoreDef *scoreDef);
209  virtual FunctorCode VisitScoreDefEnd(ScoreDef *scoreDef);
210  virtual FunctorCode VisitScoreDefElement(ScoreDefElement *scoreDefElement);
211  virtual FunctorCode VisitScoreDefElementEnd(ScoreDefElement *scoreDefElement);
212  virtual FunctorCode VisitStaff(Staff *staff);
213  virtual FunctorCode VisitStaffEnd(Staff *staff);
214  virtual FunctorCode VisitStaffDef(StaffDef *staffDef);
215  virtual FunctorCode VisitStaffDefEnd(StaffDef *staffDef);
216  virtual FunctorCode VisitStaffGrp(StaffGrp *staffGrp);
217  virtual FunctorCode VisitStaffGrpEnd(StaffGrp *staffGrp);
218  virtual FunctorCode VisitSystem(System *system);
219  virtual FunctorCode VisitSystemEnd(System *system);
220  virtual FunctorCode VisitTuning(Tuning *tuning);
221  virtual FunctorCode VisitTuningEnd(Tuning *tuning);
223 
229  virtual FunctorCode VisitEditorialElement(EditorialElement *editorialElement);
230  virtual FunctorCode VisitEditorialElementEnd(EditorialElement *editorialElement);
232 
237  virtual FunctorCode VisitDiv(Div *div);
238  virtual FunctorCode VisitDivEnd(Div *div);
239  virtual FunctorCode VisitRunningElement(RunningElement *runningElement);
240  virtual FunctorCode VisitRunningElementEnd(RunningElement *runningElement);
241  virtual FunctorCode VisitPgFoot(PgFoot *pgFoot);
242  virtual FunctorCode VisitPgFootEnd(PgFoot *pgFoot);
243  virtual FunctorCode VisitPgHead(PgHead *pgHead);
244  virtual FunctorCode VisitPgHeadEnd(PgHead *pgHead);
245  virtual FunctorCode VisitTextLayoutElement(TextLayoutElement *textLayoutElement);
246  virtual FunctorCode VisitTextLayoutElementEnd(TextLayoutElement *textLayoutElement);
248 
253  virtual FunctorCode VisitEnding(Ending *ending);
254  virtual FunctorCode VisitEndingEnd(Ending *ending);
255  virtual FunctorCode VisitExpansion(Expansion *expansion);
256  virtual FunctorCode VisitExpansionEnd(Expansion *expansion);
257  virtual FunctorCode VisitSection(Section *section);
258  virtual FunctorCode VisitSectionEnd(Section *section);
259  virtual FunctorCode VisitSystemElement(SystemElement *systemElement);
260  virtual FunctorCode VisitSystemElementEnd(SystemElement *systemElement);
261  virtual FunctorCode VisitSystemMilestone(SystemMilestoneEnd *systemMilestoneEnd);
262  virtual FunctorCode VisitSystemMilestoneEnd(SystemMilestoneEnd *systemMilestoneEnd);
264 
269  virtual FunctorCode VisitMdiv(Mdiv *mdiv);
270  virtual FunctorCode VisitMdivEnd(Mdiv *mdiv);
271  virtual FunctorCode VisitPageElement(PageElement *pageElement);
272  virtual FunctorCode VisitPageElementEnd(PageElement *pageElement);
273  virtual FunctorCode VisitPageMilestone(PageMilestoneEnd *pageMilestoneEnd);
274  virtual FunctorCode VisitPageMilestoneEnd(PageMilestoneEnd *pageMilestoneEnd);
275  virtual FunctorCode VisitScore(Score *score);
276  virtual FunctorCode VisitScoreEnd(Score *score);
278 
283  virtual FunctorCode VisitAnchoredText(AnchoredText *anchoredText);
284  virtual FunctorCode VisitAnchoredTextEnd(AnchoredText *anchoredText);
285  virtual FunctorCode VisitAnnotScore(AnnotScore *annotScore);
286  virtual FunctorCode VisitAnnotScoreEnd(AnnotScore *annotScore);
287  virtual FunctorCode VisitArpeg(Arpeg *arpeg);
288  virtual FunctorCode VisitArpegEnd(Arpeg *arpeg);
289  virtual FunctorCode VisitBeamSpan(BeamSpan *beamSpan);
290  virtual FunctorCode VisitBeamSpanEnd(BeamSpan *beamSpan);
291  virtual FunctorCode VisitBracketSpan(BracketSpan *bracketSpan);
292  virtual FunctorCode VisitBracketSpanEnd(BracketSpan *bracketSpan);
293  virtual FunctorCode VisitBreath(Breath *breath);
294  virtual FunctorCode VisitBreathEnd(Breath *breath);
295  virtual FunctorCode VisitCaesura(Caesura *caesura);
296  virtual FunctorCode VisitCaesuraEnd(Caesura *caesura);
297  virtual FunctorCode VisitControlElement(ControlElement *controlElement);
298  virtual FunctorCode VisitControlElementEnd(ControlElement *controlElement);
299  virtual FunctorCode VisitCpMark(CpMark *cpMark);
300  virtual FunctorCode VisitCpMarkEnd(CpMark *cpMark);
301  virtual FunctorCode VisitDir(Dir *dir);
302  virtual FunctorCode VisitDirEnd(Dir *dir);
303  virtual FunctorCode VisitDynam(Dynam *dynam);
304  virtual FunctorCode VisitDynamEnd(Dynam *dynam);
305  virtual FunctorCode VisitFermata(Fermata *fermata);
306  virtual FunctorCode VisitFermataEnd(Fermata *fermata);
307  virtual FunctorCode VisitFing(Fing *fing);
308  virtual FunctorCode VisitFingEnd(Fing *fing);
309  virtual FunctorCode VisitGliss(Gliss *gliss);
310  virtual FunctorCode VisitGlissEnd(Gliss *gliss);
311  virtual FunctorCode VisitHairpin(Hairpin *hairpin);
312  virtual FunctorCode VisitHairpinEnd(Hairpin *hairpin);
313  virtual FunctorCode VisitHarm(Harm *harm);
314  virtual FunctorCode VisitHarmEnd(Harm *harm);
315  virtual FunctorCode VisitLv(Lv *lv);
316  virtual FunctorCode VisitLvEnd(Lv *lv);
317  virtual FunctorCode VisitMordent(Mordent *mordent);
318  virtual FunctorCode VisitMordentEnd(Mordent *mordent);
319  virtual FunctorCode VisitOctave(Octave *octave);
320  virtual FunctorCode VisitOctaveEnd(Octave *octave);
321  virtual FunctorCode VisitOrnam(Ornam *ornam);
322  virtual FunctorCode VisitOrnamEnd(Ornam *ornam);
323  virtual FunctorCode VisitPedal(Pedal *pedal);
324  virtual FunctorCode VisitPedalEnd(Pedal *pedal);
325  virtual FunctorCode VisitPhrase(Phrase *phrase);
326  virtual FunctorCode VisitPhraseEnd(Phrase *phrase);
327  virtual FunctorCode VisitPitchInflection(PitchInflection *pitchInflection);
328  virtual FunctorCode VisitPitchInflectionEnd(PitchInflection *pitchInflection);
329  virtual FunctorCode VisitReh(Reh *reh);
330  virtual FunctorCode VisitRehEnd(Reh *reh);
331  virtual FunctorCode VisitRepeatMark(RepeatMark *repeatMark);
332  virtual FunctorCode VisitRepeatMarkEnd(RepeatMark *repeatMark);
333  virtual FunctorCode VisitSlur(Slur *slur);
334  virtual FunctorCode VisitSlurEnd(Slur *slur);
335  virtual FunctorCode VisitTempo(Tempo *tempo);
336  virtual FunctorCode VisitTempoEnd(Tempo *tempo);
337  virtual FunctorCode VisitTie(Tie *tie);
338  virtual FunctorCode VisitTieEnd(Tie *tie);
339  virtual FunctorCode VisitTrill(Trill *trill);
340  virtual FunctorCode VisitTrillEnd(Trill *trill);
341  virtual FunctorCode VisitTurn(Turn *turn);
342  virtual FunctorCode VisitTurnEnd(Turn *turn);
344 
349  virtual FunctorCode VisitAccid(Accid *accid);
350  virtual FunctorCode VisitAccidEnd(Accid *accid);
351  virtual FunctorCode VisitArtic(Artic *artic);
352  virtual FunctorCode VisitArticEnd(Artic *artic);
353  virtual FunctorCode VisitBarLine(BarLine *barLine);
354  virtual FunctorCode VisitBarLineEnd(BarLine *barLine);
355  virtual FunctorCode VisitBeam(Beam *beam);
356  virtual FunctorCode VisitBeamEnd(Beam *beam);
357  virtual FunctorCode VisitBeatRpt(BeatRpt *beatRpt);
358  virtual FunctorCode VisitBeatRptEnd(BeatRpt *beatRpt);
359  virtual FunctorCode VisitBTrem(BTrem *bTrem);
360  virtual FunctorCode VisitBTremEnd(BTrem *bTrem);
361  virtual FunctorCode VisitChord(Chord *chord);
362  virtual FunctorCode VisitChordEnd(Chord *chord);
363  virtual FunctorCode VisitClef(Clef *clef);
364  virtual FunctorCode VisitClefEnd(Clef *clef);
365  virtual FunctorCode VisitCustos(Custos *custos);
366  virtual FunctorCode VisitCustosEnd(Custos *custos);
367  virtual FunctorCode VisitDot(Dot *dot);
368  virtual FunctorCode VisitDotEnd(Dot *dot);
369  virtual FunctorCode VisitDots(Dots *dots);
370  virtual FunctorCode VisitDotsEnd(Dots *dots);
371  virtual FunctorCode VisitFlag(Flag *flag);
372  virtual FunctorCode VisitFlagEnd(Flag *flag);
373  virtual FunctorCode VisitFTrem(FTrem *fTrem);
374  virtual FunctorCode VisitFTremEnd(FTrem *fTrem);
375  virtual FunctorCode VisitGenericLayerElement(GenericLayerElement *genericLayerElement);
376  virtual FunctorCode VisitGenericLayerElementEnd(GenericLayerElement *genericLayerElement);
377  virtual FunctorCode VisitGraceGrp(GraceGrp *graceGrp);
378  virtual FunctorCode VisitGraceGrpEnd(GraceGrp *graceGrp);
379  virtual FunctorCode VisitHalfmRpt(HalfmRpt *halfmRpt);
380  virtual FunctorCode VisitHalfmRptEnd(HalfmRpt *halfmRpt);
381  virtual FunctorCode VisitKeyAccid(KeyAccid *keyAccid);
382  virtual FunctorCode VisitKeyAccidEnd(KeyAccid *keyAccid);
383  virtual FunctorCode VisitKeySig(KeySig *keySig);
384  virtual FunctorCode VisitKeySigEnd(KeySig *keySig);
385  virtual FunctorCode VisitLayerElement(LayerElement *layerElement);
386  virtual FunctorCode VisitLayerElementEnd(LayerElement *layerElement);
387  virtual FunctorCode VisitLigature(Ligature *ligature);
388  virtual FunctorCode VisitLigatureEnd(Ligature *ligature);
389  virtual FunctorCode VisitMensur(Mensur *mensur);
390  virtual FunctorCode VisitMensurEnd(Mensur *mensur);
391  virtual FunctorCode VisitMeterSig(MeterSig *meterSig);
392  virtual FunctorCode VisitMeterSigEnd(MeterSig *meterSig);
393  virtual FunctorCode VisitMeterSigGrp(MeterSigGrp *meterSigGrp);
394  virtual FunctorCode VisitMeterSigGrpEnd(MeterSigGrp *meterSigGrp);
395  virtual FunctorCode VisitMRest(MRest *mRest);
396  virtual FunctorCode VisitMRestEnd(MRest *mRest);
397  virtual FunctorCode VisitMRpt(MRpt *mRpt);
398  virtual FunctorCode VisitMRptEnd(MRpt *mRpt);
399  virtual FunctorCode VisitMRpt2(MRpt2 *mRpt2);
400  virtual FunctorCode VisitMRpt2End(MRpt2 *mRpt2);
401  virtual FunctorCode VisitMSpace(MSpace *mSpace);
402  virtual FunctorCode VisitMSpaceEnd(MSpace *mSpace);
403  virtual FunctorCode VisitMultiRest(MultiRest *multiRest);
404  virtual FunctorCode VisitMultiRestEnd(MultiRest *multiRest);
405  virtual FunctorCode VisitMultiRpt(MultiRpt *multiRpt);
406  virtual FunctorCode VisitMultiRptEnd(MultiRpt *multiRpt);
407  virtual FunctorCode VisitNc(Nc *nc);
408  virtual FunctorCode VisitNcEnd(Nc *nc);
409  virtual FunctorCode VisitNeume(Neume *neume);
410  virtual FunctorCode VisitNeumeEnd(Neume *neume);
411  virtual FunctorCode VisitNote(Note *note);
412  virtual FunctorCode VisitNoteEnd(Note *note);
413  virtual FunctorCode VisitPlica(Plica *plica);
414  virtual FunctorCode VisitPlicaEnd(Plica *plica);
415  virtual FunctorCode VisitProport(Proport *proport);
416  virtual FunctorCode VisitProportEnd(Proport *proport);
417  virtual FunctorCode VisitRest(Rest *rest);
418  virtual FunctorCode VisitRestEnd(Rest *rest);
419  virtual FunctorCode VisitSpace(Space *space);
420  virtual FunctorCode VisitSpaceEnd(Space *space);
421  virtual FunctorCode VisitStem(Stem *stem);
422  virtual FunctorCode VisitStemEnd(Stem *stem);
423  virtual FunctorCode VisitSyl(Syl *syl);
424  virtual FunctorCode VisitSylEnd(Syl *syl);
425  virtual FunctorCode VisitSyllable(Syllable *syllable);
426  virtual FunctorCode VisitSyllableEnd(Syllable *syllable);
427  virtual FunctorCode VisitTabDurSym(TabDurSym *tabDurSym);
428  virtual FunctorCode VisitTabDurSymEnd(TabDurSym *tabDurSym);
429  virtual FunctorCode VisitTabGrp(TabGrp *tabGrp);
430  virtual FunctorCode VisitTabGrpEnd(TabGrp *tabGrp);
431  virtual FunctorCode VisitTimestamp(TimestampAttr *timestamp);
432  virtual FunctorCode VisitTimestampEnd(TimestampAttr *timestamp);
433  virtual FunctorCode VisitTuplet(Tuplet *tuplet);
434  virtual FunctorCode VisitTupletEnd(Tuplet *tuplet);
435  virtual FunctorCode VisitTupletBracket(TupletBracket *tupletBracket);
436  virtual FunctorCode VisitTupletBracketEnd(TupletBracket *tupletBracket);
437  virtual FunctorCode VisitTupletNum(TupletNum *tupletNum);
438  virtual FunctorCode VisitTupletNumEnd(TupletNum *tupletNum);
439  virtual FunctorCode VisitVerse(Verse *verse);
440  virtual FunctorCode VisitVerseEnd(Verse *verse);
442 
447  virtual FunctorCode VisitF(F *f);
448  virtual FunctorCode VisitFEnd(F *f);
449  virtual FunctorCode VisitFb(Fb *fb);
450  virtual FunctorCode VisitFbEnd(Fb *fb);
451  virtual FunctorCode VisitFig(Fig *fig);
452  virtual FunctorCode VisitFigEnd(Fig *fig);
453  virtual FunctorCode VisitLb(Lb *lb);
454  virtual FunctorCode VisitLbEnd(Lb *lb);
455  virtual FunctorCode VisitMNum(MNum *mNum);
456  virtual FunctorCode VisitMNumEnd(MNum *mNum);
457  virtual FunctorCode VisitNum(Num *num);
458  virtual FunctorCode VisitNumEnd(Num *num);
459  virtual FunctorCode VisitRend(Rend *rend);
460  virtual FunctorCode VisitRendEnd(Rend *rend);
461  virtual FunctorCode VisitSvg(Svg *svg);
462  virtual FunctorCode VisitSvgEnd(Svg *svg);
463  virtual FunctorCode VisitSymbol(Symbol *symbol);
464  virtual FunctorCode VisitSymbolEnd(Symbol *symbol);
465  virtual FunctorCode VisitText(Text *text);
466  virtual FunctorCode VisitTextEnd(Text *text);
467  virtual FunctorCode VisitTextElement(TextElement *textElement);
468  virtual FunctorCode VisitTextElementEnd(TextElement *textElement);
470 
475  virtual FunctorCode VisitFacsimile(Facsimile *facsimile);
476  virtual FunctorCode VisitFacsimileEnd(Facsimile *facsimile);
477  virtual FunctorCode VisitGraphic(Graphic *graphic);
478  virtual FunctorCode VisitGraphicEnd(Graphic *graphic);
479  virtual FunctorCode VisitSurface(Surface *surface);
480  virtual FunctorCode VisitSurfaceEnd(Surface *surface);
481  virtual FunctorCode VisitZone(Zone *zone);
482  virtual FunctorCode VisitZoneEnd(Zone *zone);
484 
489  virtual FunctorCode VisitAlignment(Alignment *alignment);
490  virtual FunctorCode VisitAlignmentEnd(Alignment *alignment);
491  virtual FunctorCode VisitAlignmentReference(AlignmentReference *alignmentReference);
492  virtual FunctorCode VisitAlignmentReferenceEnd(AlignmentReference *alignmentReference);
493  virtual FunctorCode VisitHorizontalAligner(HorizontalAligner *horizontalAligner);
494  virtual FunctorCode VisitHorizontalAlignerEnd(HorizontalAligner *horizontalAligner);
495  virtual FunctorCode VisitMeasureAligner(MeasureAligner *measureAligner);
496  virtual FunctorCode VisitMeasureAlignerEnd(MeasureAligner *measureAligner);
497  virtual FunctorCode VisitGraceAligner(GraceAligner *graceAligner);
498  virtual FunctorCode VisitGraceAlignerEnd(GraceAligner *graceAligner);
499  virtual FunctorCode VisitTimestampAligner(TimestampAligner *timestampAligner);
500  virtual FunctorCode VisitTimestampAlignerEnd(TimestampAligner *timestampAligner);
502 
507  virtual FunctorCode VisitSystemAligner(SystemAligner *systemAligner);
508  virtual FunctorCode VisitSystemAlignerEnd(SystemAligner *systemAligner);
509  virtual FunctorCode VisitStaffAlignment(StaffAlignment *staffAlignment);
510  virtual FunctorCode VisitStaffAlignmentEnd(StaffAlignment *staffAlignment);
512 
517  virtual FunctorCode VisitFloatingObject(FloatingObject *floatingObject);
518  virtual FunctorCode VisitFloatingObjectEnd(FloatingObject *floatingObject);
520 
521 private:
522  //
523 public:
524  //
525 private:
526  //
527 };
528 
529 //----------------------------------------------------------------------------
530 // ConstFunctorInterface
531 //----------------------------------------------------------------------------
532 
537 class ConstFunctorInterface {
538 public:
543  ConstFunctorInterface() {}
544  virtual ~ConstFunctorInterface() = default;
546 
551  virtual FunctorCode VisitObject(const Object *) { return FUNCTOR_CONTINUE; }
552  virtual FunctorCode VisitObjectEnd(const Object *) { return FUNCTOR_CONTINUE; }
553  virtual FunctorCode VisitDoc(const Doc *doc);
554  virtual FunctorCode VisitDocEnd(const Doc *doc);
556 
561  virtual FunctorCode VisitCourse(const Course *course);
562  virtual FunctorCode VisitCourseEnd(const Course *course);
563  virtual FunctorCode VisitGrpSym(const GrpSym *grpSym);
564  virtual FunctorCode VisitGrpSymEnd(const GrpSym *grpSym);
565  virtual FunctorCode VisitInstrDef(const InstrDef *instrDef);
566  virtual FunctorCode VisitInstrDefEnd(const InstrDef *instrDef);
567  virtual FunctorCode VisitLabel(const Label *label);
568  virtual FunctorCode VisitLabelEnd(const Label *label);
569  virtual FunctorCode VisitLabelAbbr(const LabelAbbr *labelAbbr);
570  virtual FunctorCode VisitLabelAbbrEnd(const LabelAbbr *labelAbbr);
571  virtual FunctorCode VisitLayer(const Layer *layer);
572  virtual FunctorCode VisitLayerEnd(const Layer *layer);
573  virtual FunctorCode VisitLayerDef(const LayerDef *layerDef);
574  virtual FunctorCode VisitLayerDefEnd(const LayerDef *layerDef);
575  virtual FunctorCode VisitMeasure(const Measure *measure);
576  virtual FunctorCode VisitMeasureEnd(const Measure *measure);
577  virtual FunctorCode VisitPage(const Page *page);
578  virtual FunctorCode VisitPageEnd(const Page *page);
579  virtual FunctorCode VisitPages(const Pages *pages);
580  virtual FunctorCode VisitPagesEnd(const Pages *pages);
581  virtual FunctorCode VisitPb(const Pb *pb);
582  virtual FunctorCode VisitPbEnd(const Pb *pb);
583  virtual FunctorCode VisitSb(const Sb *sb);
584  virtual FunctorCode VisitSbEnd(const Sb *sb);
585  virtual FunctorCode VisitScoreDef(const ScoreDef *scoreDef);
586  virtual FunctorCode VisitScoreDefEnd(const ScoreDef *scoreDef);
587  virtual FunctorCode VisitScoreDefElement(const ScoreDefElement *scoreDefElement);
588  virtual FunctorCode VisitScoreDefElementEnd(const ScoreDefElement *scoreDefElement);
589  virtual FunctorCode VisitStaff(const Staff *staff);
590  virtual FunctorCode VisitStaffEnd(const Staff *staff);
591  virtual FunctorCode VisitStaffDef(const StaffDef *staffDef);
592  virtual FunctorCode VisitStaffDefEnd(const StaffDef *staffDef);
593  virtual FunctorCode VisitStaffGrp(const StaffGrp *staffGrp);
594  virtual FunctorCode VisitStaffGrpEnd(const StaffGrp *staffGrp);
595  virtual FunctorCode VisitSystem(const System *system);
596  virtual FunctorCode VisitSystemEnd(const System *system);
597  virtual FunctorCode VisitTuning(const Tuning *tuning);
598  virtual FunctorCode VisitTuningEnd(const Tuning *tuning);
600 
606  virtual FunctorCode VisitEditorialElement(const EditorialElement *editorialElement);
607  virtual FunctorCode VisitEditorialElementEnd(const EditorialElement *editorialElement);
609 
614  virtual FunctorCode VisitDiv(const Div *div);
615  virtual FunctorCode VisitDivEnd(const Div *div);
616  virtual FunctorCode VisitRunningElement(const RunningElement *runningElement);
617  virtual FunctorCode VisitRunningElementEnd(const RunningElement *runningElement);
618  virtual FunctorCode VisitPgFoot(const PgFoot *pgFoot);
619  virtual FunctorCode VisitPgFootEnd(const PgFoot *pgFoot);
620  virtual FunctorCode VisitPgHead(const PgHead *pgHead);
621  virtual FunctorCode VisitPgHeadEnd(const PgHead *pgHead);
622  virtual FunctorCode VisitTextLayoutElement(const TextLayoutElement *textLayoutElement);
623  virtual FunctorCode VisitTextLayoutElementEnd(const TextLayoutElement *textLayoutElement);
625 
630  virtual FunctorCode VisitEnding(const Ending *ending);
631  virtual FunctorCode VisitEndingEnd(const Ending *ending);
632  virtual FunctorCode VisitExpansion(const Expansion *expansion);
633  virtual FunctorCode VisitExpansionEnd(const Expansion *expansion);
634  virtual FunctorCode VisitSection(const Section *section);
635  virtual FunctorCode VisitSectionEnd(const Section *section);
636  virtual FunctorCode VisitSystemElement(const SystemElement *systemElement);
637  virtual FunctorCode VisitSystemElementEnd(const SystemElement *systemElement);
638  virtual FunctorCode VisitSystemMilestone(const SystemMilestoneEnd *systemMilestoneEnd);
639  virtual FunctorCode VisitSystemMilestoneEnd(const SystemMilestoneEnd *systemMilestoneEnd);
641 
646  virtual FunctorCode VisitMdiv(const Mdiv *mdiv);
647  virtual FunctorCode VisitMdivEnd(const Mdiv *mdiv);
648  virtual FunctorCode VisitPageElement(const PageElement *pageElement);
649  virtual FunctorCode VisitPageElementEnd(const PageElement *pageElement);
650  virtual FunctorCode VisitPageMilestone(const PageMilestoneEnd *pageMilestoneEnd);
651  virtual FunctorCode VisitPageMilestoneEnd(const PageMilestoneEnd *pageMilestoneEnd);
652  virtual FunctorCode VisitScore(const Score *score);
653  virtual FunctorCode VisitScoreEnd(const Score *score);
655 
660  virtual FunctorCode VisitAnchoredText(const AnchoredText *anchoredText);
661  virtual FunctorCode VisitAnchoredTextEnd(const AnchoredText *anchoredText);
662  virtual FunctorCode VisitAnnotScore(const AnnotScore *annotScore);
663  virtual FunctorCode VisitAnnotScoreEnd(const AnnotScore *annotScore);
664  virtual FunctorCode VisitArpeg(const Arpeg *arpeg);
665  virtual FunctorCode VisitArpegEnd(const Arpeg *arpeg);
666  virtual FunctorCode VisitBeamSpan(const BeamSpan *beamSpan);
667  virtual FunctorCode VisitBeamSpanEnd(const BeamSpan *beamSpan);
668  virtual FunctorCode VisitBracketSpan(const BracketSpan *bracketSpan);
669  virtual FunctorCode VisitBracketSpanEnd(const BracketSpan *bracketSpan);
670  virtual FunctorCode VisitBreath(const Breath *breath);
671  virtual FunctorCode VisitBreathEnd(const Breath *breath);
672  virtual FunctorCode VisitCaesura(const Caesura *caesura);
673  virtual FunctorCode VisitCaesuraEnd(const Caesura *caesura);
674  virtual FunctorCode VisitControlElement(const ControlElement *controlElement);
675  virtual FunctorCode VisitControlElementEnd(const ControlElement *controlElement);
676  virtual FunctorCode VisitCpMark(const CpMark *cpMark);
677  virtual FunctorCode VisitCpMarkEnd(const CpMark *cpMark);
678  virtual FunctorCode VisitDir(const Dir *dir);
679  virtual FunctorCode VisitDirEnd(const Dir *dir);
680  virtual FunctorCode VisitDynam(const Dynam *dynam);
681  virtual FunctorCode VisitDynamEnd(const Dynam *dynam);
682  virtual FunctorCode VisitFermata(const Fermata *fermata);
683  virtual FunctorCode VisitFermataEnd(const Fermata *fermata);
684  virtual FunctorCode VisitFing(const Fing *fing);
685  virtual FunctorCode VisitFingEnd(const Fing *fing);
686  virtual FunctorCode VisitGliss(const Gliss *gliss);
687  virtual FunctorCode VisitGlissEnd(const Gliss *gliss);
688  virtual FunctorCode VisitHairpin(const Hairpin *hairpin);
689  virtual FunctorCode VisitHairpinEnd(const Hairpin *hairpin);
690  virtual FunctorCode VisitHarm(const Harm *harm);
691  virtual FunctorCode VisitHarmEnd(const Harm *harm);
692  virtual FunctorCode VisitLv(const Lv *lv);
693  virtual FunctorCode VisitLvEnd(const Lv *lv);
694  virtual FunctorCode VisitMordent(const Mordent *mordent);
695  virtual FunctorCode VisitMordentEnd(const Mordent *mordent);
696  virtual FunctorCode VisitOctave(const Octave *octave);
697  virtual FunctorCode VisitOctaveEnd(const Octave *octave);
698  virtual FunctorCode VisitOrnam(const Ornam *ornam);
699  virtual FunctorCode VisitOrnamEnd(const Ornam *ornam);
700  virtual FunctorCode VisitPedal(const Pedal *pedal);
701  virtual FunctorCode VisitPedalEnd(const Pedal *pedal);
702  virtual FunctorCode VisitPhrase(const Phrase *phrase);
703  virtual FunctorCode VisitPhraseEnd(const Phrase *phrase);
704  virtual FunctorCode VisitPitchInflection(const PitchInflection *pitchInflection);
705  virtual FunctorCode VisitPitchInflectionEnd(const PitchInflection *pitchInflection);
706  virtual FunctorCode VisitReh(const Reh *reh);
707  virtual FunctorCode VisitRehEnd(const Reh *reh);
708  virtual FunctorCode VisitRepeatMark(const RepeatMark *repeatMark);
709  virtual FunctorCode VisitRepeatMarkEnd(const RepeatMark *repeatMark);
710  virtual FunctorCode VisitSlur(const Slur *slur);
711  virtual FunctorCode VisitSlurEnd(const Slur *slur);
712  virtual FunctorCode VisitTempo(const Tempo *tempo);
713  virtual FunctorCode VisitTempoEnd(const Tempo *tempo);
714  virtual FunctorCode VisitTie(const Tie *tie);
715  virtual FunctorCode VisitTieEnd(const Tie *tie);
716  virtual FunctorCode VisitTrill(const Trill *trill);
717  virtual FunctorCode VisitTrillEnd(const Trill *trill);
718  virtual FunctorCode VisitTurn(const Turn *turn);
719  virtual FunctorCode VisitTurnEnd(const Turn *turn);
721 
726  virtual FunctorCode VisitAccid(const Accid *accid);
727  virtual FunctorCode VisitAccidEnd(const Accid *accid);
728  virtual FunctorCode VisitArtic(const Artic *artic);
729  virtual FunctorCode VisitArticEnd(const Artic *artic);
730  virtual FunctorCode VisitBarLine(const BarLine *barLine);
731  virtual FunctorCode VisitBarLineEnd(const BarLine *barLine);
732  virtual FunctorCode VisitBeam(const Beam *beam);
733  virtual FunctorCode VisitBeamEnd(const Beam *beam);
734  virtual FunctorCode VisitBeatRpt(const BeatRpt *beatRpt);
735  virtual FunctorCode VisitBeatRptEnd(const BeatRpt *beatRpt);
736  virtual FunctorCode VisitBTrem(const BTrem *bTrem);
737  virtual FunctorCode VisitBTremEnd(const BTrem *bTrem);
738  virtual FunctorCode VisitChord(const Chord *chord);
739  virtual FunctorCode VisitChordEnd(const Chord *chord);
740  virtual FunctorCode VisitClef(const Clef *clef);
741  virtual FunctorCode VisitClefEnd(const Clef *clef);
742  virtual FunctorCode VisitCustos(const Custos *custos);
743  virtual FunctorCode VisitCustosEnd(const Custos *custos);
744  virtual FunctorCode VisitDot(const Dot *dot);
745  virtual FunctorCode VisitDotEnd(const Dot *dot);
746  virtual FunctorCode VisitDots(const Dots *dots);
747  virtual FunctorCode VisitDotsEnd(const Dots *dots);
748  virtual FunctorCode VisitFlag(const Flag *flag);
749  virtual FunctorCode VisitFlagEnd(const Flag *flag);
750  virtual FunctorCode VisitFTrem(const FTrem *fTrem);
751  virtual FunctorCode VisitFTremEnd(const FTrem *fTrem);
752  virtual FunctorCode VisitGenericLayerElement(const GenericLayerElement *genericLayerElement);
753  virtual FunctorCode VisitGenericLayerElementEnd(const GenericLayerElement *genericLayerElement);
754  virtual FunctorCode VisitGraceGrp(const GraceGrp *graceGrp);
755  virtual FunctorCode VisitGraceGrpEnd(const GraceGrp *graceGrp);
756  virtual FunctorCode VisitHalfmRpt(const HalfmRpt *halfmRpt);
757  virtual FunctorCode VisitHalfmRptEnd(const HalfmRpt *halfmRpt);
758  virtual FunctorCode VisitKeyAccid(const KeyAccid *keyAccid);
759  virtual FunctorCode VisitKeyAccidEnd(const KeyAccid *keyAccid);
760  virtual FunctorCode VisitKeySig(const KeySig *keySig);
761  virtual FunctorCode VisitKeySigEnd(const KeySig *keySig);
762  virtual FunctorCode VisitLayerElement(const LayerElement *layerElement);
763  virtual FunctorCode VisitLayerElementEnd(const LayerElement *layerElement);
764  virtual FunctorCode VisitLigature(const Ligature *ligature);
765  virtual FunctorCode VisitLigatureEnd(const Ligature *ligature);
766  virtual FunctorCode VisitMensur(const Mensur *mensur);
767  virtual FunctorCode VisitMensurEnd(const Mensur *mensur);
768  virtual FunctorCode VisitMeterSig(const MeterSig *meterSig);
769  virtual FunctorCode VisitMeterSigEnd(const MeterSig *meterSig);
770  virtual FunctorCode VisitMeterSigGrp(const MeterSigGrp *meterSigGrp);
771  virtual FunctorCode VisitMeterSigGrpEnd(const MeterSigGrp *meterSigGrp);
772  virtual FunctorCode VisitMRest(const MRest *mRest);
773  virtual FunctorCode VisitMRestEnd(const MRest *mRest);
774  virtual FunctorCode VisitMRpt(const MRpt *mRpt);
775  virtual FunctorCode VisitMRptEnd(const MRpt *mRpt);
776  virtual FunctorCode VisitMRpt2(const MRpt2 *mRpt2);
777  virtual FunctorCode VisitMRpt2End(const MRpt2 *mRpt2);
778  virtual FunctorCode VisitMSpace(const MSpace *mSpace);
779  virtual FunctorCode VisitMSpaceEnd(const MSpace *mSpace);
780  virtual FunctorCode VisitMultiRest(const MultiRest *multiRest);
781  virtual FunctorCode VisitMultiRestEnd(const MultiRest *multiRest);
782  virtual FunctorCode VisitMultiRpt(const MultiRpt *multiRpt);
783  virtual FunctorCode VisitMultiRptEnd(const MultiRpt *multiRpt);
784  virtual FunctorCode VisitNc(const Nc *nc);
785  virtual FunctorCode VisitNcEnd(const Nc *nc);
786  virtual FunctorCode VisitNeume(const Neume *neume);
787  virtual FunctorCode VisitNeumeEnd(const Neume *neume);
788  virtual FunctorCode VisitNote(const Note *note);
789  virtual FunctorCode VisitNoteEnd(const Note *note);
790  virtual FunctorCode VisitPlica(const Plica *plica);
791  virtual FunctorCode VisitPlicaEnd(const Plica *plica);
792  virtual FunctorCode VisitProport(const Proport *proport);
793  virtual FunctorCode VisitProportEnd(const Proport *proport);
794  virtual FunctorCode VisitRest(const Rest *rest);
795  virtual FunctorCode VisitRestEnd(const Rest *rest);
796  virtual FunctorCode VisitSpace(const Space *space);
797  virtual FunctorCode VisitSpaceEnd(const Space *space);
798  virtual FunctorCode VisitStem(const Stem *stem);
799  virtual FunctorCode VisitStemEnd(const Stem *stem);
800  virtual FunctorCode VisitSyl(const Syl *syl);
801  virtual FunctorCode VisitSylEnd(const Syl *syl);
802  virtual FunctorCode VisitSyllable(const Syllable *syllable);
803  virtual FunctorCode VisitSyllableEnd(const Syllable *syllable);
804  virtual FunctorCode VisitTabDurSym(const TabDurSym *tabDurSym);
805  virtual FunctorCode VisitTabDurSymEnd(const TabDurSym *tabDurSym);
806  virtual FunctorCode VisitTabGrp(const TabGrp *tabGrp);
807  virtual FunctorCode VisitTabGrpEnd(const TabGrp *tabGrp);
808  virtual FunctorCode VisitTimestamp(const TimestampAttr *timestamp);
809  virtual FunctorCode VisitTimestampEnd(const TimestampAttr *timestamp);
810  virtual FunctorCode VisitTuplet(const Tuplet *tuplet);
811  virtual FunctorCode VisitTupletEnd(const Tuplet *tuplet);
812  virtual FunctorCode VisitTupletBracket(const TupletBracket *tupletBracket);
813  virtual FunctorCode VisitTupletBracketEnd(const TupletBracket *tupletBracket);
814  virtual FunctorCode VisitTupletNum(const TupletNum *tupletNum);
815  virtual FunctorCode VisitTupletNumEnd(const TupletNum *tupletNum);
816  virtual FunctorCode VisitVerse(const Verse *verse);
817  virtual FunctorCode VisitVerseEnd(const Verse *verse);
819 
824  virtual FunctorCode VisitF(const F *f);
825  virtual FunctorCode VisitFEnd(const F *f);
826  virtual FunctorCode VisitFb(const Fb *fb);
827  virtual FunctorCode VisitFbEnd(const Fb *fb);
828  virtual FunctorCode VisitFig(const Fig *fig);
829  virtual FunctorCode VisitFigEnd(const Fig *fig);
830  virtual FunctorCode VisitLb(const Lb *lb);
831  virtual FunctorCode VisitLbEnd(const Lb *lb);
832  virtual FunctorCode VisitMNum(const MNum *mNum);
833  virtual FunctorCode VisitMNumEnd(const MNum *mNum);
834  virtual FunctorCode VisitNum(const Num *num);
835  virtual FunctorCode VisitNumEnd(const Num *num);
836  virtual FunctorCode VisitRend(const Rend *rend);
837  virtual FunctorCode VisitRendEnd(const Rend *rend);
838  virtual FunctorCode VisitSvg(const Svg *svg);
839  virtual FunctorCode VisitSvgEnd(const Svg *svg);
840  virtual FunctorCode VisitSymbol(const Symbol *symbol);
841  virtual FunctorCode VisitSymbolEnd(const Symbol *symbol);
842  virtual FunctorCode VisitText(const Text *text);
843  virtual FunctorCode VisitTextEnd(const Text *text);
844  virtual FunctorCode VisitTextElement(const TextElement *textElement);
845  virtual FunctorCode VisitTextElementEnd(const TextElement *textElement);
847 
852  virtual FunctorCode VisitFacsimile(const Facsimile *facsimile);
853  virtual FunctorCode VisitFacsimileEnd(const Facsimile *facsimile);
854  virtual FunctorCode VisitGraphic(const Graphic *graphic);
855  virtual FunctorCode VisitGraphicEnd(const Graphic *graphic);
856  virtual FunctorCode VisitSurface(const Surface *surface);
857  virtual FunctorCode VisitSurfaceEnd(const Surface *surface);
858  virtual FunctorCode VisitZone(const Zone *zone);
859  virtual FunctorCode VisitZoneEnd(const Zone *zone);
861 
866  virtual FunctorCode VisitAlignment(const Alignment *alignment);
867  virtual FunctorCode VisitAlignmentEnd(const Alignment *alignment);
868  virtual FunctorCode VisitAlignmentReference(const AlignmentReference *alignmentReference);
869  virtual FunctorCode VisitAlignmentReferenceEnd(const AlignmentReference *alignmentReference);
870  virtual FunctorCode VisitHorizontalAligner(const HorizontalAligner *horizontalAligner);
871  virtual FunctorCode VisitHorizontalAlignerEnd(const HorizontalAligner *horizontalAligner);
872  virtual FunctorCode VisitMeasureAligner(const MeasureAligner *measureAligner);
873  virtual FunctorCode VisitMeasureAlignerEnd(const MeasureAligner *measureAligner);
874  virtual FunctorCode VisitGraceAligner(const GraceAligner *graceAligner);
875  virtual FunctorCode VisitGraceAlignerEnd(const GraceAligner *graceAligner);
876  virtual FunctorCode VisitTimestampAligner(const TimestampAligner *timestampAligner);
877  virtual FunctorCode VisitTimestampAlignerEnd(const TimestampAligner *timestampAligner);
879 
884  virtual FunctorCode VisitSystemAligner(const SystemAligner *systemAligner);
885  virtual FunctorCode VisitSystemAlignerEnd(const SystemAligner *systemAligner);
886  virtual FunctorCode VisitStaffAlignment(const StaffAlignment *staffAlignment);
887  virtual FunctorCode VisitStaffAlignmentEnd(const StaffAlignment *staffAlignment);
889 
894  virtual FunctorCode VisitFloatingObject(const FloatingObject *floatingObject);
895  virtual FunctorCode VisitFloatingObjectEnd(const FloatingObject *floatingObject);
897 
898 private:
899  //
900 public:
901  //
902 private:
903  //
904 };
905 
906 } // namespace vrv
907 
908 #endif // __VRV_FUNCTOR_INTERFACE_H__
vrv::Accid
This class models the MEI <accid> element.
Definition: accid.h:37
vrv::Alignment
This class stores an alignment position elements will point to.
Definition: horizontalaligner.h:73
vrv::AlignmentReference
This class stores a references of LayerElements for a staff.
Definition: horizontalaligner.h:290
vrv::AnchoredText
This class is an interface for <anchoredText> elements at the measure level.
Definition: anchoredtext.h:25
vrv::AnnotScore
This class models the MEI <annot> element where @type is score.
Definition: annotscore.h:24
vrv::Arpeg
This class models the MEI <arpeg> element.
Definition: arpeg.h:31
vrv::Artic
Definition: artic.h:29
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::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:39
vrv::ConstFunctorInterface
This class is an interface for const functors based on a visitor pattern.
Definition: functorinterface.h:537
vrv::ControlElement
This class represents elements appearing within a measure.
Definition: controlelement.h:33
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:29
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::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:22
vrv::Dots
This class models a group of dots as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:27
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::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::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::Flag
This class models a stem as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:97
vrv::FloatingObject
This class represents elements appearing within a measure.
Definition: floatingobject.h:28
vrv::FunctorInterface
This class is an interface for functors based on a visitor pattern.
Definition: functorinterface.h:160
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::GraceAligner
This class aligns the content of a grace note group It contains a vector of Alignment.
Definition: horizontalaligner.h:570
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:31
vrv::HalfmRpt
This class models the MEI <halfmRpt> element.
Definition: halfmrpt.h:26
vrv::Harm
This class models the MEI <harm> element.
Definition: harm.h:32
vrv::HorizontalAligner
This class aligns the content horizontally It contains a vector of Alignment.
Definition: horizontalaligner.h:362
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:52
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:39
vrv::Lb
This class models the MEI <lb>
Definition: lb.h:23
vrv::Ligature
This class represents a collection of notes in the same layer with successive onset times,...
Definition: ligature.h:28
vrv::Lv
This class models the MEI <lv> element.
Definition: lv.h:22
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:32
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::MeasureAligner
This class aligns the content of a measure It contains a vector of Alignment.
Definition: horizontalaligner.h:425
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:28
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:32
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:41
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:67
vrv::Num
This class models the MEI <num> element.
Definition: num.h:24
vrv::Object
This class represents a basic object.
Definition: object.h:61
vrv::Octave
This class models the MEI <octave> element.
Definition: octave.h:31
vrv::Ornam
This class models the MEI <ornam> element.
Definition: ornam.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::Plica
Definition: plica.h:20
vrv::Proport
This class models the MEI <proport> element.
Definition: proport.h:23
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:45
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:42
vrv::ScoreDef
This class represents a MEI scoreDef.
Definition: scoredef.h:135
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::Slur
Definition: slur.h:57
vrv::Space
This class models the MEI <space> element.
Definition: space.h:23
vrv::StaffAlignment
This class stores an alignement position staves will point to.
Definition: verticalaligner.h:172
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:107
vrv::Stem
This class models a stem as a layer element part and as MEI <stem> element.
Definition: stem.h:27
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:36
vrv::Syllable
This class models the MEI <mensur> element.
Definition: syllable.h:25
vrv::Symbol
This class models the MEI <symbol> element.
Definition: symbol.h:25
vrv::SystemAligner
This class aligns the content of a system It contains a vector of StaffAlignment.
Definition: verticalaligner.h:31
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:23
vrv::Tempo
This class is an interface for <tempo> elements at the measure level.
Definition: tempo.h:33
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:27
vrv::TimestampAligner
This class stores the timestamps (TimestampsAttr) in a measure.
Definition: horizontalaligner.h:664
vrv::TimestampAttr
Definition: timestamp.h:19
vrv::Trill
This class models the MEI <trill> element.
Definition: trill.h:34
vrv::Tuning
This class models the MEI <tuning> element.
Definition: tuning.h:23
vrv::TupletBracket
This class models a bracket as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:150
vrv::Tuplet
Definition: tuplet.h:33
vrv::TupletNum
This class models a tuplet num as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:249
vrv::Turn
This class models the MEI <turn> element.
Definition: turn.h:32
vrv::Verse
Definition: verse.h:28
vrv::Zone
Implements the zone element in MEI.
Definition: zone.h:30