Verovio
Source code documentation
resetfunctor.h
1 // Name: resetfunctor.h
3 // Author: David Bauer
4 // Created: 2023
5 // Copyright (c) Authors and others. All rights reserved.
7 
8 #ifndef __VRV_RESETFUNCTOR_H__
9 #define __VRV_RESETFUNCTOR_H__
10 
11 #include "functor.h"
12 
13 namespace vrv {
14 
15 //----------------------------------------------------------------------------
16 // ResetDataFunctor
17 //----------------------------------------------------------------------------
18 
22 class ResetDataFunctor : public Functor {
23 public:
28  ResetDataFunctor();
29  virtual ~ResetDataFunctor() = default;
31 
32  /*
33  * Abstract base implementation
34  */
35  bool ImplementsEndInterface() const override { return false; }
36 
37  /*
38  * Functor interface
39  */
41  FunctorCode VisitAccid(Accid *accid) override;
42  FunctorCode VisitArpeg(Arpeg *arpeg) override;
43  FunctorCode VisitArtic(Artic *artic) override;
44  FunctorCode VisitBeam(Beam *beam) override;
45  FunctorCode VisitBeamSpan(BeamSpan *beamSpan) override;
46  FunctorCode VisitChord(Chord *chord) override;
47  FunctorCode VisitControlElement(ControlElement *controlElement) override;
48  FunctorCode VisitCustos(Custos *custos) override;
49  FunctorCode VisitDiv(Div *div) override;
50  FunctorCode VisitDot(Dot *dot) override;
51  FunctorCode VisitDots(Dots *dots) override;
52  FunctorCode VisitEditorialElement(EditorialElement *editorialElement) override;
53  FunctorCode VisitEnding(Ending *ending) override;
54  FunctorCode VisitF(F *f) override;
55  FunctorCode VisitFlag(Flag *flag) override;
56  FunctorCode VisitFloatingObject(FloatingObject *floatingObject) override;
57  FunctorCode VisitFTrem(FTrem *fTrem) override;
58  FunctorCode VisitHairpin(Hairpin *hairpin) override;
59  FunctorCode VisitKeySig(KeySig *keySig) override;
60  FunctorCode VisitLayer(Layer *layer) override;
61  FunctorCode VisitLayerElement(LayerElement *layerElement) override;
62  FunctorCode VisitLyricElement(LyricElement *lyricElement) override;
63  FunctorCode VisitLigature(Ligature *ligature) override;
64  FunctorCode VisitMeasure(Measure *measure) override;
65  FunctorCode VisitMRest(MRest *mRest) override;
66  FunctorCode VisitMSpace(MSpace *mSpace) override;
67  FunctorCode VisitNote(Note *note) override;
68  FunctorCode VisitNc(Nc *nc) override;
69  FunctorCode VisitObject(Object *object) override;
70  FunctorCode VisitPage(Page *page) override;
71  FunctorCode VisitRepeatMark(RepeatMark *repeatMark) override;
72  FunctorCode VisitRest(Rest *rest) override;
73  FunctorCode VisitSection(Section *section) override;
74  FunctorCode VisitSlur(Slur *slur) override;
75  FunctorCode VisitSpace(Space *space) override;
76  FunctorCode VisitStaff(Staff *staff) override;
77  FunctorCode VisitStaffDef(StaffDef *staffDef) override;
78  FunctorCode VisitStem(Stem *stem) override;
79  FunctorCode VisitSyl(Syl *syl) override;
80  FunctorCode VisitSystem(System *system) override;
81  FunctorCode VisitSystemMilestone(SystemMilestoneEnd *systemMilestoneEnd) override;
82  FunctorCode VisitTabDurSym(TabDurSym *tabDurSym) override;
83  FunctorCode VisitTempo(Tempo *tempo) override;
84  FunctorCode VisitTuplet(Tuplet *tuplet) override;
85  FunctorCode VisitTurn(Turn *turn) override;
86  FunctorCode VisitRefrain(Refrain *refrain) override;
87  FunctorCode VisitVolta(Volta *volta) override;
88  FunctorCode VisitVerse(Verse *verse) override;
90 
91 protected:
92  //
93 private:
94  //
95 public:
96  //
97 private:
98  //
99 };
100 
101 //----------------------------------------------------------------------------
102 // ResetHorizontalAlignmentFunctor
103 //----------------------------------------------------------------------------
104 
108 class ResetHorizontalAlignmentFunctor : public Functor {
109 public:
114  ResetHorizontalAlignmentFunctor();
115  virtual ~ResetHorizontalAlignmentFunctor() = default;
117 
118  /*
119  * Abstract base implementation
120  */
121  bool ImplementsEndInterface() const override { return false; }
122 
123  /*
124  * Functor interface
125  */
127  FunctorCode VisitAccid(Accid *accid) override;
128  FunctorCode VisitArpeg(Arpeg *arpeg) override;
129  FunctorCode VisitBeam(Beam *beam) override;
130  FunctorCode VisitBeamSpan(BeamSpan *beamSpan) override;
131  FunctorCode VisitCursor(Cursor *cursor) override;
132  FunctorCode VisitCustos(Custos *custos) override;
133  FunctorCode VisitDiv(Div *div) override;
134  FunctorCode VisitDot(Dot *dot) override;
135  FunctorCode VisitDots(Dots *dots) override;
136  FunctorCode VisitFloatingObject(FloatingObject *floatingObject) override;
137  FunctorCode VisitLayer(Layer *layer) override;
138  FunctorCode VisitLayerElement(LayerElement *layerElement) override;
139  FunctorCode VisitMeasure(Measure *measure) override;
140  FunctorCode VisitMRest(MRest *mRest) override;
141  FunctorCode VisitNote(Note *note) override;
142  FunctorCode VisitOssia(Ossia *ossia) override;
143  FunctorCode VisitProport(Proport *proport) override;
144  FunctorCode VisitRest(Rest *rest) override;
145  FunctorCode VisitScoreDef(ScoreDef *scoreDef) override;
146  FunctorCode VisitSystem(System *system) override;
147  FunctorCode VisitTuplet(Tuplet *tuplet) override;
148  FunctorCode VisitTupletBracket(TupletBracket *tupletBracket) override;
149  FunctorCode VisitTupletNum(TupletNum *tupletNum) override;
151 
152 protected:
153  //
154 private:
155  //
156 public:
157  //
158 private:
159  //
160 };
161 
162 //----------------------------------------------------------------------------
163 // ResetVerticalAlignmentFunctor
164 //----------------------------------------------------------------------------
165 
169 class ResetVerticalAlignmentFunctor : public Functor {
170 public:
175  ResetVerticalAlignmentFunctor();
176  virtual ~ResetVerticalAlignmentFunctor() = default;
178 
179  /*
180  * Abstract base implementation
181  */
182  bool ImplementsEndInterface() const override { return false; }
183 
184  /*
185  * Functor interface
186  */
188  FunctorCode VisitArtic(Artic *artic) override;
189  FunctorCode VisitFloatingObject(FloatingObject *floatingObject) override;
190  FunctorCode VisitLayerElement(LayerElement *layerElement) override;
191  FunctorCode VisitOctave(Octave *octave) override;
192  FunctorCode VisitPage(Page *page) override;
193  FunctorCode VisitStaff(Staff *staff) override;
194  FunctorCode VisitSystem(System *system) override;
195  FunctorCode VisitTextElement(TextElement *textElement) override;
196  FunctorCode VisitTuplet(Tuplet *tuplet) override;
197  FunctorCode VisitTupletBracket(TupletBracket *tupletBracket) override;
199 
200 protected:
201  //
202 private:
203  //
204 public:
205  //
206 private:
207  //
208 };
209 
210 } // namespace vrv
211 
212 #endif // __VRV_RESETFUNCTOR_H__
vrv::Accid
This class models the MEI <accid> element.
Definition: accid.h:41
vrv::Arpeg
This class models the MEI <arpeg> element.
Definition: arpeg.h:31
vrv::Artic
Definition: artic.h:31
vrv::Beam
Definition: beam.h:284
vrv::BeamSpan
This class models the MEI <beamSpan> element.
Definition: beamspan.h:36
vrv::Chord
This class represents a collection of notes in the same layer with the same onset time.
Definition: chord.h:44
vrv::ControlElement
This class represents elements appearing within a measure.
Definition: controlelement.h:35
vrv::Cursor
This class implements a curor for the editor.
Definition: cursor.h:27
vrv::Custos
Definition: custos.h:31
vrv::Div
This class represents an MEI Div.
Definition: div.h:24
vrv::Dot
Definition: dot.h:23
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::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::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::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::Functor
This abstract class is the base class for all mutable functors.
Definition: functor.h:101
vrv::Hairpin
This class models the MEI <hairpin> element.
Definition: hairpin.h:32
vrv::KeySig
This class models the MEI <keySig> element.
Definition: keysig.h:51
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::Ligature
This class represents a collection of notes in the same layer with successive onset times,...
Definition: ligature.h:28
vrv::LyricElement
Shared implementation for note-attached verse and refrain lyrics.
Definition: lyricelement.h:33
vrv::MRest
This class models the MEI <mRest> element.
Definition: mrest.h:36
vrv::MSpace
This class models the MEI <space> element.
Definition: mspace.h:22
vrv::Measure
This class represents a measure in a page-based score (Doc).
Definition: measure.h:46
vrv::Nc
This class models the MEI <nc> element.
Definition: nc.h:43
vrv::Note
This class models the MEI <note> element.
Definition: note.h:69
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::Ossia
This class represents an ossia.
Definition: ossia.h:28
vrv::Page
This class represents a page in a laid-out score (Doc).
Definition: page.h:31
vrv::Proport
This class models the MEI <proport> element.
Definition: proport.h:23
vrv::Refrain
Recurring note-attached lyrics, such as a chorus.
Definition: refrain.h:19
vrv::RepeatMark
This class models the MEI <ornam> element.
Definition: repeatmark.h:32
vrv::ResetDataFunctor
This class resets the drawing values before calling PrepareData after changes.
Definition: resetfunctor.h:22
vrv::ResetDataFunctor::ImplementsEndInterface
bool ImplementsEndInterface() const override
Return true if the functor implements the end interface.
Definition: resetfunctor.h:35
vrv::ResetHorizontalAlignmentFunctor
This class resets the horizontal alignment for various types.
Definition: resetfunctor.h:108
vrv::ResetHorizontalAlignmentFunctor::ImplementsEndInterface
bool ImplementsEndInterface() const override
Return true if the functor implements the end interface.
Definition: resetfunctor.h:121
vrv::ResetVerticalAlignmentFunctor
This class resets the vertical alignment for various types.
Definition: resetfunctor.h:169
vrv::ResetVerticalAlignmentFunctor::ImplementsEndInterface
bool ImplementsEndInterface() const override
Return true if the functor implements the end interface.
Definition: resetfunctor.h:182
vrv::Rest
This class models the MEI <rest> element.
Definition: rest.h:49
vrv::ScoreDef
This class represents a MEI scoreDef.
Definition: scoredef.h:136
vrv::Section
This class represents a MEI section.
Definition: section.h:28
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::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::Syl
Syl is a TimeSpanningInterface for managing syllable connectors.
Definition: syl.h:38
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::Tempo
This class is an interface for <tempo> elements at the measure level.
Definition: tempo.h:33
vrv::TextElement
Definition: textelement.h:22
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:250
vrv::Turn
This class models the MEI <turn> element.
Definition: turn.h:33
vrv::Verse
Definition: verse.h:21
vrv::Volta
Sung text for a specific iteration of a repeated section of music.
Definition: volta.h:26