diff --git a/include/vrv/accid.h b/include/vrv/accid.h
index e6fa9aa14af..0df8e4ab64c 100644
--- a/include/vrv/accid.h
+++ b/include/vrv/accid.h
@@ -27,14 +27,14 @@ class Accid : public LayerElement, public PositionInterface, public AttAccidenta
     Accid();
     virtual ~Accid();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Accid"; };
-    virtual ClassId Is() { return ACCID; };
+    virtual std::string GetClassName() const { return "Accid"; };
+    virtual ClassId Is() const { return ACCID; };
     ///@}
 
     virtual PositionInterface *GetPositionInterface() { return dynamic_cast<PositionInterface *>(this); }
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     //----------//
     // Functors //
diff --git a/include/vrv/aligner.h b/include/vrv/aligner.h
index c8dc5b7e889..ab1c070719e 100644
--- a/include/vrv/aligner.h
+++ b/include/vrv/aligner.h
@@ -61,7 +61,7 @@ class SystemAligner : public Object {
     // constructors and destructors
     SystemAligner();
     virtual ~SystemAligner();
-    virtual ClassId Is() { return SYSTEM_ALIGNER; }
+    virtual ClassId Is() const { return SYSTEM_ALIGNER; }
 
     int GetStaffAlignmentCount() const { return (int)m_children.size(); };
 
@@ -74,13 +74,14 @@ class SystemAligner : public Object {
      * Get bottom StaffAlignment for the system.
      * For each SystemAligner, we keep a StaffAlignment for the bottom position.
      */
-    StaffAlignment *GetBottomAlignment() { return m_bottomAlignment; };
+    StaffAlignment *GetBottomAlignment() const { return m_bottomAlignment; };
 
     /**
      * Get the StaffAlignment at index idx.
      * Creates the StaffAlignment if not there yet.
      * Checks the they are created incrementally (without gap).
      * If a staff is passed, it will be used for initializing m_staffN and m_staffSize of the aligner.
+     * (no const since the bottom alignment is temporarily removed)
      */
     StaffAlignment *GetStaffAlignment(int idx, Staff *staff = NULL);
 
@@ -88,7 +89,7 @@ class SystemAligner : public Object {
      * Get the StaffAlignment for the staffN.
      * Return NULL if not found.
      */
-    StaffAlignment *GetStaffAlignmentForStaffN(int staffN);
+    StaffAlignment *GetStaffAlignmentForStaffN(int staffN) const;
 
 private:
     //
@@ -117,17 +118,17 @@ class StaffAlignment : public Object {
     ///@{
     StaffAlignment();
     virtual ~StaffAlignment();
-    virtual ClassId Is() { return STAFF_ALIGNMENT; }
+    virtual ClassId Is() const { return STAFF_ALIGNMENT; }
     ///@}
 
     void SetYRel(int yRel) { m_yRel = yRel; };
-    int GetYRel() { return m_yRel; };
+    int GetYRel() const { return m_yRel; };
 
     void SetYShift(int yShift);
-    int GetYShift() { return m_yShift; };
+    int GetYShift() const { return m_yShift; };
 
     void SetMaxHeight(int max_height);
-    int GetMaxHeight() { return m_maxHeight; };
+    int GetMaxHeight() const { return m_maxHeight; };
 
     /**
      * @name Set and get verse count.
@@ -136,24 +137,24 @@ class StaffAlignment : public Object {
      */
     ///@{
     void SetVerseCount(int verse_count);
-    int GetVerseCount() { return m_verseCount; };
+    int GetVerseCount() const { return m_verseCount; };
 
     /**
      * @name Setter and getter for above or below dir/dynam/hairpin
      */
     ///@{
     void SetDirAbove() { m_dirAbove = true; };
-    bool GetDirAbove() { return m_dirAbove; };
+    bool GetDirAbove() const { return m_dirAbove; };
     void SetDirBelow() { m_dirBelow = true; };
-    bool GetDirBelow() { return m_dirBelow; };
+    bool GetDirBelow() const { return m_dirBelow; };
     void SetDynamAbove() { m_dynamAbove = true; };
-    bool GetDynamAbove() { return m_dynamAbove; };
+    bool GetDynamAbove() const { return m_dynamAbove; };
     void SetDynamBelow() { m_dynamBelow = true; };
-    bool GetDynamBelow() { return m_dynamBelow; };
+    bool GetDynamBelow() const { return m_dynamBelow; };
     void SetHairpinAbove() { m_hairpinAbove = true; };
-    bool GetHairpinAbove() { return m_hairpinAbove; };
+    bool GetHairpinAbove() const { return m_hairpinAbove; };
     void SetHairpinBelow() { m_hairpinBelow = true; };
-    bool GetHairpinBelow() { return m_hairpinBelow; };
+    bool GetHairpinBelow() const { return m_hairpinBelow; };
     ///@}
 
     void SetCurrentBoundingBox(FloatingElement *element, int x, int y);
@@ -163,7 +164,7 @@ class StaffAlignment : public Object {
      * Used for accessing the staff @n, the size, etc.
      */
     ///@{
-    Staff *GetStaff() { return m_staff; };
+    Staff *GetStaff() const { return m_staff; };
     void SetStaff(Staff *staff) { m_staff = staff; };
     ///@}
 
@@ -237,23 +238,23 @@ class Alignment : public Object {
     Alignment();
     Alignment(double time, AlignmentType type = ALIGNMENT_DEFAULT);
     virtual ~Alignment();
-    virtual ClassId Is() { return ALIGNMENT; }
+    virtual ClassId Is() const { return ALIGNMENT; }
 
     void SetXRel(int x_rel);
-    int GetXRel() { return m_xRel; };
+    int GetXRel() const { return m_xRel; };
 
     void SetXShift(int xShift);
-    int GetXShift() { return m_xShift; };
+    int GetXShift() const { return m_xShift; };
 
     void SetMaxWidth(int maxWidth);
-    int GetMaxWidth() { return m_maxWidth; };
+    int GetMaxWidth() const { return m_maxWidth; };
 
     /**
      * @name Set and get the time value of the alignment
      */
     ///@{
     void SetTime(double time) { m_time = time; };
-    double GetTime() { return m_time; };
+    double GetTime() const { return m_time; };
     ///@}
 
     /**
@@ -261,7 +262,7 @@ class Alignment : public Object {
      */
     ///@{
     void SetType(AlignmentType type) { m_type = type; };
-    AlignmentType GetType() { return m_type; };
+    AlignmentType GetType() const { return m_type; };
     ///@}
 
     /**
@@ -273,7 +274,7 @@ class Alignment : public Object {
     /**
      * Returns true if the aligner has a GraceAligner
      */
-    bool HasGraceAligner() { return (m_graceAligner != NULL); };
+    bool HasGraceAligner() const { return (m_graceAligner != NULL); };
 
     /**
      * Correct the X alignment of grace notes once the content of a system has been aligned and laid out.
@@ -359,7 +360,7 @@ class MeasureAligner : public Object {
     // constructors and destructors
     MeasureAligner();
     virtual ~MeasureAligner();
-    virtual ClassId Is() { return MEASURE_ALIGNER; }
+    virtual ClassId Is() const { return MEASURE_ALIGNER; }
 
     int GetAlignmentCount() const { return (int)m_children.size(); };
 
@@ -382,7 +383,7 @@ class MeasureAligner : public Object {
      */
     ///@{
     void SetNonJustifiableMargin(int margin) { m_nonJustifiableLeftMargin = margin; };
-    int GetNonJustifiableMargin() { return m_nonJustifiableLeftMargin; };
+    int GetNonJustifiableMargin() const { return m_nonJustifiableLeftMargin; };
     ///@}
 
     /**
@@ -390,14 +391,14 @@ class MeasureAligner : public Object {
      * For each MeasureAligner, we keep and Alignment for the left position.
      * The Alignment time will be always 0.0 and will appear first in the list.
      */
-    Alignment *GetLeftAlignment() { return m_leftAlignment; };
+    Alignment *GetLeftAlignment() const { return m_leftAlignment; };
 
     /**
      * Get right Alignment for the measure.
      * For each MeasureAligner, we keep and Alignment for the right position.
      * The Alignment time will be increased whenever necessary when values are added.
      */
-    Alignment *GetRightAlignment() { return m_rightAlignment; };
+    Alignment *GetRightAlignment() const { return m_rightAlignment; };
 
     /**
      * Correct the X alignment once the the content of a system has been aligned and laid out.
@@ -453,7 +454,7 @@ class GraceAligner : public MeasureAligner {
     // constructors and destructors
     GraceAligner();
     virtual ~GraceAligner();
-    virtual ClassId Is() { return GRACE_ALIGNER; }
+    virtual ClassId Is() const { return GRACE_ALIGNER; }
 
     /**
      * Because the grace notes appear from left to right but need to be aligned
@@ -473,7 +474,7 @@ class GraceAligner : public MeasureAligner {
      */
     ///@{
     void SetWidth(int totalWidth) { m_totalWidth = totalWidth; };
-    int GetWidth() { return m_totalWidth; };
+    int GetWidth() const { return m_totalWidth; };
     ///@}
 
 private:
@@ -507,7 +508,7 @@ class TimestampAligner : public Object {
     // constructors and destructors
     TimestampAligner();
     virtual ~TimestampAligner();
-    virtual ClassId Is() { return TIMESTAMP_ALIGNER; }
+    virtual ClassId Is() const { return TIMESTAMP_ALIGNER; }
 
     /**
      * Reset the aligner (clear the content)
diff --git a/include/vrv/anchoredtext.h b/include/vrv/anchoredtext.h
index 2a37824646b..9c9950ae92d 100644
--- a/include/vrv/anchoredtext.h
+++ b/include/vrv/anchoredtext.h
@@ -32,8 +32,8 @@ class AnchoredText : public FloatingElement, public TextDirInterface {
     AnchoredText();
     virtual ~AnchoredText();
     virtual void Reset();
-    virtual std::string GetClassName() { return "AnchoredText"; };
-    virtual ClassId Is() { return ANCHORED_TEXT; };
+    virtual std::string GetClassName() const { return "AnchoredText"; };
+    virtual ClassId Is() const { return ANCHORED_TEXT; };
     ///@}
 
     virtual TextDirInterface *GetTextDirInterface() { return dynamic_cast<TextDirInterface *>(this); }
diff --git a/include/vrv/att.h b/include/vrv/att.h
index 47ec8485300..f50084968aa 100644
--- a/include/vrv/att.h
+++ b/include/vrv/att.h
@@ -68,85 +68,85 @@ class Att : public AttConverter {
      * Idem for getting attributes as strings
      */
     // static void GetAnalysis(Object *element, ArrayOfStrAttr *attributes);
-    static void GetCmn(Object *element, ArrayOfStrAttr *attributes);
+    static void GetCmn(const Object *element, ArrayOfStrAttr *attributes);
     // static void GetCmnornaments(Object *element, ArrayOfStrAttr *attributes);
-    static void GetCritapp(Object *element, ArrayOfStrAttr *attributes);
+    static void GetCritapp(const Object *element, ArrayOfStrAttr *attributes);
     // static void GetEdittrans(Object *element, ArrayOfStrAttr *attributes);
     // static void GetFacsimile(Object *element, ArrayOfStrAttr *attributes);
     // static void GetFigtable(Object *element, ArrayOfStrAttr *attributes);
     // static void GetHarmony(Object *element, ArrayOfStrAttr *attributes);
     // static void GetHeader(Object *element, ArrayOfStrAttr *attributes);
     // static void GetLyrics(Object *element, ArrayOfStrAttr *attributes);
-    static void GetMei(Object *element, ArrayOfStrAttr *attributes);
-    static void GetMensural(Object *element, ArrayOfStrAttr *attributes);
+    static void GetMei(const Object *element, ArrayOfStrAttr *attributes);
+    static void GetMensural(const Object *element, ArrayOfStrAttr *attributes);
     // static void GetMidi(Object *element, ArrayOfStrAttr *attributes);
-    static void GetPagebased(Object *element, ArrayOfStrAttr *attributes);
+    static void GetPagebased(const Object *element, ArrayOfStrAttr *attributes);
     // static void GetPerformance(Object *element, ArrayOfStrAttr *attributes);
     // static void GetNeumes(Object *element, ArrayOfStrAttr *attributes);
-    static void GetShared(Object *element, ArrayOfStrAttr *attributes);
+    static void GetShared(const Object *element, ArrayOfStrAttr *attributes);
     // static void GetTablature(Object *element, ArrayOfStrAttr *attributes);
     // static void GetUsersymbols(Object *element, ArrayOfStrAttr *attributes);
     ///@}
 
 public:
     /** Dummy string converter */
-    std::string StrToStr(std::string str);
+    std::string StrToStr(std::string str) const;
 
     /** @name Basic converters for writing */
     ///@{
-    std::string DblToStr(double data);
-    std::string IntToStr(int data);
+    std::string DblToStr(double data) const;
+    std::string IntToStr(int data) const;
     ///@}
 
     /** @name Basic converters for reading */
     ///@{
-    double StrToDbl(std::string value);
-    int StrToInt(std::string value);
+    double StrToDbl(std::string value) const;
+    int StrToInt(std::string value) const;
     ///@}
 
     /** @name Converters for writing and reading */
     ///@{
-    std::string BeatrptRendToStr(data_BEATRPT_REND data);
-    data_BEATRPT_REND StrToBeatrptRend(std::string value);
+    std::string BeatrptRendToStr(data_BEATRPT_REND data) const;
+    data_BEATRPT_REND StrToBeatrptRend(std::string value) const;
 
-    std::string DurationToStr(data_DURATION data);
-    data_DURATION StrToDuration(std::string value);
+    std::string DurationToStr(data_DURATION data) const;
+    data_DURATION StrToDuration(std::string value) const;
 
-    std::string KeysignatureToStr(data_KEYSIGNATURE data);
-    data_KEYSIGNATURE StrToKeysignature(std::string value);
+    std::string KeysignatureToStr(data_KEYSIGNATURE data) const;
+    data_KEYSIGNATURE StrToKeysignature(std::string value) const;
 
-    std::string MeasurebeatToStr(data_MEASUREBEAT data);
-    data_MEASUREBEAT StrToMeasurebeat(std::string value);
+    std::string MeasurebeatToStr(data_MEASUREBEAT data) const;
+    data_MEASUREBEAT StrToMeasurebeat(std::string value) const;
 
-    std::string ModusmaiorToStr(data_MODUSMAIOR data);
-    data_MODUSMAIOR StrToModusmaior(std::string value);
+    std::string ModusmaiorToStr(data_MODUSMAIOR data) const;
+    data_MODUSMAIOR StrToModusmaior(std::string value) const;
 
-    std::string ModusminorToStr(data_MODUSMINOR data);
-    data_MODUSMINOR StrToModusminor(std::string value);
+    std::string ModusminorToStr(data_MODUSMINOR data) const;
+    data_MODUSMINOR StrToModusminor(std::string value) const;
 
-    std::string OctaveDisToStr(data_OCTAVE_DIS data);
-    data_OCTAVE_DIS StrToOctaveDis(std::string value);
+    std::string OctaveDisToStr(data_OCTAVE_DIS data) const;
+    data_OCTAVE_DIS StrToOctaveDis(std::string value) const;
 
-    std::string OrientationToStr(data_ORIENTATION data);
-    data_ORIENTATION StrToOrientation(std::string value);
+    std::string OrientationToStr(data_ORIENTATION data) const;
+    data_ORIENTATION StrToOrientation(std::string value) const;
 
-    std::string PitchnameToStr(data_PITCHNAME data);
-    data_PITCHNAME StrToPitchname(std::string value);
+    std::string PitchnameToStr(data_PITCHNAME data) const;
+    data_PITCHNAME StrToPitchname(std::string value) const;
 
-    std::string ProlatioToStr(data_PROLATIO data);
-    data_PROLATIO StrToProlatio(std::string value);
+    std::string ProlatioToStr(data_PROLATIO data) const;
+    data_PROLATIO StrToProlatio(std::string value) const;
 
-    std::string StemdirectionToStr(data_STEMDIRECTION data);
-    data_STEMDIRECTION StrToStemdirection(std::string value);
+    std::string StemdirectionToStr(data_STEMDIRECTION data) const;
+    data_STEMDIRECTION StrToStemdirection(std::string value) const;
 
-    std::string TempusToStr(data_TEMPUS data);
-    data_TEMPUS StrToTempus(std::string value);
+    std::string TempusToStr(data_TEMPUS data) const;
+    data_TEMPUS StrToTempus(std::string value) const;
 
-    std::string TieToStr(data_TIE data);
-    data_TIE StrToTie(std::string value);
+    std::string TieToStr(data_TIE data) const;
+    data_TIE StrToTie(std::string value) const;
 
-    std::string XsdPosintlistToStr(xsd_posIntList data);
-    xsd_posIntList StrToXsdPosintlist(std::string value);
+    std::string XsdPosintlistToStr(xsd_posIntList data) const;
+    xsd_posIntList StrToXsdPosintlist(std::string value) const;
     ///@}
 };
 
diff --git a/include/vrv/barline.h b/include/vrv/barline.h
index bafac923ef2..91511145c82 100644
--- a/include/vrv/barline.h
+++ b/include/vrv/barline.h
@@ -30,13 +30,13 @@ class BarLine : public LayerElement, public AttBarLineLog {
     BarLine();
     virtual ~BarLine();
     virtual void Reset();
-    virtual Object *Clone() { return new BarLine(*this); };
-    virtual std::string GetClassName() { return "BarLine"; };
-    virtual ClassId Is() { return BARLINE; };
+    virtual Object *Clone() const { return new BarLine(*this); };
+    virtual std::string GetClassName() const { return "BarLine"; };
+    virtual ClassId Is() const { return BARLINE; };
     ///@}
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     /**
      * Use to set the alignment for the Measure BarLine members.
@@ -47,7 +47,7 @@ class BarLine : public LayerElement, public AttBarLineLog {
     /*
      * Return true if the barLine type requires repetition dots to be drawn.
      */
-    bool HasRepetitionDots();
+    bool HasRepetitionDots() const;
 
 private:
     //
@@ -72,9 +72,9 @@ class BarLineAttr : public BarLine {
     ///@{
     BarLineAttr();
     virtual ~BarLineAttr();
-    virtual Object *Clone() { return new BarLineAttr(*this); };
-    virtual std::string GetClassName() { return "BarLineAttr"; };
-    virtual ClassId Is() { return BARLINE_ATTR; };
+    virtual Object *Clone() const { return new BarLineAttr(*this); };
+    virtual std::string GetClassName() const { return "BarLineAttr"; };
+    virtual ClassId Is() const { return BARLINE_ATTR; };
     ///@}
 };
 
diff --git a/include/vrv/beam.h b/include/vrv/beam.h
index 988b5839f56..abb1b02df80 100644
--- a/include/vrv/beam.h
+++ b/include/vrv/beam.h
@@ -32,11 +32,11 @@ class Beam : public LayerElement, public ObjectListInterface, public DrawingList
     Beam();
     virtual ~Beam();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Beam"; };
-    virtual ClassId Is() { return BEAM; };
+    virtual std::string GetClassName() const { return "Beam"; };
+    virtual ClassId Is() const { return BEAM; };
     ///@}
 
-    int GetNoteCount() { return this->GetChildCount(NOTE); };
+    int GetNoteCount() const { return this->GetChildCount(NOTE); };
 
     /**
      * Add an element (a note or a rest) to a beam.
@@ -45,7 +45,8 @@ class Beam : public LayerElement, public ObjectListInterface, public DrawingList
     void AddLayerElement(LayerElement *element);
 
     /**
-     * Return information about the position in the beam
+     * Return information about the position in the beam.
+     * (no const since the cached list is updated)
      */
     ///@{
     bool IsFirstInBeam(LayerElement *element);
@@ -55,7 +56,7 @@ class Beam : public LayerElement, public ObjectListInterface, public DrawingList
     /**
      *
      */
-    const ArrayOfBeamElementCoords *GetElementCoords() { return &m_beamElementCoords; };
+    const ArrayOfBeamElementCoords *GetElementCoords() const { return &m_beamElementCoords; };
 
 protected:
     /**
@@ -83,7 +84,7 @@ class Beam : public LayerElement, public ObjectListInterface, public DrawingList
     /**
      * An array of coordinates for each element
      **/
-    ArrayOfBeamElementCoords m_beamElementCoords;
+    mutable ArrayOfBeamElementCoords m_beamElementCoords;
 };
 
 //----------------------------------------------------------------------------
diff --git a/include/vrv/chord.h b/include/vrv/chord.h
index e548e530ed7..2a7266e07f5 100644
--- a/include/vrv/chord.h
+++ b/include/vrv/chord.h
@@ -46,15 +46,18 @@ class Chord : public LayerElement,
     Chord();
     virtual ~Chord();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Chord"; };
-    virtual ClassId Is() { return CHORD; };
+    virtual std::string GetClassName() const { return "Chord"; };
+    virtual ClassId Is() const { return CHORD; };
     ///@}
 
     virtual DurationInterface *GetDurationInterface() { return dynamic_cast<DurationInterface *>(this); }
-    virtual StemmedDrawingInterface *GetStemmedDrawingInterface() { return dynamic_cast<StemmedDrawingInterface *>(this); }
+    virtual StemmedDrawingInterface *GetStemmedDrawingInterface()
+    {
+        return dynamic_cast<StemmedDrawingInterface *>(this);
+    }
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     /**
      * Add an element (only note supported) to a chord.
@@ -112,10 +115,10 @@ class Chord : public LayerElement,
     /**
      * Clear the m_clusters vector and delete all the objects.
      */
-    void ClearClusters();
+    void ClearClusters() const;
 
 public:
-    std::list<ChordCluster *> m_clusters;
+    mutable std::list<ChordCluster *> m_clusters;
 
     /**
      * Number of ledger lines for the chord where:
diff --git a/include/vrv/clef.h b/include/vrv/clef.h
index 4fce8de0a42..68585cbcd5f 100644
--- a/include/vrv/clef.h
+++ b/include/vrv/clef.h
@@ -30,28 +30,28 @@ class Clef : public LayerElement, public AttClefshape, public AttLineloc, public
      */
     ///@{
     Clef();
-    Clef(ScoreDefInterface *clefAttr);
+    Clef(const ScoreDefInterface *clefAttr);
     void Init();
     virtual ~Clef();
     virtual void Reset();
-    virtual Object *Clone() { return new Clef(*this); };
-    virtual std::string GetClassName() { return "Clef"; };
-    virtual ClassId Is() { return CLEF; };
+    virtual Object *Clone() const { return new Clef(*this); };
+    virtual std::string GetClassName() const { return "Clef"; };
+    virtual ClassId Is() const { return CLEF; };
     ///@}
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     /**
      * Return the offset of the clef
      */
-    int GetClefOffset();
+    int GetClefOffset() const;
 
     /**
      * This is used for false clef offset calculation.
      * Returns 4 bytes with, from right to left, line, shape, dis and displace
      */
-    int GetClefId();
+    int GetClefId() const;
 
 private:
     //
diff --git a/include/vrv/custos.h b/include/vrv/custos.h
index 717bcc5d51d..f1c20c44f22 100644
--- a/include/vrv/custos.h
+++ b/include/vrv/custos.h
@@ -27,14 +27,14 @@ class Custos : public LayerElement, public PositionInterface {
     Custos();
     virtual ~Custos();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Custos"; };
-    virtual ClassId Is() { return CUSTOS; };
+    virtual std::string GetClassName() const { return "Custos"; };
+    virtual ClassId Is() const { return CUSTOS; };
     ///@}
 
     virtual PositionInterface *GetPositionInterface() { return dynamic_cast<PositionInterface *>(this); }
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
 private:
     //
diff --git a/include/vrv/dir.h b/include/vrv/dir.h
index dfa26a65d85..2f291f10b19 100644
--- a/include/vrv/dir.h
+++ b/include/vrv/dir.h
@@ -30,8 +30,8 @@ class Dir : public FloatingElement, public TextListInterface, public TextDirInte
     Dir();
     virtual ~Dir();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Dir"; };
-    virtual ClassId Is() { return DIR; };
+    virtual std::string GetClassName() const { return "Dir"; };
+    virtual ClassId Is() const { return DIR; };
     ///@}
 
     virtual TextDirInterface *GetTextDirInterface() { return dynamic_cast<TextDirInterface *>(this); }
diff --git a/include/vrv/doc.h b/include/vrv/doc.h
index 88ae4715487..a3003db2065 100644
--- a/include/vrv/doc.h
+++ b/include/vrv/doc.h
@@ -34,7 +34,7 @@ class Doc : public Object {
     // constructors and destructors
     Doc();
     virtual ~Doc();
-    virtual ClassId Is() { return DOC; }
+    virtual ClassId Is() const { return DOC; }
 
     void AddPage(Page *page);
 
@@ -52,44 +52,45 @@ class Doc : public Object {
      * Getter for the DocType.
      * The setter is Doc::Reset.
      */
-    DocType GetType() { return m_type; };
+    DocType GetType() const { return m_type; };
 
     /**
      * Check if the document has a page with the specified value
      */
-    bool HasPage(int pageIdx);
+    bool HasPage(int pageIdx) const;
 
     /**
     * Get the total page count
     */
-    int GetPageCount();
+    int GetPageCount() const;
 
     /**
      * @name Get the height or width for a glyph taking into account the staff and grace sizes
      */
     ///@{
-    int GetGlyphHeight(wchar_t smuflCode, int staffSize, bool graceSize);
-    int GetGlyphWidth(wchar_t smuflCode, int staffSize, bool graceSize);
-    int GetGlyphDescender(wchar_t smuflCode, int staffSize, bool graceSize);
-    int GetDrawingUnit(int staffSize);
-    int GetDrawingDoubleUnit(int staffSize);
-    int GetDrawingStaffSize(int staffSize);
-    int GetDrawingOctaveSize(int staffSize);
-    int GetDrawingBrevisWidth(int staffSize);
-    int GetDrawingBarLineWidth(int staffSize);
-    int GetDrawingStaffLineWidth(int staffSize);
-    int GetDrawingStemWidth(int staffSize);
-    int GetDrawingDirHeight(int staffSize, bool withMargin);
-    int GetDrawingDynamHeight(int staffSize, bool withMargin);
-    int GetDrawingHairpinSize(int staffSize, bool withMargin);
-    int GetDrawingBeamWidth(int staffSize, bool graceSize);
-    int GetDrawingBeamWhiteWidth(int staffSize, bool graceSize);
-    int GetDrawingLedgerLineLength(int staffSize, bool graceSize);
-    int GetGraceSize(int value);
+    int GetGlyphHeight(wchar_t smuflCode, int staffSize, bool graceSize) const;
+    int GetGlyphWidth(wchar_t smuflCode, int staffSize, bool graceSize) const;
+    int GetGlyphDescender(wchar_t smuflCode, int staffSize, bool graceSize) const;
+    int GetDrawingUnit(int staffSize) const;
+    int GetDrawingDoubleUnit(int staffSize) const;
+    int GetDrawingStaffSize(int staffSize) const;
+    int GetDrawingOctaveSize(int staffSize) const;
+    int GetDrawingBrevisWidth(int staffSize) const;
+    int GetDrawingBarLineWidth(int staffSize) const;
+    int GetDrawingStaffLineWidth(int staffSize) const;
+    int GetDrawingStemWidth(int staffSize) const;
+    int GetDrawingDirHeight(int staffSize, bool withMargin) const;
+    int GetDrawingDynamHeight(int staffSize, bool withMargin) const;
+    int GetDrawingHairpinSize(int staffSize, bool withMargin) const;
+    int GetDrawingBeamWidth(int staffSize, bool graceSize) const;
+    int GetDrawingBeamWhiteWidth(int staffSize, bool graceSize) const;
+    int GetDrawingLedgerLineLength(int staffSize, bool graceSize) const;
+    int GetGraceSize(int value) const;
     ///@}
 
     /**
      * @name Get the height or width for a glyph taking into account the staff and grace sizes
+     * (no const because the size of the member font is changed)
      */
     ///@{
     FontInfo *GetDrawingSmuflFont(int staffSize, bool graceSize);
@@ -113,18 +114,18 @@ class Doc : public Object {
      * @name Getters for tie and slur parameters
      */
     ///@{
-    char GetTieThickness() { return m_style->m_tieThickness; };
-    char GetSlurMinHeight() { return m_style->m_minSlurHeight; };
-    char GetSlurMaxHeight() { return m_style->m_maxSlurHeight; };
-    char GetSlurThickness() { return m_style->m_slurThickness; };
+    char GetTieThickness() const { return m_style->m_tieThickness; };
+    char GetSlurMinHeight() const { return m_style->m_minSlurHeight; };
+    char GetSlurMaxHeight() const { return m_style->m_maxSlurHeight; };
+    char GetSlurThickness() const { return m_style->m_slurThickness; };
     ///@}
 
     /**
      * @name Getters for the page dimensions and margins
      */
     ///@{
-    short GetSpacingStaff() { return m_spacingStaff; };
-    short GetSpacingSystem() { return m_spacingSystem; };
+    short GetSpacingStaff() const { return m_spacingStaff; };
+    short GetSpacingSystem() const { return m_spacingSystem; };
     ///@}
 
     /**
@@ -134,9 +135,9 @@ class Doc : public Object {
      * These should eventually be set at parameters.
      */
     ///@{
-    char GetLeftMargin(const ClassId classId);
-    char GetRightMargin(const ClassId classId);
-    char GetLeftPosition();
+    char GetLeftMargin(const ClassId classId) const;
+    char GetRightMargin(const ClassId classId) const;
+    char GetLeftPosition() const;
     ///@}
 
     /*
@@ -146,7 +147,7 @@ class Doc : public Object {
      */
     ///@{
     void SetJustificationX(bool drawingJustifyX) { m_drawingJustifyX = drawingJustifyX; };
-    bool GetJustificationX() { return m_drawingJustifyX; };
+    bool GetJustificationX() const { return m_drawingJustifyX; };
     ///@}
 
     /*
@@ -156,7 +157,7 @@ class Doc : public Object {
      */
     ///@{
     void SetEvenSpacing(bool drawingEvenSpacing) { m_drawingEvenSpacing = drawingEvenSpacing; };
-    bool GetEvenSpacing() { return m_drawingEvenSpacing; };
+    bool GetEvenSpacing() const { return m_drawingEvenSpacing; };
     ///@}
 
     /*
@@ -164,9 +165,9 @@ class Doc : public Object {
      */
     ///@{
     void SetSpacingLinear(double drawingSpacingLinear) { m_drawingSpacingLinear = drawingSpacingLinear; };
-    double GetSpacingLinear() { return m_drawingSpacingLinear; };
+    double GetSpacingLinear() const { return m_drawingSpacingLinear; };
     void SetSpacingNonLinear(double drawingSpacingNonLinear) { m_drawingSpacingNonLinear = drawingSpacingNonLinear; };
-    double GetSpacingNonLinear() { return m_drawingSpacingNonLinear; };
+    double GetSpacingNonLinear() const { return m_drawingSpacingNonLinear; };
     ///@}
 
     /**
@@ -227,19 +228,19 @@ class Doc : public Object {
      * be done with Doc::SetDrawingPage. This is only a method for
      * asserting that currently have the right page.
      */
-    Page *GetDrawingPage() { return m_drawingPage; };
+    Page *GetDrawingPage() const { return m_drawingPage; };
 
     /**
      * Return the width adjusted to the content of the current drawing page.
      * This includes the appropriate left and right margins.
      */
-    int GetAdjustedDrawingPageWidth();
+    int GetAdjustedDrawingPageWidth() const;
 
     /**
      * Return the height adjusted to the content of the current drawing page.
      * This includes the appropriate top and bottom margin (using top as bottom).
      */
-    int GetAdjustedDrawingPageHeight();
+    int GetAdjustedDrawingPageHeight() const;
 
     //----------//
     // Functors //
diff --git a/include/vrv/dot.h b/include/vrv/dot.h
index 8d77cf13845..2f2bf92af05 100644
--- a/include/vrv/dot.h
+++ b/include/vrv/dot.h
@@ -29,14 +29,14 @@ class Dot : public LayerElement, public PositionInterface {
     Dot();
     virtual ~Dot();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Dot"; };
-    virtual ClassId Is() { return DOT; };
+    virtual std::string GetClassName() const { return "Dot"; };
+    virtual ClassId Is() const { return DOT; };
     ///@}
 
     virtual PositionInterface *GetPositionInterface() { return dynamic_cast<PositionInterface *>(this); }
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     //----------//
     // Functors //
diff --git a/include/vrv/durationinterface.h b/include/vrv/durationinterface.h
index 63447fe61a3..ff5738f0c1f 100644
--- a/include/vrv/durationinterface.h
+++ b/include/vrv/durationinterface.h
@@ -75,7 +75,7 @@ class DurationInterface : public Interface,
      * For CMN, it is the same (DURATION_1 == DUR_1)
      * For mensural, we need to apply the DUR_MENSURAL_MASK
      */
-    int GetActualDur();
+    int GetActualDur() const;
 
     /**
      * If the element is part of a chord, return the chord actual duration, otherwise the note actual duration.
diff --git a/include/vrv/dynam.h b/include/vrv/dynam.h
index bcb3502e175..44183c95a3f 100644
--- a/include/vrv/dynam.h
+++ b/include/vrv/dynam.h
@@ -30,8 +30,8 @@ class Dynam : public FloatingElement, public TextListInterface, public TextDirIn
     Dynam();
     virtual ~Dynam();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Dynam"; };
-    virtual ClassId Is() { return DYNAM; };
+    virtual std::string GetClassName() const { return "Dynam"; };
+    virtual ClassId Is() const { return DYNAM; };
     ///@}
 
     virtual TextDirInterface *GetTextDirInterface() { return dynamic_cast<TextDirInterface *>(this); }
@@ -49,7 +49,7 @@ class Dynam : public FloatingElement, public TextListInterface, public TextDirIn
      */
     bool IsSymbolOnly();
 
-    std::wstring GetSymbolStr();
+    std::wstring GetSymbolStr() const;
 
     //----------//
     // Functors //
diff --git a/include/vrv/editorial.h b/include/vrv/editorial.h
index b4bd5bd7499..55590cef159 100644
--- a/include/vrv/editorial.h
+++ b/include/vrv/editorial.h
@@ -46,7 +46,7 @@ class EditorialElement : public Object, public AttCommon, public AttCommonPart {
     EditorialElement(std::string classid);
     virtual ~EditorialElement();
     virtual void Reset();
-    virtual ClassId Is() { return EDITORIAL_ELEMENT; };
+    virtual ClassId Is() const { return EDITORIAL_ELEMENT; };
     ///@}
 
     /**
@@ -102,8 +102,8 @@ class Abbr : public EditorialElement, public AttSource {
     Abbr();
     virtual ~Abbr();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Abbr"; };
-    virtual ClassId Is() { return ABBR; };
+    virtual std::string GetClassName() const { return "Abbr"; };
+    virtual ClassId Is() const { return ABBR; };
     ///@}
 
 private:
@@ -127,8 +127,8 @@ class Add : public EditorialElement, public AttSource {
     Add();
     virtual ~Add();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Add"; };
-    virtual ClassId Is() { return ADD; };
+    virtual std::string GetClassName() const { return "Add"; };
+    virtual ClassId Is() const { return ADD; };
     ///@}
 
 private:
@@ -152,8 +152,8 @@ class Annot : public EditorialElement, public AttPlist, public AttSource {
     Annot();
     virtual ~Annot();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Annot"; };
-    virtual ClassId Is() { return ANNOT; };
+    virtual std::string GetClassName() const { return "Annot"; };
+    virtual ClassId Is() const { return ANNOT; };
     ///@}
 
 private:
@@ -182,8 +182,8 @@ class App : public EditorialElement {
     App(EditorialLevel level);
     virtual ~App();
     virtual void Reset();
-    virtual std::string GetClassName() { return "App"; };
-    virtual ClassId Is() { return APP; };
+    virtual std::string GetClassName() const { return "App"; };
+    virtual ClassId Is() const { return APP; };
     ///@}
 
     /** Getter for level **/
@@ -220,8 +220,8 @@ class Corr : public EditorialElement, public AttSource {
     Corr();
     virtual ~Corr();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Corr"; };
-    virtual ClassId Is() { return CORR; };
+    virtual std::string GetClassName() const { return "Corr"; };
+    virtual ClassId Is() const { return CORR; };
     ///@}
 
 private:
@@ -245,8 +245,8 @@ class Damage : public EditorialElement, public AttSource {
     Damage();
     virtual ~Damage();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Damage"; };
-    virtual ClassId Is() { return DAMAGE; };
+    virtual std::string GetClassName() const { return "Damage"; };
+    virtual ClassId Is() const { return DAMAGE; };
     ///@}
 
 private:
@@ -270,8 +270,8 @@ class Del : public EditorialElement, public AttSource {
     Del();
     virtual ~Del();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Del"; };
-    virtual ClassId Is() { return DEL; };
+    virtual std::string GetClassName() const { return "Del"; };
+    virtual ClassId Is() const { return DEL; };
     ///@}
 
 private:
@@ -295,8 +295,8 @@ class Expan : public EditorialElement, public AttSource {
     Expan();
     virtual ~Expan();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Expan"; };
-    virtual ClassId Is() { return EXPAN; };
+    virtual std::string GetClassName() const { return "Expan"; };
+    virtual ClassId Is() const { return EXPAN; };
     ///@}
 
 private:
@@ -320,8 +320,8 @@ class Lem : public EditorialElement, public AttSource {
     Lem();
     virtual ~Lem();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Lem"; };
-    virtual ClassId Is() { return LEM; };
+    virtual std::string GetClassName() const { return "Lem"; };
+    virtual ClassId Is() const { return LEM; };
     ///@}
 
 private:
@@ -345,8 +345,8 @@ class Orig : public EditorialElement, public AttSource {
     Orig();
     virtual ~Orig();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Orig"; };
-    virtual ClassId Is() { return ORIG; };
+    virtual std::string GetClassName() const { return "Orig"; };
+    virtual ClassId Is() const { return ORIG; };
     ///@}
 
 private:
@@ -370,8 +370,8 @@ class Rdg : public EditorialElement, public AttSource {
     Rdg();
     virtual ~Rdg();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Rdg"; };
-    virtual ClassId Is() { return RDG; };
+    virtual std::string GetClassName() const { return "Rdg"; };
+    virtual ClassId Is() const { return RDG; };
     ///@}
 
 private:
@@ -395,8 +395,8 @@ class Reg : public EditorialElement, public AttSource {
     Reg();
     virtual ~Reg();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Reg"; };
-    virtual ClassId Is() { return REG; };
+    virtual std::string GetClassName() const { return "Reg"; };
+    virtual ClassId Is() const { return REG; };
     ///@}
 
 private:
@@ -420,8 +420,8 @@ class Restore : public EditorialElement, public AttSource {
     Restore();
     virtual ~Restore();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Restore"; };
-    virtual ClassId Is() { return RESTORE; };
+    virtual std::string GetClassName() const { return "Restore"; };
+    virtual ClassId Is() const { return RESTORE; };
     ///@}
 
 private:
@@ -445,8 +445,8 @@ class Sic : public EditorialElement, public AttSource {
     Sic();
     virtual ~Sic();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Sic"; };
-    virtual ClassId Is() { return SIC; };
+    virtual std::string GetClassName() const { return "Sic"; };
+    virtual ClassId Is() const { return SIC; };
     ///@}
 
 private:
@@ -470,8 +470,8 @@ class Supplied : public EditorialElement, public AttSource {
     Supplied();
     virtual ~Supplied();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Supplied"; };
-    virtual ClassId Is() { return SUPPLIED; };
+    virtual std::string GetClassName() const { return "Supplied"; };
+    virtual ClassId Is() const { return SUPPLIED; };
     ///@}
 
 private:
@@ -495,8 +495,8 @@ class Unclear : public EditorialElement, public AttSource {
     Unclear();
     virtual ~Unclear();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Unclear"; };
-    virtual ClassId Is() { return UNCLEAR; };
+    virtual std::string GetClassName() const { return "Unclear"; };
+    virtual ClassId Is() const { return UNCLEAR; };
     ///@}
 
 private:
diff --git a/include/vrv/floatingelement.h b/include/vrv/floatingelement.h
index 048494785b9..f9161b8a8ff 100644
--- a/include/vrv/floatingelement.h
+++ b/include/vrv/floatingelement.h
@@ -33,7 +33,7 @@ class FloatingElement : public Object {
     FloatingElement(std::string classid);
     virtual ~FloatingElement();
     virtual void Reset();
-    virtual ClassId Is() { return FLOATING_ELEMENT; };
+    virtual ClassId Is() const { return FLOATING_ELEMENT; };
     ///@}
 
     virtual void UpdateContentBBoxX(int x1, int x2){};
@@ -96,7 +96,7 @@ class FloatingBoundingBox : public BoundingBox {
      * @name Get and set the Y drawing relative position
      */
     ///@{
-    int GetDrawingYRel() { return m_drawingYRel; };
+    int GetDrawingYRel() const { return m_drawingYRel; };
     void SetDrawingYRel(int drawingYRel) { m_drawingYRel = drawingYRel; };
     ///@}
 
diff --git a/include/vrv/hairpin.h b/include/vrv/hairpin.h
index feea0327c20..8ddb0636a12 100644
--- a/include/vrv/hairpin.h
+++ b/include/vrv/hairpin.h
@@ -28,8 +28,8 @@ class Hairpin : public FloatingElement, public TimeSpanningInterface, public Att
     Hairpin();
     virtual ~Hairpin();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Hairpin"; };
-    virtual ClassId Is() { return HAIRPIN; };
+    virtual std::string GetClassName() const { return "Hairpin"; };
+    virtual ClassId Is() const { return HAIRPIN; };
     ///@}
 
     virtual TimePointInterface *GetTimePointInterface() { return dynamic_cast<TimePointInterface *>(this); }
diff --git a/include/vrv/keysig.h b/include/vrv/keysig.h
index 31cbc30acc4..82fe51c81eb 100644
--- a/include/vrv/keysig.h
+++ b/include/vrv/keysig.h
@@ -40,23 +40,23 @@ class KeySig : public LayerElement, public AttAccidental, public AttPitch {
     ///@{
     KeySig();
     KeySig(int alterationNumber, data_ACCIDENTAL_EXPLICIT alterationType);
-    KeySig(ScoreDefInterface *keySigAttr);
+    KeySig(const ScoreDefInterface *keySigAttr);
     void Init();
     virtual ~KeySig();
     virtual void Reset();
-    virtual Object *Clone() { return new KeySig(*this); };
-    virtual std::string GetClassName() { return "KeySig"; };
-    virtual ClassId Is() { return KEYSIG; };
+    virtual Object *Clone() const { return new KeySig(*this); };
+    virtual std::string GetClassName() const { return "KeySig"; };
+    virtual ClassId Is() const { return KEYSIG; };
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     /* Alteration number getter/setter */
-    int GetAlterationNumber() { return m_alterationNumber; };
+    int GetAlterationNumber() const { return m_alterationNumber; };
     void SetAlterationNumber(int alterationNumber) { m_alterationNumber = alterationNumber; };
 
     /* Alteration number getter/setter */
-    data_ACCIDENTAL_EXPLICIT GetAlterationType() { return m_alterationType; };
+    data_ACCIDENTAL_EXPLICIT GetAlterationType() const { return m_alterationType; };
     void SetAlterationType(data_ACCIDENTAL_EXPLICIT alterationType) { m_alterationType = alterationType; };
 
     /* Temporary methods for turning @accid and @pitch into num_alter and alter */
diff --git a/include/vrv/layer.h b/include/vrv/layer.h
index a00dbae86a4..da89ec7c679 100644
--- a/include/vrv/layer.h
+++ b/include/vrv/layer.h
@@ -44,8 +44,8 @@ class Layer : public Object,
     Layer();
     virtual ~Layer();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Layer"; };
-    virtual ClassId Is() { return LAYER; };
+    virtual std::string GetClassName() const { return "Layer"; };
+    virtual ClassId Is() const { return LAYER; };
     ///@}
 
     /**
@@ -91,7 +91,7 @@ class Layer : public Object,
      */
     ///@{
     void SetDrawingStemDir(data_STEMDIRECTION stemDirection) { m_drawingStemDir = stemDirection; };
-    data_STEMDIRECTION GetDrawingStemDir() { return m_drawingStemDir; };
+    data_STEMDIRECTION GetDrawingStemDir() const { return m_drawingStemDir; };
     ///@}
 
     //----------//
diff --git a/include/vrv/layerelement.h b/include/vrv/layerelement.h
index 9bb40020ebe..d06d09d20c6 100644
--- a/include/vrv/layerelement.h
+++ b/include/vrv/layerelement.h
@@ -39,7 +39,7 @@ class LayerElement : public Object {
     LayerElement(std::string classid);
     virtual ~LayerElement();
     virtual void Reset();
-    virtual ClassId Is() { return LAYER_ELEMENT; };
+    virtual ClassId Is() const { return LAYER_ELEMENT; };
     ///@}
 
     /**
@@ -68,13 +68,13 @@ class LayerElement : public Object {
      */
     ///@{
     /** Return true if the element is a grace note */
-    bool IsGraceNote();
+    bool IsGraceNote() const;
     /** Return true if the element is a note or a note child and the note has a @grace */
     bool IsCueSize();
     /** Return true if the element is a note or a chord within a fTrem */
     bool IsInFTrem();
     /** Return true if the element has to be aligned horizontally */
-    virtual bool HasToBeAligned() { return false; };
+    virtual bool HasToBeAligned() const { return false; };
     /**
      * Return the beam parent if in beam
      * Look if the note or rest is in a beam.
@@ -94,9 +94,9 @@ class LayerElement : public Object {
     /**
      * Alignment getter
      */
-    Alignment *GetAlignment() { return m_alignment; };
+    Alignment *GetAlignment() const { return m_alignment; };
 
-    int GetXRel();
+    int GetXRel() const;
 
     /**
      * Returns the duration if the child element has a DurationInterface
@@ -140,7 +140,7 @@ class LayerElement : public Object {
      *  See Object:ExportMIDI
      */
     virtual int ExportMIDIEnd(ArrayPtrVoid *params);
-    
+
     /**
      * See Object::CalcMaxMeasureDuration
      */
diff --git a/include/vrv/measure.h b/include/vrv/measure.h
index 103302eec9b..9d46448bc54 100644
--- a/include/vrv/measure.h
+++ b/include/vrv/measure.h
@@ -39,14 +39,14 @@ class Measure : public Object, public AttCommon, public AttMeasureLog, public At
     Measure(bool measuredMusic = true, int logMeasureNb = -1);
     virtual ~Measure();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Measure"; };
-    virtual ClassId Is() { return MEASURE; };
+    virtual std::string GetClassName() const { return "Measure"; };
+    virtual ClassId Is() const { return MEASURE; };
     ///@}
 
     /**
      * Return true if measured music (otherwise we have fake measures)
      */
-    bool IsMeasuredMusic() { return m_measuredMusic; };
+    bool IsMeasuredMusic() const { return m_measuredMusic; };
 
     /**
      * @name Methods for adding allowed content
@@ -90,29 +90,29 @@ class Measure : public Object, public AttCommon, public AttMeasureLog, public At
      * not for creating other measure objects.
      */
     ///@{
-    BarLine *GetLeftBarLine() { return &m_leftBarLine; };
-    BarLine *GetRightBarLine() { return &m_rightBarLine; };
+    BarLine *const GetLeftBarLine() { return &m_leftBarLine; };
+    BarLine *const GetRightBarLine() { return &m_rightBarLine; };
     ///@}
 
-    int GetXRel();
+    int GetXRel() const;
 
     /**
      * Return the non-justifiable left margin for the measure
      */
-    int GetNonJustifiableLeftMargin() { return m_measureAligner.GetNonJustifiableMargin(); }
+    int GetNonJustifiableLeftMargin() const { return m_measureAligner.GetNonJustifiableMargin(); }
 
     /**
      * @name Return the X rel position of the right and left barLine (without their width)
      */
     ///@{
-    int GetLeftBarLineX();
-    int GetRightBarLineX();
+    int GetLeftBarLineX() const;
+    int GetRightBarLineX() const;
     ///@}
 
     /**
      * Return the width of the measure, including the barLine width
      */
-    int GetWidth();
+    int GetWidth() const;
 
     //----------//
     // Functors //
diff --git a/include/vrv/mensur.h b/include/vrv/mensur.h
index f69763f5554..6d6ca71a306 100644
--- a/include/vrv/mensur.h
+++ b/include/vrv/mensur.h
@@ -36,17 +36,17 @@ class Mensur : public LayerElement,
      */
     ///@{
     Mensur();
-    Mensur(ScoreDefInterface *mensurAttr);
+    Mensur(const ScoreDefInterface *mensurAttr);
     void Init();
     virtual ~Mensur();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Mensur"; };
-    virtual ClassId Is() { return MENSUR; };
-    virtual Object *Clone() { return new Mensur(*this); };
+    virtual std::string GetClassName() const { return "Mensur"; };
+    virtual ClassId Is() const { return MENSUR; };
+    virtual Object *Clone() const { return new Mensur(*this); };
     ///@}
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
 private:
     //
diff --git a/include/vrv/metersig.h b/include/vrv/metersig.h
index 31a4b38275f..1df5f2577a2 100644
--- a/include/vrv/metersig.h
+++ b/include/vrv/metersig.h
@@ -30,17 +30,17 @@ class MeterSig : public LayerElement, public AttMeterSigLog {
      */
     ///@{
     MeterSig();
-    MeterSig(ScoreDefInterface *meterSigAttr);
+    MeterSig(const ScoreDefInterface *meterSigAttr);
     void Init();
     virtual ~MeterSig();
     virtual void Reset();
-    virtual std::string GetClassName() { return "MeterSig"; };
-    virtual ClassId Is() { return METERSIG; };
-    virtual Object *Clone() { return new MeterSig(*this); };
+    virtual std::string GetClassName() const { return "MeterSig"; };
+    virtual ClassId Is() const { return METERSIG; };
+    virtual Object *Clone() const { return new MeterSig(*this); };
     ///@}
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
 private:
     //
diff --git a/include/vrv/mrest.h b/include/vrv/mrest.h
index f04157104da..e29e9f9e7e9 100644
--- a/include/vrv/mrest.h
+++ b/include/vrv/mrest.h
@@ -29,9 +29,8 @@ class MRest : public LayerElement {
     MRest();
     virtual ~MRest();
     virtual void Reset();
-    virtual std::string GetClassName() { return "MRest"; };
-    ;
-    virtual ClassId Is() { return MREST; };
+    virtual std::string GetClassName() const { return "MRest"; };
+    virtual ClassId Is() const { return MREST; };
     ///@}
 
 private:
diff --git a/include/vrv/multirest.h b/include/vrv/multirest.h
index 0f53c7d489c..3a1aa60d29c 100644
--- a/include/vrv/multirest.h
+++ b/include/vrv/multirest.h
@@ -31,8 +31,8 @@ class MultiRest : public LayerElement, public AttNumbered {
     // MultiRest(int number);
     virtual ~MultiRest();
     virtual void Reset();
-    virtual std::string GetClassName() { return "MultiRest"; };
-    virtual ClassId Is() { return MULTIREST; };
+    virtual std::string GetClassName() const { return "MultiRest"; };
+    virtual ClassId Is() const { return MULTIREST; };
     ///@}
 
 private:
diff --git a/include/vrv/note.h b/include/vrv/note.h
index 6529edbd05e..8ea4b372ddc 100644
--- a/include/vrv/note.h
+++ b/include/vrv/note.h
@@ -62,16 +62,16 @@ class Note : public LayerElement,
     Note();
     virtual ~Note();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Note"; };
-    virtual ClassId Is() { return NOTE; };
+    virtual std::string GetClassName() const { return "Note"; };
+    virtual ClassId Is() const { return NOTE; };
     ///@}
 
-    virtual DurationInterface *GetDurationInterface() { return dynamic_cast<DurationInterface *>(this); }
+    virtual DurationInterface * GetDurationInterface() { return dynamic_cast<DurationInterface *>(this); }
     virtual PitchInterface *GetPitchInterface() { return dynamic_cast<PitchInterface *>(this); }
     virtual StemmedDrawingInterface *GetStemmedDrawingInterface() { return dynamic_cast<StemmedDrawingInterface *>(this); }
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     /**
      * Add an element (a verse or an accid) to a note.
@@ -86,7 +86,7 @@ class Note : public LayerElement,
     void ResetDrawingAccid();
     void ResetDrawingTieAttr();
     void SetDrawingTieAttr();
-    Tie *GetDrawingTieAttr() { return m_drawingTieAttr; };
+    Tie *GetDrawingTieAttr() const { return m_drawingTieAttr; };
     ///@}
 
     /**
@@ -95,7 +95,7 @@ class Note : public LayerElement,
     ///@{
     Alignment *GetGraceAlignment();
     void SetGraceAlignment(Alignment *graceAlignment);
-    bool HasGraceAlignment() { return (m_graceAlignment != NULL); };
+    bool HasGraceAlignment() const { return (m_graceAlignment != NULL); };
     void ResetGraceAlignment() { m_graceAlignment = NULL; };
     ///@}
 
@@ -105,13 +105,13 @@ class Note : public LayerElement,
     ///@{
     Chord *IsChordTone();
     int GetDrawingDur();
-    bool IsClusterExtreme(); // used to find if it is the highest or lowest note in a cluster
+    bool IsClusterExtreme() const; // used to find if it is the highest or lowest note in a cluster
     ///@}
 
     /**
      * Returns a single integer representing pitch and octave.
      */
-    int GetDiatonicPitch() { return this->GetPname() + (int)this->GetOct() * 7; };
+    int GetDiatonicPitch() const { return this->GetPname() + (int)this->GetOct() * 7; };
 
     //----------//
     // Functors //
diff --git a/include/vrv/object.h b/include/vrv/object.h
index eb21708aa12..ea078b47bf3 100644
--- a/include/vrv/object.h
+++ b/include/vrv/object.h
@@ -92,8 +92,8 @@ class BoundingBox {
      * @name Get and set the X and Y drawing position
      */
     ///@{
-    int GetDrawingX() { return m_drawingX; };
-    int GetDrawingY() { return m_drawingY; };
+    int GetDrawingX() const { return m_drawingX; };
+    int GetDrawingY() const { return m_drawingY; };
     void SetDrawingX(int drawingX) { m_drawingX = drawingX; };
     void SetDrawingY(int drawingY) { m_drawingY = drawingY; };
     ///@}
@@ -102,7 +102,7 @@ class BoundingBox {
      * Is true if the bounding box (self or content) has been updated at least once.
      * We need this to avoid not updating bounding boxes to screw up the layout with their initial values.
      */
-    bool HasUpdatedBB() { return (m_updatedBBoxX && m_updatedBBoxY); };
+    bool HasUpdatedBB() const { return (m_updatedBBoxX && m_updatedBBoxY); };
 
 private:
     bool m_updatedBBoxX;
@@ -142,8 +142,8 @@ class Object : public BoundingBox {
     Object();
     Object(std::string classid);
     virtual ~Object();
-    virtual ClassId Is();
-    virtual std::string GetClassName() { return "[MISSING]"; };
+    virtual ClassId Is() const;
+    virtual std::string GetClassName() const { return "[MISSING]"; };
     ///@}
 
     /**
@@ -152,11 +152,11 @@ class Object : public BoundingBox {
      * See classId enum.
      */
     ///@{
-    bool IsEditorialElement() { return (this->Is() > EDITORIAL_ELEMENT && this->Is() < EDITORIAL_ELEMENT_max); };
-    bool IsLayerElement() { return (this->Is() > LAYER_ELEMENT && this->Is() < LAYER_ELEMENT_max); };
-    bool IsFloatingElement() { return (this->Is() > FLOATING_ELEMENT && this->Is() < FLOATING_ELEMENT_max); };
-    bool IsScoreDefElement() { return (this->Is() > SCOREDEF_ELEMENT && this->Is() < SCOREDEF_ELEMENT_max); };
-    bool IsTextElement() { return (this->Is() > TEXT_ELEMENT && this->Is() < TEXT_ELEMENT_max); };
+    bool IsEditorialElement() const { return (this->Is() > EDITORIAL_ELEMENT && this->Is() < EDITORIAL_ELEMENT_max); };
+    bool IsLayerElement() const { return (this->Is() > LAYER_ELEMENT && this->Is() < LAYER_ELEMENT_max); };
+    bool IsFloatingElement() const { return (this->Is() > FLOATING_ELEMENT && this->Is() < FLOATING_ELEMENT_max); };
+    bool IsScoreDefElement() const { return (this->Is() > SCOREDEF_ELEMENT && this->Is() < SCOREDEF_ELEMENT_max); };
+    bool IsTextElement() const { return (this->Is() > TEXT_ELEMENT && this->Is() < TEXT_ELEMENT_max); };
     ///@}
 
     /**
@@ -164,12 +164,12 @@ class Object : public BoundingBox {
      */
     ///@{
     void RegisterAttClass(AttClassId attClassId) { m_attClasses.push_back(attClassId); };
-    bool HasAttClass(AttClassId attClassId)
+    bool HasAttClass(AttClassId attClassId) const
     {
         return std::find(m_attClasses.begin(), m_attClasses.end(), attClassId) != m_attClasses.end();
     };
     void RegisterInterface(std::vector<AttClassId> *attClasses, InterfaceId interfaceId);
-    bool HasInterface(InterfaceId interfaceId)
+    bool HasInterface(InterfaceId interfaceId) const
     {
         return std::find(m_interfaces.begin(), m_interfaces.end(), interfaceId) != m_interfaces.end();
     };
@@ -216,9 +216,9 @@ class Object : public BoundingBox {
      * Method call for copying child classes.
      * The method has to be overridden.
      */
-    virtual Object *Clone();
+    virtual Object *Clone() const;
 
-    std::string GetUuid() { return m_uuid; };
+    std::string GetUuid() const { return m_uuid; };
     void SetUuid(std::string uuid);
     void ResetUuid();
 
@@ -228,25 +228,25 @@ class Object : public BoundingBox {
      * The method with a ClassId only searches at the first level.
      */
     ///@{
-    int GetChildCount() { return (int)m_children.size(); };
-    int GetChildCount(const ClassId classId);
+    int GetChildCount() const { return (int)m_children.size(); };
+    int GetChildCount(const ClassId classId) const;
     ///@}
 
     /**
      * Child access (generic)
      */
-    Object *GetChild(int idx);
+    Object *GetChild(int idx) const;
 
     /**
      * Fill an array of pairs with all attributes and their values.
      * Return the number of attributes found.
      */
-    int GetAttributes(ArrayOfStrAttr *attributes);
+    int GetAttributes(ArrayOfStrAttr *attributes) const;
 
     /**
      * Check if an Object has an attribute with the specified value
      */
-    bool HasAttribute(std::string attribute, std::string value);
+    bool HasAttribute(std::string attribute, std::string value) const;
 
     /**
      * @name Iterator methods for accessing children.
@@ -263,7 +263,7 @@ class Object : public BoundingBox {
     /**
      * Return the last child of the object (if any, NULL otherwise)
      */
-    Object *GetLast();
+    Object *GetLast() const;
 
     /**
      * Set the parent of the Object.
@@ -358,15 +358,10 @@ class Object : public BoundingBox {
      */
     void FillFlatList(ListOfObjects *list);
 
-    /**
-     * Parse the sameAs attribute and return the one at the #idx position (if any).
-     */
-    bool GetSameAs(std::string *id, std::string *filename, int idx = 0);
-
     /**
      * Check if the content was modified or not
      */
-    bool IsModified() { return m_isModified; };
+    bool IsModified() const { return m_isModified; };
 
     /**
      * Mark the object and its parent (if any) as modified
@@ -790,17 +785,17 @@ class Object : public BoundingBox {
 protected:
     ArrayOfObjects m_children;
 
+private:
     std::string m_uuid;
     std::string m_classid;
 
-private:
     /**
      * Indicates whether the object content is up-to-date or not.
      * This is useful for object using sub-lists of objects when drawing.
      * For example, Beam has a list of children notes and this value indicates if the
      * list needs to be updated or not. Is is mostly an optimization feature.
      */
-    bool m_isModified;
+    mutable bool m_isModified;
 
     /**
      * Members used for caching iterator values.
@@ -853,12 +848,12 @@ class ObjectListInterface {
     /**
      * Returns the previous object in the list (NULL if not found)
      */
-    Object *GetListPrevious(const Object *listElement);
+    Object *GetListPrevious(Object *listElement);
 
     /**
      * Returns the next object in the list (NULL if not found)
      */
-    Object *GetListNext(const Object *listElement);
+    Object *GetListNext(Object *listElement);
 
     /**
      * Return the list.
@@ -877,7 +872,7 @@ class ObjectListInterface {
      * Filter the list for a specific class.
      * For example, keep only notes in Beam
      */
-    virtual void FilterList(ListOfObjects *childList){};
+    virtual void FilterList(ListOfObjects *childList) {};
 
 public:
     /**
diff --git a/include/vrv/page.h b/include/vrv/page.h
index a4e3bad6207..87a4c990634 100644
--- a/include/vrv/page.h
+++ b/include/vrv/page.h
@@ -36,8 +36,8 @@ class Page : public Object {
     Page();
     virtual ~Page();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Page"; };
-    virtual ClassId Is() { return PAGE; };
+    virtual std::string GetClassName() const { return "Page"; };
+    virtual ClassId Is() const { return PAGE; };
     ///@}
 
     /**
@@ -57,7 +57,7 @@ class Page : public Object {
     /**
      * Return the position of the staff on the page, from top to bottom
      */
-    int GetStaffPosOnPage(Staff *staff);
+    int GetStaffPosOnPage(Staff *staff) const;
 
     /**
      * Do the layout of the page, which means aligning its content horizontally
@@ -91,7 +91,7 @@ class Page : public Object {
      * This is used for adjusting the page height when this is the expected behaviour,
      * typically with the --adjust-page-height option in the commandline tool
      */
-    int GetContentHeight();
+    int GetContentHeight() const;
 
     /**
      * Return the width of the content by looking at the first system of the page.
@@ -99,7 +99,7 @@ class Page : public Object {
      * typically with the --no_layout option in the commandline tool
      *
      */
-    int GetContentWidth();
+    int GetContentWidth() const;
 
     //----------//
     // Functors //
diff --git a/include/vrv/proport.h b/include/vrv/proport.h
index 5fb1d1ebc4f..810cc0edb63 100644
--- a/include/vrv/proport.h
+++ b/include/vrv/proport.h
@@ -30,13 +30,13 @@ class Proport : public LayerElement, public AttDurationRatio {
     Proport();
     virtual ~Proport();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Proport"; };
-    virtual ClassId Is() { return PROPORT; };
-    virtual Object *Clone() { return new Proport(*this); };
+    virtual std::string GetClassName() const { return "Proport"; };
+    virtual ClassId Is() const { return PROPORT; };
+    virtual Object *Clone() const { return new Proport(*this); };
     ///@}
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
 private:
     //
diff --git a/include/vrv/rest.h b/include/vrv/rest.h
index dcbba83c0ac..2f31b29203e 100644
--- a/include/vrv/rest.h
+++ b/include/vrv/rest.h
@@ -31,8 +31,8 @@ class Rest : public LayerElement, public DurationInterface, public PositionInter
     Rest();
     virtual ~Rest();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Rest"; };
-    virtual ClassId Is() { return REST; };
+    virtual std::string GetClassName() const { return "Rest"; };
+    virtual ClassId Is() const { return REST; };
     ///@}
 
     virtual PositionInterface *GetPositionInterface() { return dynamic_cast<PositionInterface *>(this); }
@@ -40,7 +40,7 @@ class Rest : public LayerElement, public DurationInterface, public PositionInter
     virtual DurationInterface *GetDurationInterface() { return dynamic_cast<DurationInterface *>(this); }
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
 private:
     //
diff --git a/include/vrv/rpt.h b/include/vrv/rpt.h
index efded9a7d44..a0b8d7444d6 100644
--- a/include/vrv/rpt.h
+++ b/include/vrv/rpt.h
@@ -31,18 +31,18 @@ class BeatRpt : public LayerElement, public AttBeatRptVis {
     BeatRpt();
     virtual ~BeatRpt();
     virtual void Reset();
-    virtual std::string GetClassName() { return "BeatRpt"; };
-    ;
-    virtual ClassId Is() { return BEATRPT; };
+    virtual std::string GetClassName() const { return "BeatRpt"; };
+    virtual ClassId Is() const { return BEATRPT; };
     ///@}
 
     /** Override the method since alignment is required */
-    virtual bool HasToBeAligned() { return true; };
+    virtual bool HasToBeAligned() const { return true; };
 
     /**
      * Returns the duration (in double) for the BeatRpt.
      */
-    virtual double GetBeatRptAlignmentDuration(int meterUnit);
+
+    double GetBeatRptAlignmentDuration(int meterUnit) const;
 
 private:
     //
@@ -68,9 +68,8 @@ class BTrem : public LayerElement {
     BTrem();
     virtual ~BTrem();
     virtual void Reset();
-    virtual std::string GetClassName() { return "BTrem"; };
-    ;
-    virtual ClassId Is() { return BTREM; };
+    virtual std::string GetClassName() const { return "BTrem"; };
+    virtual ClassId Is() const { return BTREM; }
     ///@}
 
     /**
@@ -103,9 +102,8 @@ class FTrem : public LayerElement, public ObjectListInterface, public AttSlashco
     FTrem();
     virtual ~FTrem();
     virtual void Reset();
-    virtual std::string GetClassName() { return "FTrem"; };
-    ;
-    virtual ClassId Is() { return FTREM; };
+    virtual std::string GetClassName() const { return "FTrem"; };
+    virtual ClassId Is() const { return FTREM; };
     ///@}
 
     /**
@@ -144,9 +142,8 @@ class MRpt : public LayerElement {
     MRpt();
     virtual ~MRpt();
     virtual void Reset();
-    virtual std::string GetClassName() { return "MRpt"; };
-    ;
-    virtual ClassId Is() { return MRPT; };
+    virtual std::string GetClassName() const { return "MRpt"; };
+    virtual ClassId Is() const { return MRPT; };
     ///@}
 
     //----------//
@@ -185,9 +182,8 @@ class MRpt2 : public LayerElement {
     MRpt2();
     virtual ~MRpt2();
     virtual void Reset();
-    virtual std::string GetClassName() { return "MRpt2"; };
-    ;
-    virtual ClassId Is() { return MRPT2; };
+    virtual std::string GetClassName() const { return "MRpt2"; };
+    virtual ClassId Is() const { return MRPT2; };
     ///@}
 
 private:
@@ -214,9 +210,8 @@ class MultiRpt : public LayerElement, public AttNumbered {
     MultiRpt();
     virtual ~MultiRpt();
     virtual void Reset();
-    virtual std::string GetClassName() { return "MultiRpt"; };
-    ;
-    virtual ClassId Is() { return MULTIRPT; };
+    virtual std::string GetClassName() const { return "MultiRpt"; };
+    virtual ClassId Is() const { return MULTIRPT; };
     ///@}
 
 private:
diff --git a/include/vrv/scoredef.h b/include/vrv/scoredef.h
index 35c97a1d9de..398a84d4bd1 100644
--- a/include/vrv/scoredef.h
+++ b/include/vrv/scoredef.h
@@ -44,7 +44,7 @@ class ScoreDefElement : public Object, public ScoreDefInterface {
     ScoreDefElement(std::string classid);
     virtual ~ScoreDefElement();
     virtual void Reset();
-    virtual ClassId Is() { return SCOREDEF_ELEMENT; };
+    virtual ClassId Is() const { return SCOREDEF_ELEMENT; };
     ///@}
 
     virtual ScoreDefInterface *GetScoreDefInterface() { return dynamic_cast<ScoreDefInterface *>(this); }
@@ -54,10 +54,10 @@ class ScoreDefElement : public Object, public ScoreDefInterface {
      * Look both at the attributes (e.g., @key.sig) and at child elements (not implemented)
      */
     ///@{
-    bool HasClefInfo();
-    bool HasKeySigInfo();
-    bool HasMensurInfo();
-    bool HasMeterSigInfo();
+    bool HasClefInfo() const;
+    bool HasKeySigInfo() const;
+    bool HasMensurInfo() const;
+    bool HasMeterSigInfo() const;
     ///@}
 
     /**
@@ -69,10 +69,10 @@ class ScoreDefElement : public Object, public ScoreDefInterface {
      * constructor of each corresponding class (Clef, KeySig, etc.)
      */
     ///@{
-    Clef *GetClefCopy();
-    KeySig *GetKeySigCopy();
-    Mensur *GetMensurCopy();
-    MeterSig *GetMeterSigCopy();
+    Clef *GetClefCopy() const;
+    KeySig *GetKeySigCopy() const;
+    Mensur *GetMensurCopy() const;
+    MeterSig *GetMeterSigCopy() const;
     ///@}
 
 private:
@@ -80,10 +80,10 @@ class ScoreDefElement : public Object, public ScoreDefInterface {
      * @name Methods for checking if clef info is available at the attribute level.
      */
     ///@{
-    bool HasClefAttrInfo();
-    bool HasKeySigAttrInfo();
-    bool HasMensurAttrInfo();
-    bool HasMeterSigAttrInfo();
+    bool HasClefAttrInfo() const;
+    bool HasKeySigAttrInfo() const;
+    bool HasMensurAttrInfo() const;
+    bool HasMeterSigAttrInfo() const;
     ///@}
 
     /**
@@ -91,10 +91,10 @@ class ScoreDefElement : public Object, public ScoreDefInterface {
      * To be implemented.
      */
     ///@{
-    bool HasClefElementInfo();
-    bool HasKeySigElementInfo();
-    bool HasMensurElementInfo();
-    bool HasMeterSigElementInfo();
+    bool HasClefElementInfo() const;
+    bool HasKeySigElementInfo() const;
+    bool HasMensurElementInfo() const;
+    bool HasMeterSigElementInfo() const;
     ///@}
 };
 
@@ -116,8 +116,8 @@ class ScoreDef : public ScoreDefElement, public ObjectListInterface {
     ScoreDef();
     virtual ~ScoreDef();
     virtual void Reset();
-    virtual std::string GetClassName() { return "ScoreDef"; };
-    virtual ClassId Is() { return SCOREDEF; };
+    virtual std::string GetClassName() const { return "ScoreDef"; };
+    virtual ClassId Is() const { return SCOREDEF; };
     ///@}
 
     void AddStaffGrp(StaffGrp *staffGrp);
@@ -213,10 +213,10 @@ class StaffGrp : public Object,
     ///@{
     StaffGrp();
     virtual ~StaffGrp();
-    virtual Object *Clone() { return new StaffGrp(*this); };
+    virtual Object *Clone() const { return new StaffGrp(*this); };
     virtual void Reset();
-    virtual std::string GetClassName() { return "StaffGrp"; };
-    virtual ClassId Is() { return STAFFGRP; };
+    virtual std::string GetClassName() const { return "StaffGrp"; };
+    virtual ClassId Is() const { return STAFFGRP; };
     ///@}
 
     /**
@@ -268,10 +268,10 @@ class StaffDef : public ScoreDefElement,
     ///@{
     StaffDef();
     virtual ~StaffDef();
-    virtual Object *Clone() { return new StaffDef(*this); };
+    virtual Object *Clone() const { return new StaffDef(*this); };
     virtual void Reset();
-    virtual std::string GetClassName() { return "StaffDef"; };
-    virtual ClassId Is() { return STAFFDEF; };
+    virtual std::string GetClassName() const { return "StaffDef"; };
+    virtual ClassId Is() const { return STAFFDEF; };
     ///@}
 
     //----------//
diff --git a/include/vrv/slur.h b/include/vrv/slur.h
index 12f26661295..d3161e03889 100644
--- a/include/vrv/slur.h
+++ b/include/vrv/slur.h
@@ -27,8 +27,8 @@ class Slur : public FloatingElement, public TimeSpanningInterface, public AttCur
     Slur();
     virtual ~Slur();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Slur"; };
-    virtual ClassId Is() { return SLUR; };
+    virtual std::string GetClassName() const { return "Slur"; };
+    virtual ClassId Is() const { return SLUR; };
     ///@}
 
     virtual TimePointInterface *GetTimePointInterface() { return dynamic_cast<TimePointInterface *>(this); }
diff --git a/include/vrv/space.h b/include/vrv/space.h
index db3da8e3407..62806a27710 100644
--- a/include/vrv/space.h
+++ b/include/vrv/space.h
@@ -30,9 +30,8 @@ class Space : public LayerElement, public DurationInterface {
     Space();
     virtual ~Space();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Space"; };
-    ;
-    virtual ClassId Is() { return SPACE; };
+    virtual std::string GetClassName() const { return "Space"; };
+    virtual ClassId Is() const { return SPACE; };
     ///@}
 
     virtual DurationInterface *GetDurationInterface() { return dynamic_cast<DurationInterface *>(this); }
diff --git a/include/vrv/staff.h b/include/vrv/staff.h
index 0b451b0276b..b2648925c12 100644
--- a/include/vrv/staff.h
+++ b/include/vrv/staff.h
@@ -40,8 +40,8 @@ class Staff : public Object, public AttCommon {
     Staff(int n = -1);
     virtual ~Staff();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Staff"; };
-    virtual ClassId Is() { return STAFF; };
+    virtual std::string GetClassName() const { return "Staff"; };
+    virtual ClassId Is() const { return STAFF; };
     ///@}
 
     /**
@@ -69,9 +69,9 @@ class Staff : public Object, public AttCommon {
      */
     virtual void ResetVerticalAlignment();
 
-    StaffAlignment *GetAlignment() { return m_staffAlignment; };
+    StaffAlignment *GetAlignment() const { return m_staffAlignment; };
 
-    int GetYRel();
+    int GetYRel() const;
 
     //----------//
     // Functors //
@@ -136,7 +136,7 @@ class Staff : public Object, public AttCommon {
      */
     int m_drawingStaffSize;
 
-    std::vector< Object *> m_timeSpanningElements;
+    std::vector<Object *> m_timeSpanningElements;
 
     /**
  * The Y absolute position of the staff for facsimile (transcription) encodings.
diff --git a/include/vrv/syl.h b/include/vrv/syl.h
index a32c326853c..cf46e300fa2 100644
--- a/include/vrv/syl.h
+++ b/include/vrv/syl.h
@@ -41,8 +41,8 @@ class Syl : public LayerElement,
     Syl();
     virtual ~Syl();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Syl"; };
-    virtual ClassId Is() { return SYL; };
+    virtual std::string GetClassName() const { return "Syl"; };
+    virtual ClassId Is() const { return SYL; };
     ///@}
 
     virtual TimePointInterface *GetTimePointInterface() { return dynamic_cast<TimePointInterface *>(this); }
diff --git a/include/vrv/system.h b/include/vrv/system.h
index 175fe7ad902..b30e2830792 100644
--- a/include/vrv/system.h
+++ b/include/vrv/system.h
@@ -37,8 +37,8 @@ class System : public Object, public DrawingListInterface {
     System();
     virtual ~System();
     virtual void Reset();
-    virtual std::string GetClassName() { return "System"; };
-    virtual ClassId Is() { return SYSTEM; };
+    virtual std::string GetClassName() const { return "System"; };
+    virtual ClassId Is() const { return SYSTEM; };
     ///@}
 
     /**
@@ -62,12 +62,12 @@ class System : public Object, public DrawingListInterface {
     /**
      * Return the height of the system
      */
-    int GetHeight();
+    int GetHeight() const;
 
     /**
      * Return the default horizontal spacing of system.
      */
-    int GetVerticalSpacing();
+    int GetVerticalSpacing() const;
 
     /**
      * Return the index position of the system in its page parent
diff --git a/include/vrv/tempo.h b/include/vrv/tempo.h
index 73a5e497fb5..066a0ff4117 100644
--- a/include/vrv/tempo.h
+++ b/include/vrv/tempo.h
@@ -33,8 +33,8 @@ class Tempo : public FloatingElement, public TextDirInterface, public TimePointI
     Tempo();
     virtual ~Tempo();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Tempo"; };
-    virtual ClassId Is() { return TEMPO; };
+    virtual std::string GetClassName() const { return "Tempo"; };
+    virtual ClassId Is() const { return TEMPO; };
     ///@}
 
     virtual TextDirInterface *GetTextDirInterface() { return dynamic_cast<TextDirInterface *>(this); }
diff --git a/include/vrv/text.h b/include/vrv/text.h
index 4e70880635d..469fc0b9bfb 100644
--- a/include/vrv/text.h
+++ b/include/vrv/text.h
@@ -30,9 +30,8 @@ class Rend : public TextElement, public AttCommon, public AttTypography {
     Rend();
     virtual ~Rend();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Rend"; };
-    ;
-    virtual ClassId Is() { return REND; };
+    virtual std::string GetClassName() const { return "Rend"; };
+    virtual ClassId Is() const { return REND; };
     ///@}
 
     /**
@@ -65,9 +64,8 @@ class Text : public TextElement {
     Text();
     virtual ~Text();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Text"; };
-    ;
-    virtual ClassId Is() { return TEXT; };
+    virtual std::string GetClassName() const { return "Text"; };
+    virtual ClassId Is() const { return TEXT; };
     ///@}
 
     /**
diff --git a/include/vrv/textelement.h b/include/vrv/textelement.h
index 4458b78afde..b6cc9df1651 100644
--- a/include/vrv/textelement.h
+++ b/include/vrv/textelement.h
@@ -27,8 +27,8 @@ class TextElement : public Object {
     TextElement(std::string classid);
     virtual ~TextElement();
     virtual void Reset();
-    virtual std::string GetClassName() { return "TextElement"; };
-    virtual ClassId Is() { return TEXT_ELEMENT; };
+    virtual std::string GetClassName() const { return "TextElement"; };
+    virtual ClassId Is() const { return TEXT_ELEMENT; };
     ///@}
 
 private:
diff --git a/include/vrv/tie.h b/include/vrv/tie.h
index 2607f395e64..e1ff0b199b8 100644
--- a/include/vrv/tie.h
+++ b/include/vrv/tie.h
@@ -27,8 +27,8 @@ class Tie : public FloatingElement, public TimeSpanningInterface, public AttCurv
     Tie();
     virtual ~Tie();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Tie"; };
-    virtual ClassId Is() { return TIE; };
+    virtual std::string GetClassName() const { return "Tie"; };
+    virtual ClassId Is() const { return TIE; };
     ///@}
 
     virtual TimePointInterface *GetTimePointInterface() { return dynamic_cast<TimePointInterface *>(this); }
diff --git a/include/vrv/timestamp.h b/include/vrv/timestamp.h
index 3ac36478f3e..8834fe766b0 100644
--- a/include/vrv/timestamp.h
+++ b/include/vrv/timestamp.h
@@ -26,8 +26,8 @@ class TimestampAttr : public LayerElement {
     TimestampAttr();
     virtual ~TimestampAttr();
     virtual void Reset();
-    virtual std::string GetClassName() { return "TimestampAttr"; };
-    virtual ClassId Is() { return TIMESTAMP_ATTR; };
+    virtual std::string GetClassName() const { return "TimestampAttr"; };
+    virtual ClassId Is() const { return TIMESTAMP_ATTR; };
     ///@}
 
     /**
@@ -35,14 +35,14 @@ class TimestampAttr : public LayerElement {
      * The actual duration position is the timestamp position - 1.0.
      */
     ///@{
-    double GetActualDurPos() { return m_actualDurPos; };
+    double GetActualDurPos() const { return m_actualDurPos; };
     void SetDrawingPos(double pos) { m_actualDurPos = pos; };
     ///@}
 
     /**
      * Returns the duration (in double) for the Timestamp.
      */
-    virtual double GetTimestampAttrAlignmentDuration(int meterUnit);
+    double GetTimestampAttrAlignmentDuration(int meterUnit) const;
 
     //----------//
     // Functors //
diff --git a/include/vrv/tuplet.h b/include/vrv/tuplet.h
index 934ead59bc9..6d393c00d0e 100644
--- a/include/vrv/tuplet.h
+++ b/include/vrv/tuplet.h
@@ -34,11 +34,11 @@ class Tuplet : public LayerElement,
     Tuplet();
     virtual ~Tuplet();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Tuplet"; };
-    virtual ClassId Is() { return TUPLET; };
+    virtual std::string GetClassName() const { return "Tuplet"; };
+    virtual ClassId Is() const { return TUPLET; };
     ///@}
 
-    int GetNoteCount() { return this->GetChildCount(NOTE); };
+    int GetNoteCount() const { return this->GetChildCount(NOTE); };
 
     /**
      * Add an element (a note or a rest) to a tuplet.
diff --git a/include/vrv/verse.h b/include/vrv/verse.h
index 190316154f8..344cdce2cd2 100644
--- a/include/vrv/verse.h
+++ b/include/vrv/verse.h
@@ -29,8 +29,8 @@ class Verse : public LayerElement, public AttCommon {
     Verse();
     virtual ~Verse();
     virtual void Reset();
-    virtual std::string GetClassName() { return "Verse"; };
-    virtual ClassId Is() { return VERSE; };
+    virtual std::string GetClassName() const { return "Verse"; };
+    virtual ClassId Is() const { return VERSE; };
     ///@}
 
     /**
diff --git a/libmei/attconverter.cpp b/libmei/attconverter.cpp
index 656ba9e5ff2..9d7d7a98a6f 100644
--- a/libmei/attconverter.cpp
+++ b/libmei/attconverter.cpp
@@ -28,7 +28,7 @@ namespace vrv {
 // AttConverter
 //----------------------------------------------------------------------------
 
-std::string AttConverter::AccidentalExplicitToStr(data_ACCIDENTAL_EXPLICIT data)
+std::string AttConverter::AccidentalExplicitToStr(data_ACCIDENTAL_EXPLICIT data) const
 {
     std::string value;
     switch (data) {
@@ -61,7 +61,7 @@ std::string AttConverter::AccidentalExplicitToStr(data_ACCIDENTAL_EXPLICIT data)
     return value;
 }
 
-data_ACCIDENTAL_EXPLICIT AttConverter::StrToAccidentalExplicit(std::string value)
+data_ACCIDENTAL_EXPLICIT AttConverter::StrToAccidentalExplicit(std::string value) const
 {
     if (value == "s") return ACCIDENTAL_EXPLICIT_s;
     if (value == "f") return ACCIDENTAL_EXPLICIT_f;
@@ -88,7 +88,7 @@ data_ACCIDENTAL_EXPLICIT AttConverter::StrToAccidentalExplicit(std::string value
     return ACCIDENTAL_EXPLICIT_NONE;
 }
 
-std::string AttConverter::AccidentalImplicitToStr(data_ACCIDENTAL_IMPLICIT data)
+std::string AttConverter::AccidentalImplicitToStr(data_ACCIDENTAL_IMPLICIT data) const
 {
     std::string value;
     switch (data) {
@@ -109,7 +109,7 @@ std::string AttConverter::AccidentalImplicitToStr(data_ACCIDENTAL_IMPLICIT data)
     return value;
 }
 
-data_ACCIDENTAL_IMPLICIT AttConverter::StrToAccidentalImplicit(std::string value)
+data_ACCIDENTAL_IMPLICIT AttConverter::StrToAccidentalImplicit(std::string value) const
 {
     if (value == "s") return ACCIDENTAL_IMPLICIT_s;
     if (value == "f") return ACCIDENTAL_IMPLICIT_f;
@@ -124,7 +124,7 @@ data_ACCIDENTAL_IMPLICIT AttConverter::StrToAccidentalImplicit(std::string value
     return ACCIDENTAL_IMPLICIT_NONE;
 }
 
-std::string AttConverter::ArticulationToStr(data_ARTICULATION data)
+std::string AttConverter::ArticulationToStr(data_ARTICULATION data) const
 {
     std::string value;
     switch (data) {
@@ -171,7 +171,7 @@ std::string AttConverter::ArticulationToStr(data_ARTICULATION data)
     return value;
 }
 
-data_ARTICULATION AttConverter::StrToArticulation(std::string value)
+data_ARTICULATION AttConverter::StrToArticulation(std::string value) const
 {
     if (value == "acc") return ARTICULATION_acc;
     if (value == "stacc") return ARTICULATION_stacc;
@@ -212,7 +212,7 @@ data_ARTICULATION AttConverter::StrToArticulation(std::string value)
     return ARTICULATION_NONE;
 }
 
-std::string AttConverter::BarplaceToStr(data_BARPLACE data)
+std::string AttConverter::BarplaceToStr(data_BARPLACE data) const
 {
     std::string value;
     switch (data) {
@@ -227,7 +227,7 @@ std::string AttConverter::BarplaceToStr(data_BARPLACE data)
     return value;
 }
 
-data_BARPLACE AttConverter::StrToBarplace(std::string value)
+data_BARPLACE AttConverter::StrToBarplace(std::string value) const
 {
     if (value == "mensur") return BARPLACE_mensur;
     if (value == "staff") return BARPLACE_staff;
@@ -236,7 +236,7 @@ data_BARPLACE AttConverter::StrToBarplace(std::string value)
     return BARPLACE_NONE;
 }
 
-std::string AttConverter::BarrenditionToStr(data_BARRENDITION data)
+std::string AttConverter::BarrenditionToStr(data_BARRENDITION data) const
 {
     std::string value;
     switch (data) {
@@ -259,7 +259,7 @@ std::string AttConverter::BarrenditionToStr(data_BARRENDITION data)
     return value;
 }
 
-data_BARRENDITION AttConverter::StrToBarrendition(std::string value)
+data_BARRENDITION AttConverter::StrToBarrendition(std::string value) const
 {
     if (value == "dashed") return BARRENDITION_dashed;
     if (value == "dotted") return BARRENDITION_dotted;
@@ -276,7 +276,7 @@ data_BARRENDITION AttConverter::StrToBarrendition(std::string value)
     return BARRENDITION_NONE;
 }
 
-std::string AttConverter::BetypeToStr(data_BETYPE data)
+std::string AttConverter::BetypeToStr(data_BETYPE data) const
 {
     std::string value;
     switch (data) {
@@ -301,7 +301,7 @@ std::string AttConverter::BetypeToStr(data_BETYPE data)
     return value;
 }
 
-data_BETYPE AttConverter::StrToBetype(std::string value)
+data_BETYPE AttConverter::StrToBetype(std::string value) const
 {
     if (value == "byte") return BETYPE_byte;
     if (value == "smil") return BETYPE_smil;
@@ -320,7 +320,7 @@ data_BETYPE AttConverter::StrToBetype(std::string value)
     return BETYPE_NONE;
 }
 
-std::string AttConverter::BooleanToStr(data_BOOLEAN data)
+std::string AttConverter::BooleanToStr(data_BOOLEAN data) const
 {
     std::string value;
     switch (data) {
@@ -334,7 +334,7 @@ std::string AttConverter::BooleanToStr(data_BOOLEAN data)
     return value;
 }
 
-data_BOOLEAN AttConverter::StrToBoolean(std::string value)
+data_BOOLEAN AttConverter::StrToBoolean(std::string value) const
 {
     if (value == "true") return BOOLEAN_true;
     if (value == "false") return BOOLEAN_false;
@@ -342,7 +342,7 @@ data_BOOLEAN AttConverter::StrToBoolean(std::string value)
     return BOOLEAN_NONE;
 }
 
-std::string AttConverter::CertaintyToStr(data_CERTAINTY data)
+std::string AttConverter::CertaintyToStr(data_CERTAINTY data) const
 {
     std::string value;
     switch (data) {
@@ -358,7 +358,7 @@ std::string AttConverter::CertaintyToStr(data_CERTAINTY data)
     return value;
 }
 
-data_CERTAINTY AttConverter::StrToCertainty(std::string value)
+data_CERTAINTY AttConverter::StrToCertainty(std::string value) const
 {
     if (value == "high") return CERTAINTY_high;
     if (value == "medium") return CERTAINTY_medium;
@@ -368,7 +368,7 @@ data_CERTAINTY AttConverter::StrToCertainty(std::string value)
     return CERTAINTY_NONE;
 }
 
-std::string AttConverter::ClefshapeToStr(data_CLEFSHAPE data)
+std::string AttConverter::ClefshapeToStr(data_CLEFSHAPE data) const
 {
     std::string value;
     switch (data) {
@@ -386,7 +386,7 @@ std::string AttConverter::ClefshapeToStr(data_CLEFSHAPE data)
     return value;
 }
 
-data_CLEFSHAPE AttConverter::StrToClefshape(std::string value)
+data_CLEFSHAPE AttConverter::StrToClefshape(std::string value) const
 {
     if (value == "G") return CLEFSHAPE_G;
     if (value == "GG") return CLEFSHAPE_GG;
@@ -398,7 +398,7 @@ data_CLEFSHAPE AttConverter::StrToClefshape(std::string value)
     return CLEFSHAPE_NONE;
 }
 
-std::string AttConverter::ClusterToStr(data_CLUSTER data)
+std::string AttConverter::ClusterToStr(data_CLUSTER data) const
 {
     std::string value;
     switch (data) {
@@ -413,7 +413,7 @@ std::string AttConverter::ClusterToStr(data_CLUSTER data)
     return value;
 }
 
-data_CLUSTER AttConverter::StrToCluster(std::string value)
+data_CLUSTER AttConverter::StrToCluster(std::string value) const
 {
     if (value == "white") return CLUSTER_white;
     if (value == "black") return CLUSTER_black;
@@ -422,7 +422,7 @@ data_CLUSTER AttConverter::StrToCluster(std::string value)
     return CLUSTER_NONE;
 }
 
-std::string AttConverter::ColornamesToStr(data_COLORNAMES data)
+std::string AttConverter::ColornamesToStr(data_COLORNAMES data) const
 {
     std::string value;
     switch (data) {
@@ -450,7 +450,7 @@ std::string AttConverter::ColornamesToStr(data_COLORNAMES data)
     return value;
 }
 
-data_COLORNAMES AttConverter::StrToColornames(std::string value)
+data_COLORNAMES AttConverter::StrToColornames(std::string value) const
 {
     if (value == "aqua") return COLORNAMES_aqua;
     if (value == "black") return COLORNAMES_black;
@@ -472,7 +472,7 @@ data_COLORNAMES AttConverter::StrToColornames(std::string value)
     return COLORNAMES_NONE;
 }
 
-std::string AttConverter::CurverenditionToStr(data_CURVERENDITION data)
+std::string AttConverter::CurverenditionToStr(data_CURVERENDITION data) const
 {
     std::string value;
     switch (data) {
@@ -489,7 +489,7 @@ std::string AttConverter::CurverenditionToStr(data_CURVERENDITION data)
     return value;
 }
 
-data_CURVERENDITION AttConverter::StrToCurverendition(std::string value)
+data_CURVERENDITION AttConverter::StrToCurverendition(std::string value) const
 {
     if (value == "narrow") return CURVERENDITION_narrow;
     if (value == "medium") return CURVERENDITION_medium;
@@ -500,7 +500,7 @@ data_CURVERENDITION AttConverter::StrToCurverendition(std::string value)
     return CURVERENDITION_NONE;
 }
 
-std::string AttConverter::EnclosureToStr(data_ENCLOSURE data)
+std::string AttConverter::EnclosureToStr(data_ENCLOSURE data) const
 {
     std::string value;
     switch (data) {
@@ -514,7 +514,7 @@ std::string AttConverter::EnclosureToStr(data_ENCLOSURE data)
     return value;
 }
 
-data_ENCLOSURE AttConverter::StrToEnclosure(std::string value)
+data_ENCLOSURE AttConverter::StrToEnclosure(std::string value) const
 {
     if (value == "paren") return ENCLOSURE_paren;
     if (value == "brack") return ENCLOSURE_brack;
@@ -522,7 +522,7 @@ data_ENCLOSURE AttConverter::StrToEnclosure(std::string value)
     return ENCLOSURE_NONE;
 }
 
-std::string AttConverter::FontstyleToStr(data_FONTSTYLE data)
+std::string AttConverter::FontstyleToStr(data_FONTSTYLE data) const
 {
     std::string value;
     switch (data) {
@@ -537,7 +537,7 @@ std::string AttConverter::FontstyleToStr(data_FONTSTYLE data)
     return value;
 }
 
-data_FONTSTYLE AttConverter::StrToFontstyle(std::string value)
+data_FONTSTYLE AttConverter::StrToFontstyle(std::string value) const
 {
     if (value == "italic") return FONTSTYLE_italic;
     if (value == "normal") return FONTSTYLE_normal;
@@ -546,7 +546,7 @@ data_FONTSTYLE AttConverter::StrToFontstyle(std::string value)
     return FONTSTYLE_NONE;
 }
 
-std::string AttConverter::FontweightToStr(data_FONTWEIGHT data)
+std::string AttConverter::FontweightToStr(data_FONTWEIGHT data) const
 {
     std::string value;
     switch (data) {
@@ -560,7 +560,7 @@ std::string AttConverter::FontweightToStr(data_FONTWEIGHT data)
     return value;
 }
 
-data_FONTWEIGHT AttConverter::StrToFontweight(std::string value)
+data_FONTWEIGHT AttConverter::StrToFontweight(std::string value) const
 {
     if (value == "bold") return FONTWEIGHT_bold;
     if (value == "normal") return FONTWEIGHT_normal;
@@ -568,7 +568,7 @@ data_FONTWEIGHT AttConverter::StrToFontweight(std::string value)
     return FONTWEIGHT_NONE;
 }
 
-std::string AttConverter::GlissandoToStr(data_GLISSANDO data)
+std::string AttConverter::GlissandoToStr(data_GLISSANDO data) const
 {
     std::string value;
     switch (data) {
@@ -583,7 +583,7 @@ std::string AttConverter::GlissandoToStr(data_GLISSANDO data)
     return value;
 }
 
-data_GLISSANDO AttConverter::StrToGlissando(std::string value)
+data_GLISSANDO AttConverter::StrToGlissando(std::string value) const
 {
     if (value == "i") return GLISSANDO_i;
     if (value == "m") return GLISSANDO_m;
@@ -592,7 +592,7 @@ data_GLISSANDO AttConverter::StrToGlissando(std::string value)
     return GLISSANDO_NONE;
 }
 
-std::string AttConverter::GraceToStr(data_GRACE data)
+std::string AttConverter::GraceToStr(data_GRACE data) const
 {
     std::string value;
     switch (data) {
@@ -607,7 +607,7 @@ std::string AttConverter::GraceToStr(data_GRACE data)
     return value;
 }
 
-data_GRACE AttConverter::StrToGrace(std::string value)
+data_GRACE AttConverter::StrToGrace(std::string value) const
 {
     if (value == "acc") return GRACE_acc;
     if (value == "unacc") return GRACE_unacc;
@@ -616,7 +616,7 @@ data_GRACE AttConverter::StrToGrace(std::string value)
     return GRACE_NONE;
 }
 
-std::string AttConverter::HorizontalalignmentToStr(data_HORIZONTALALIGNMENT data)
+std::string AttConverter::HorizontalalignmentToStr(data_HORIZONTALALIGNMENT data) const
 {
     std::string value;
     switch (data) {
@@ -632,7 +632,7 @@ std::string AttConverter::HorizontalalignmentToStr(data_HORIZONTALALIGNMENT data
     return value;
 }
 
-data_HORIZONTALALIGNMENT AttConverter::StrToHorizontalalignment(std::string value)
+data_HORIZONTALALIGNMENT AttConverter::StrToHorizontalalignment(std::string value) const
 {
     if (value == "left") return HORIZONTALALIGNMENT_left;
     if (value == "right") return HORIZONTALALIGNMENT_right;
@@ -642,7 +642,7 @@ data_HORIZONTALALIGNMENT AttConverter::StrToHorizontalalignment(std::string valu
     return HORIZONTALALIGNMENT_NONE;
 }
 
-std::string AttConverter::IneumeformToStr(data_INEUMEFORM data)
+std::string AttConverter::IneumeformToStr(data_INEUMEFORM data) const
 {
     std::string value;
     switch (data) {
@@ -659,7 +659,7 @@ std::string AttConverter::IneumeformToStr(data_INEUMEFORM data)
     return value;
 }
 
-data_INEUMEFORM AttConverter::StrToIneumeform(std::string value)
+data_INEUMEFORM AttConverter::StrToIneumeform(std::string value) const
 {
     if (value == "liquescent1") return INEUMEFORM_liquescent1;
     if (value == "liquescent2") return INEUMEFORM_liquescent2;
@@ -670,7 +670,7 @@ data_INEUMEFORM AttConverter::StrToIneumeform(std::string value)
     return INEUMEFORM_NONE;
 }
 
-std::string AttConverter::IneumenameToStr(data_INEUMENAME data)
+std::string AttConverter::IneumenameToStr(data_INEUMENAME data) const
 {
     std::string value;
     switch (data) {
@@ -689,7 +689,7 @@ std::string AttConverter::IneumenameToStr(data_INEUMENAME data)
     return value;
 }
 
-data_INEUMENAME AttConverter::StrToIneumename(std::string value)
+data_INEUMENAME AttConverter::StrToIneumename(std::string value) const
 {
     if (value == "pessubpunctis") return INEUMENAME_pessubpunctis;
     if (value == "climacus") return INEUMENAME_climacus;
@@ -702,7 +702,7 @@ data_INEUMENAME AttConverter::StrToIneumename(std::string value)
     return INEUMENAME_NONE;
 }
 
-std::string AttConverter::LayerschemeToStr(data_LAYERSCHEME data)
+std::string AttConverter::LayerschemeToStr(data_LAYERSCHEME data) const
 {
     std::string value;
     switch (data) {
@@ -719,7 +719,7 @@ std::string AttConverter::LayerschemeToStr(data_LAYERSCHEME data)
     return value;
 }
 
-data_LAYERSCHEME AttConverter::StrToLayerscheme(std::string value)
+data_LAYERSCHEME AttConverter::StrToLayerscheme(std::string value) const
 {
     if (value == "1") return LAYERSCHEME_1;
     if (value == "2o") return LAYERSCHEME_2o;
@@ -730,7 +730,7 @@ data_LAYERSCHEME AttConverter::StrToLayerscheme(std::string value)
     return LAYERSCHEME_NONE;
 }
 
-std::string AttConverter::LigatureformToStr(data_LIGATUREFORM data)
+std::string AttConverter::LigatureformToStr(data_LIGATUREFORM data) const
 {
     std::string value;
     switch (data) {
@@ -744,7 +744,7 @@ std::string AttConverter::LigatureformToStr(data_LIGATUREFORM data)
     return value;
 }
 
-data_LIGATUREFORM AttConverter::StrToLigatureform(std::string value)
+data_LIGATUREFORM AttConverter::StrToLigatureform(std::string value) const
 {
     if (value == "recta") return LIGATUREFORM_recta;
     if (value == "obliqua") return LIGATUREFORM_obliqua;
@@ -752,7 +752,7 @@ data_LIGATUREFORM AttConverter::StrToLigatureform(std::string value)
     return LIGATUREFORM_NONE;
 }
 
-std::string AttConverter::LineformToStr(data_LINEFORM data)
+std::string AttConverter::LineformToStr(data_LINEFORM data) const
 {
     std::string value;
     switch (data) {
@@ -768,7 +768,7 @@ std::string AttConverter::LineformToStr(data_LINEFORM data)
     return value;
 }
 
-data_LINEFORM AttConverter::StrToLineform(std::string value)
+data_LINEFORM AttConverter::StrToLineform(std::string value) const
 {
     if (value == "dashed") return LINEFORM_dashed;
     if (value == "dotted") return LINEFORM_dotted;
@@ -778,7 +778,7 @@ data_LINEFORM AttConverter::StrToLineform(std::string value)
     return LINEFORM_NONE;
 }
 
-std::string AttConverter::LinestartendsymbolToStr(data_LINESTARTENDSYMBOL data)
+std::string AttConverter::LinestartendsymbolToStr(data_LINESTARTENDSYMBOL data) const
 {
     std::string value;
     switch (data) {
@@ -800,7 +800,7 @@ std::string AttConverter::LinestartendsymbolToStr(data_LINESTARTENDSYMBOL data)
     return value;
 }
 
-data_LINESTARTENDSYMBOL AttConverter::StrToLinestartendsymbol(std::string value)
+data_LINESTARTENDSYMBOL AttConverter::StrToLinestartendsymbol(std::string value) const
 {
     if (value == "angledown") return LINESTARTENDSYMBOL_angledown;
     if (value == "angleup") return LINESTARTENDSYMBOL_angleup;
@@ -816,7 +816,7 @@ data_LINESTARTENDSYMBOL AttConverter::StrToLinestartendsymbol(std::string value)
     return LINESTARTENDSYMBOL_NONE;
 }
 
-std::string AttConverter::LinewidthtermToStr(data_LINEWIDTHTERM data)
+std::string AttConverter::LinewidthtermToStr(data_LINEWIDTHTERM data) const
 {
     std::string value;
     switch (data) {
@@ -831,7 +831,7 @@ std::string AttConverter::LinewidthtermToStr(data_LINEWIDTHTERM data)
     return value;
 }
 
-data_LINEWIDTHTERM AttConverter::StrToLinewidthterm(std::string value)
+data_LINEWIDTHTERM AttConverter::StrToLinewidthterm(std::string value) const
 {
     if (value == "narrow") return LINEWIDTHTERM_narrow;
     if (value == "medium") return LINEWIDTHTERM_medium;
@@ -840,7 +840,7 @@ data_LINEWIDTHTERM AttConverter::StrToLinewidthterm(std::string value)
     return LINEWIDTHTERM_NONE;
 }
 
-std::string AttConverter::MelodicfunctionToStr(data_MELODICFUNCTION data)
+std::string AttConverter::MelodicfunctionToStr(data_MELODICFUNCTION data) const
 {
     std::string value;
     switch (data) {
@@ -880,7 +880,7 @@ std::string AttConverter::MelodicfunctionToStr(data_MELODICFUNCTION data)
     return value;
 }
 
-data_MELODICFUNCTION AttConverter::StrToMelodicfunction(std::string value)
+data_MELODICFUNCTION AttConverter::StrToMelodicfunction(std::string value) const
 {
     if (value == "aln") return MELODICFUNCTION_aln;
     if (value == "ant") return MELODICFUNCTION_ant;
@@ -914,7 +914,7 @@ data_MELODICFUNCTION AttConverter::StrToMelodicfunction(std::string value)
     return MELODICFUNCTION_NONE;
 }
 
-std::string AttConverter::MensurationsignToStr(data_MENSURATIONSIGN data)
+std::string AttConverter::MensurationsignToStr(data_MENSURATIONSIGN data) const
 {
     std::string value;
     switch (data) {
@@ -928,7 +928,7 @@ std::string AttConverter::MensurationsignToStr(data_MENSURATIONSIGN data)
     return value;
 }
 
-data_MENSURATIONSIGN AttConverter::StrToMensurationsign(std::string value)
+data_MENSURATIONSIGN AttConverter::StrToMensurationsign(std::string value) const
 {
     if (value == "C") return MENSURATIONSIGN_C;
     if (value == "O") return MENSURATIONSIGN_O;
@@ -936,7 +936,7 @@ data_MENSURATIONSIGN AttConverter::StrToMensurationsign(std::string value)
     return MENSURATIONSIGN_NONE;
 }
 
-std::string AttConverter::MetersignToStr(data_METERSIGN data)
+std::string AttConverter::MetersignToStr(data_METERSIGN data) const
 {
     std::string value;
     switch (data) {
@@ -950,7 +950,7 @@ std::string AttConverter::MetersignToStr(data_METERSIGN data)
     return value;
 }
 
-data_METERSIGN AttConverter::StrToMetersign(std::string value)
+data_METERSIGN AttConverter::StrToMetersign(std::string value) const
 {
     if (value == "common") return METERSIGN_common;
     if (value == "cut") return METERSIGN_cut;
@@ -958,7 +958,7 @@ data_METERSIGN AttConverter::StrToMetersign(std::string value)
     return METERSIGN_NONE;
 }
 
-std::string AttConverter::MidinamesToStr(data_MIDINAMES data)
+std::string AttConverter::MidinamesToStr(data_MIDINAMES data) const
 {
     std::string value;
     switch (data) {
@@ -1145,7 +1145,7 @@ std::string AttConverter::MidinamesToStr(data_MIDINAMES data)
     return value;
 }
 
-data_MIDINAMES AttConverter::StrToMidinames(std::string value)
+data_MIDINAMES AttConverter::StrToMidinames(std::string value) const
 {
     if (value == "Acoustic_Grand_Piano") return MIDINAMES_Acoustic_Grand_Piano;
     if (value == "Bright_Acoustic_Piano") return MIDINAMES_Bright_Acoustic_Piano;
@@ -1326,7 +1326,7 @@ data_MIDINAMES AttConverter::StrToMidinames(std::string value)
     return MIDINAMES_NONE;
 }
 
-std::string AttConverter::ModeToStr(data_MODE data)
+std::string AttConverter::ModeToStr(data_MODE data) const
 {
     std::string value;
     switch (data) {
@@ -1346,7 +1346,7 @@ std::string AttConverter::ModeToStr(data_MODE data)
     return value;
 }
 
-data_MODE AttConverter::StrToMode(std::string value)
+data_MODE AttConverter::StrToMode(std::string value) const
 {
     if (value == "major") return MODE_major;
     if (value == "minor") return MODE_minor;
@@ -1360,7 +1360,7 @@ data_MODE AttConverter::StrToMode(std::string value)
     return MODE_NONE;
 }
 
-std::string AttConverter::NotationtypeToStr(data_NOTATIONTYPE data)
+std::string AttConverter::NotationtypeToStr(data_NOTATIONTYPE data) const
 {
     std::string value;
     switch (data) {
@@ -1378,7 +1378,7 @@ std::string AttConverter::NotationtypeToStr(data_NOTATIONTYPE data)
     return value;
 }
 
-data_NOTATIONTYPE AttConverter::StrToNotationtype(std::string value)
+data_NOTATIONTYPE AttConverter::StrToNotationtype(std::string value) const
 {
     if (value == "cmn") return NOTATIONTYPE_cmn;
     if (value == "mensural") return NOTATIONTYPE_mensural;
@@ -1390,7 +1390,7 @@ data_NOTATIONTYPE AttConverter::StrToNotationtype(std::string value)
     return NOTATIONTYPE_NONE;
 }
 
-std::string AttConverter::NoteheadmodifierListToStr(data_NOTEHEADMODIFIER_list data)
+std::string AttConverter::NoteheadmodifierListToStr(data_NOTEHEADMODIFIER_list data) const
 {
     std::string value;
     switch (data) {
@@ -1412,7 +1412,7 @@ std::string AttConverter::NoteheadmodifierListToStr(data_NOTEHEADMODIFIER_list d
     return value;
 }
 
-data_NOTEHEADMODIFIER_list AttConverter::StrToNoteheadmodifierList(std::string value)
+data_NOTEHEADMODIFIER_list AttConverter::StrToNoteheadmodifierList(std::string value) const
 {
     if (value == "slash") return NOTEHEADMODIFIER_list_slash;
     if (value == "backslash") return NOTEHEADMODIFIER_list_backslash;
@@ -1428,7 +1428,7 @@ data_NOTEHEADMODIFIER_list AttConverter::StrToNoteheadmodifierList(std::string v
     return NOTEHEADMODIFIER_list_NONE;
 }
 
-std::string AttConverter::OtherstaffToStr(data_OTHERSTAFF data)
+std::string AttConverter::OtherstaffToStr(data_OTHERSTAFF data) const
 {
     std::string value;
     switch (data) {
@@ -1442,7 +1442,7 @@ std::string AttConverter::OtherstaffToStr(data_OTHERSTAFF data)
     return value;
 }
 
-data_OTHERSTAFF AttConverter::StrToOtherstaff(std::string value)
+data_OTHERSTAFF AttConverter::StrToOtherstaff(std::string value) const
 {
     if (value == "above") return OTHERSTAFF_above;
     if (value == "below") return OTHERSTAFF_below;
@@ -1450,7 +1450,7 @@ data_OTHERSTAFF AttConverter::StrToOtherstaff(std::string value)
     return OTHERSTAFF_NONE;
 }
 
-std::string AttConverter::PlaceToStr(data_PLACE data)
+std::string AttConverter::PlaceToStr(data_PLACE data) const
 {
     std::string value;
     switch (data) {
@@ -1464,7 +1464,7 @@ std::string AttConverter::PlaceToStr(data_PLACE data)
     return value;
 }
 
-data_PLACE AttConverter::StrToPlace(std::string value)
+data_PLACE AttConverter::StrToPlace(std::string value) const
 {
     if (value == "above") return PLACE_above;
     if (value == "below") return PLACE_below;
@@ -1472,7 +1472,7 @@ data_PLACE AttConverter::StrToPlace(std::string value)
     return PLACE_NONE;
 }
 
-std::string AttConverter::RotationdirectionToStr(data_ROTATIONDIRECTION data)
+std::string AttConverter::RotationdirectionToStr(data_ROTATIONDIRECTION data) const
 {
     std::string value;
     switch (data) {
@@ -1491,7 +1491,7 @@ std::string AttConverter::RotationdirectionToStr(data_ROTATIONDIRECTION data)
     return value;
 }
 
-data_ROTATIONDIRECTION AttConverter::StrToRotationdirection(std::string value)
+data_ROTATIONDIRECTION AttConverter::StrToRotationdirection(std::string value) const
 {
     if (value == "none") return ROTATIONDIRECTION_none;
     if (value == "down") return ROTATIONDIRECTION_down;
@@ -1504,7 +1504,7 @@ data_ROTATIONDIRECTION AttConverter::StrToRotationdirection(std::string value)
     return ROTATIONDIRECTION_NONE;
 }
 
-std::string AttConverter::SizeToStr(data_SIZE data)
+std::string AttConverter::SizeToStr(data_SIZE data) const
 {
     std::string value;
     switch (data) {
@@ -1518,7 +1518,7 @@ std::string AttConverter::SizeToStr(data_SIZE data)
     return value;
 }
 
-data_SIZE AttConverter::StrToSize(std::string value)
+data_SIZE AttConverter::StrToSize(std::string value) const
 {
     if (value == "normal") return SIZE_normal;
     if (value == "cue") return SIZE_cue;
@@ -1526,7 +1526,7 @@ data_SIZE AttConverter::StrToSize(std::string value)
     return SIZE_NONE;
 }
 
-std::string AttConverter::StaffrelToStr(data_STAFFREL data)
+std::string AttConverter::StaffrelToStr(data_STAFFREL data) const
 {
     std::string value;
     switch (data) {
@@ -1541,7 +1541,7 @@ std::string AttConverter::StaffrelToStr(data_STAFFREL data)
     return value;
 }
 
-data_STAFFREL AttConverter::StrToStaffrel(std::string value)
+data_STAFFREL AttConverter::StrToStaffrel(std::string value) const
 {
     if (value == "above") return STAFFREL_above;
     if (value == "below") return STAFFREL_below;
@@ -1550,7 +1550,7 @@ data_STAFFREL AttConverter::StrToStaffrel(std::string value)
     return STAFFREL_NONE;
 }
 
-std::string AttConverter::StemmodifierToStr(data_STEMMODIFIER data)
+std::string AttConverter::StemmodifierToStr(data_STEMMODIFIER data) const
 {
     std::string value;
     switch (data) {
@@ -1571,7 +1571,7 @@ std::string AttConverter::StemmodifierToStr(data_STEMMODIFIER data)
     return value;
 }
 
-data_STEMMODIFIER AttConverter::StrToStemmodifier(std::string value)
+data_STEMMODIFIER AttConverter::StrToStemmodifier(std::string value) const
 {
     if (value == "none") return STEMMODIFIER_none;
     if (value == "1slash") return STEMMODIFIER_1slash;
@@ -1586,7 +1586,7 @@ data_STEMMODIFIER AttConverter::StrToStemmodifier(std::string value)
     return STEMMODIFIER_NONE;
 }
 
-std::string AttConverter::StempositionToStr(data_STEMPOSITION data)
+std::string AttConverter::StempositionToStr(data_STEMPOSITION data) const
 {
     std::string value;
     switch (data) {
@@ -1601,7 +1601,7 @@ std::string AttConverter::StempositionToStr(data_STEMPOSITION data)
     return value;
 }
 
-data_STEMPOSITION AttConverter::StrToStemposition(std::string value)
+data_STEMPOSITION AttConverter::StrToStemposition(std::string value) const
 {
     if (value == "left") return STEMPOSITION_left;
     if (value == "right") return STEMPOSITION_right;
@@ -1610,7 +1610,7 @@ data_STEMPOSITION AttConverter::StrToStemposition(std::string value)
     return STEMPOSITION_NONE;
 }
 
-std::string AttConverter::TemperamentToStr(data_TEMPERAMENT data)
+std::string AttConverter::TemperamentToStr(data_TEMPERAMENT data) const
 {
     std::string value;
     switch (data) {
@@ -1626,7 +1626,7 @@ std::string AttConverter::TemperamentToStr(data_TEMPERAMENT data)
     return value;
 }
 
-data_TEMPERAMENT AttConverter::StrToTemperament(std::string value)
+data_TEMPERAMENT AttConverter::StrToTemperament(std::string value) const
 {
     if (value == "equal") return TEMPERAMENT_equal;
     if (value == "just") return TEMPERAMENT_just;
@@ -1636,7 +1636,7 @@ data_TEMPERAMENT AttConverter::StrToTemperament(std::string value)
     return TEMPERAMENT_NONE;
 }
 
-std::string AttConverter::TextrenditionlistToStr(data_TEXTRENDITIONLIST data)
+std::string AttConverter::TextrenditionlistToStr(data_TEXTRENDITIONLIST data) const
 {
     std::string value;
     switch (data) {
@@ -1681,7 +1681,7 @@ std::string AttConverter::TextrenditionlistToStr(data_TEXTRENDITIONLIST data)
     return value;
 }
 
-data_TEXTRENDITIONLIST AttConverter::StrToTextrenditionlist(std::string value)
+data_TEXTRENDITIONLIST AttConverter::StrToTextrenditionlist(std::string value) const
 {
     if (value == "xx-small") return TEXTRENDITIONLIST_xx_small;
     if (value == "x-small") return TEXTRENDITIONLIST_x_small;
@@ -1720,7 +1720,7 @@ data_TEXTRENDITIONLIST AttConverter::StrToTextrenditionlist(std::string value)
     return TEXTRENDITIONLIST_NONE;
 }
 
-std::string AttConverter::UneumeformToStr(data_UNEUMEFORM data)
+std::string AttConverter::UneumeformToStr(data_UNEUMEFORM data) const
 {
     std::string value;
     switch (data) {
@@ -1739,7 +1739,7 @@ std::string AttConverter::UneumeformToStr(data_UNEUMEFORM data)
     return value;
 }
 
-data_UNEUMEFORM AttConverter::StrToUneumeform(std::string value)
+data_UNEUMEFORM AttConverter::StrToUneumeform(std::string value) const
 {
     if (value == "liquescent1") return UNEUMEFORM_liquescent1;
     if (value == "liquescent2") return UNEUMEFORM_liquescent2;
@@ -1752,7 +1752,7 @@ data_UNEUMEFORM AttConverter::StrToUneumeform(std::string value)
     return UNEUMEFORM_NONE;
 }
 
-std::string AttConverter::UneumenameToStr(data_UNEUMENAME data)
+std::string AttConverter::UneumenameToStr(data_UNEUMENAME data) const
 {
     std::string value;
     switch (data) {
@@ -1777,7 +1777,7 @@ std::string AttConverter::UneumenameToStr(data_UNEUMENAME data)
     return value;
 }
 
-data_UNEUMENAME AttConverter::StrToUneumename(std::string value)
+data_UNEUMENAME AttConverter::StrToUneumename(std::string value) const
 {
     if (value == "punctum") return UNEUMENAME_punctum;
     if (value == "virga") return UNEUMENAME_virga;
@@ -1796,7 +1796,7 @@ data_UNEUMENAME AttConverter::StrToUneumename(std::string value)
     return UNEUMENAME_NONE;
 }
 
-std::string AttConverter::AccidLogFuncToStr(accidLog_FUNC data)
+std::string AttConverter::AccidLogFuncToStr(accidLog_FUNC data) const
 {
     std::string value;
     switch (data) {
@@ -1810,7 +1810,7 @@ std::string AttConverter::AccidLogFuncToStr(accidLog_FUNC data)
     return value;
 }
 
-accidLog_FUNC AttConverter::StrToAccidLogFunc(std::string value)
+accidLog_FUNC AttConverter::StrToAccidLogFunc(std::string value) const
 {
     if (value == "caution") return accidLog_FUNC_caution;
     if (value == "edit") return accidLog_FUNC_edit;
@@ -1818,7 +1818,7 @@ accidLog_FUNC AttConverter::StrToAccidLogFunc(std::string value)
     return accidLog_FUNC_NONE;
 }
 
-std::string AttConverter::ArpegLogOrderToStr(arpegLog_ORDER data)
+std::string AttConverter::ArpegLogOrderToStr(arpegLog_ORDER data) const
 {
     std::string value;
     switch (data) {
@@ -1833,7 +1833,7 @@ std::string AttConverter::ArpegLogOrderToStr(arpegLog_ORDER data)
     return value;
 }
 
-arpegLog_ORDER AttConverter::StrToArpegLogOrder(std::string value)
+arpegLog_ORDER AttConverter::StrToArpegLogOrder(std::string value) const
 {
     if (value == "up") return arpegLog_ORDER_up;
     if (value == "down") return arpegLog_ORDER_down;
@@ -1842,7 +1842,7 @@ arpegLog_ORDER AttConverter::StrToArpegLogOrder(std::string value)
     return arpegLog_ORDER_NONE;
 }
 
-std::string AttConverter::BTremLogFormToStr(bTremLog_FORM data)
+std::string AttConverter::BTremLogFormToStr(bTremLog_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -1856,7 +1856,7 @@ std::string AttConverter::BTremLogFormToStr(bTremLog_FORM data)
     return value;
 }
 
-bTremLog_FORM AttConverter::StrToBTremLogForm(std::string value)
+bTremLog_FORM AttConverter::StrToBTremLogForm(std::string value) const
 {
     if (value == "meas") return bTremLog_FORM_meas;
     if (value == "unmeas") return bTremLog_FORM_unmeas;
@@ -1864,7 +1864,7 @@ bTremLog_FORM AttConverter::StrToBTremLogForm(std::string value)
     return bTremLog_FORM_NONE;
 }
 
-std::string AttConverter::BeamingVisBeamrendToStr(beamingVis_BEAMREND data)
+std::string AttConverter::BeamingVisBeamrendToStr(beamingVis_BEAMREND data) const
 {
     std::string value;
     switch (data) {
@@ -1879,7 +1879,7 @@ std::string AttConverter::BeamingVisBeamrendToStr(beamingVis_BEAMREND data)
     return value;
 }
 
-beamingVis_BEAMREND AttConverter::StrToBeamingVisBeamrend(std::string value)
+beamingVis_BEAMREND AttConverter::StrToBeamingVisBeamrend(std::string value) const
 {
     if (value == "acc") return beamingVis_BEAMREND_acc;
     if (value == "rit") return beamingVis_BEAMREND_rit;
@@ -1888,7 +1888,7 @@ beamingVis_BEAMREND AttConverter::StrToBeamingVisBeamrend(std::string value)
     return beamingVis_BEAMREND_NONE;
 }
 
-std::string AttConverter::BeamrendFormToStr(beamrend_FORM data)
+std::string AttConverter::BeamrendFormToStr(beamrend_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -1904,7 +1904,7 @@ std::string AttConverter::BeamrendFormToStr(beamrend_FORM data)
     return value;
 }
 
-beamrend_FORM AttConverter::StrToBeamrendForm(std::string value)
+beamrend_FORM AttConverter::StrToBeamrendForm(std::string value) const
 {
     if (value == "acc") return beamrend_FORM_acc;
     if (value == "mixed") return beamrend_FORM_mixed;
@@ -1914,7 +1914,7 @@ beamrend_FORM AttConverter::StrToBeamrendForm(std::string value)
     return beamrend_FORM_NONE;
 }
 
-std::string AttConverter::CurvatureCurvedirToStr(curvature_CURVEDIR data)
+std::string AttConverter::CurvatureCurvedirToStr(curvature_CURVEDIR data) const
 {
     std::string value;
     switch (data) {
@@ -1929,7 +1929,7 @@ std::string AttConverter::CurvatureCurvedirToStr(curvature_CURVEDIR data)
     return value;
 }
 
-curvature_CURVEDIR AttConverter::StrToCurvatureCurvedir(std::string value)
+curvature_CURVEDIR AttConverter::StrToCurvatureCurvedir(std::string value) const
 {
     if (value == "above") return curvature_CURVEDIR_above;
     if (value == "below") return curvature_CURVEDIR_below;
@@ -1938,7 +1938,7 @@ curvature_CURVEDIR AttConverter::StrToCurvatureCurvedir(std::string value)
     return curvature_CURVEDIR_NONE;
 }
 
-std::string AttConverter::CutoutCutoutToStr(cutout_CUTOUT data)
+std::string AttConverter::CutoutCutoutToStr(cutout_CUTOUT data) const
 {
     std::string value;
     switch (data) {
@@ -1951,14 +1951,14 @@ std::string AttConverter::CutoutCutoutToStr(cutout_CUTOUT data)
     return value;
 }
 
-cutout_CUTOUT AttConverter::StrToCutoutCutout(std::string value)
+cutout_CUTOUT AttConverter::StrToCutoutCutout(std::string value) const
 {
     if (value == "cutout") return cutout_CUTOUT_cutout;
     LogWarning("Unsupported value '%s' for att.cutout@cutout", value.c_str());
     return cutout_CUTOUT_NONE;
 }
 
-std::string AttConverter::DotLogFormToStr(dotLog_FORM data)
+std::string AttConverter::DotLogFormToStr(dotLog_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -1972,7 +1972,7 @@ std::string AttConverter::DotLogFormToStr(dotLog_FORM data)
     return value;
 }
 
-dotLog_FORM AttConverter::StrToDotLogForm(std::string value)
+dotLog_FORM AttConverter::StrToDotLogForm(std::string value) const
 {
     if (value == "aug") return dotLog_FORM_aug;
     if (value == "div") return dotLog_FORM_div;
@@ -1980,7 +1980,7 @@ dotLog_FORM AttConverter::StrToDotLogForm(std::string value)
     return dotLog_FORM_NONE;
 }
 
-std::string AttConverter::EndingsEndingrendToStr(endings_ENDINGREND data)
+std::string AttConverter::EndingsEndingrendToStr(endings_ENDINGREND data) const
 {
     std::string value;
     switch (data) {
@@ -1995,7 +1995,7 @@ std::string AttConverter::EndingsEndingrendToStr(endings_ENDINGREND data)
     return value;
 }
 
-endings_ENDINGREND AttConverter::StrToEndingsEndingrend(std::string value)
+endings_ENDINGREND AttConverter::StrToEndingsEndingrend(std::string value) const
 {
     if (value == "top") return endings_ENDINGREND_top;
     if (value == "barred") return endings_ENDINGREND_barred;
@@ -2004,7 +2004,7 @@ endings_ENDINGREND AttConverter::StrToEndingsEndingrend(std::string value)
     return endings_ENDINGREND_NONE;
 }
 
-std::string AttConverter::FTremLogFormToStr(fTremLog_FORM data)
+std::string AttConverter::FTremLogFormToStr(fTremLog_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2018,7 +2018,7 @@ std::string AttConverter::FTremLogFormToStr(fTremLog_FORM data)
     return value;
 }
 
-fTremLog_FORM AttConverter::StrToFTremLogForm(std::string value)
+fTremLog_FORM AttConverter::StrToFTremLogForm(std::string value) const
 {
     if (value == "meas") return fTremLog_FORM_meas;
     if (value == "unmeas") return fTremLog_FORM_unmeas;
@@ -2026,7 +2026,7 @@ fTremLog_FORM AttConverter::StrToFTremLogForm(std::string value)
     return fTremLog_FORM_NONE;
 }
 
-std::string AttConverter::FermataVisFormToStr(fermataVis_FORM data)
+std::string AttConverter::FermataVisFormToStr(fermataVis_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2040,7 +2040,7 @@ std::string AttConverter::FermataVisFormToStr(fermataVis_FORM data)
     return value;
 }
 
-fermataVis_FORM AttConverter::StrToFermataVisForm(std::string value)
+fermataVis_FORM AttConverter::StrToFermataVisForm(std::string value) const
 {
     if (value == "inv") return fermataVis_FORM_inv;
     if (value == "norm") return fermataVis_FORM_norm;
@@ -2048,7 +2048,7 @@ fermataVis_FORM AttConverter::StrToFermataVisForm(std::string value)
     return fermataVis_FORM_NONE;
 }
 
-std::string AttConverter::FermataVisShapeToStr(fermataVis_SHAPE data)
+std::string AttConverter::FermataVisShapeToStr(fermataVis_SHAPE data) const
 {
     std::string value;
     switch (data) {
@@ -2063,7 +2063,7 @@ std::string AttConverter::FermataVisShapeToStr(fermataVis_SHAPE data)
     return value;
 }
 
-fermataVis_SHAPE AttConverter::StrToFermataVisShape(std::string value)
+fermataVis_SHAPE AttConverter::StrToFermataVisShape(std::string value) const
 {
     if (value == "curved") return fermataVis_SHAPE_curved;
     if (value == "square") return fermataVis_SHAPE_square;
@@ -2072,7 +2072,7 @@ fermataVis_SHAPE AttConverter::StrToFermataVisShape(std::string value)
     return fermataVis_SHAPE_NONE;
 }
 
-std::string AttConverter::HairpinLogFormToStr(hairpinLog_FORM data)
+std::string AttConverter::HairpinLogFormToStr(hairpinLog_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2086,7 +2086,7 @@ std::string AttConverter::HairpinLogFormToStr(hairpinLog_FORM data)
     return value;
 }
 
-hairpinLog_FORM AttConverter::StrToHairpinLogForm(std::string value)
+hairpinLog_FORM AttConverter::StrToHairpinLogForm(std::string value) const
 {
     if (value == "cres") return hairpinLog_FORM_cres;
     if (value == "dim") return hairpinLog_FORM_dim;
@@ -2094,7 +2094,7 @@ hairpinLog_FORM AttConverter::StrToHairpinLogForm(std::string value)
     return hairpinLog_FORM_NONE;
 }
 
-std::string AttConverter::HarmVisRendgridToStr(harmVis_RENDGRID data)
+std::string AttConverter::HarmVisRendgridToStr(harmVis_RENDGRID data) const
 {
     std::string value;
     switch (data) {
@@ -2109,7 +2109,7 @@ std::string AttConverter::HarmVisRendgridToStr(harmVis_RENDGRID data)
     return value;
 }
 
-harmVis_RENDGRID AttConverter::StrToHarmVisRendgrid(std::string value)
+harmVis_RENDGRID AttConverter::StrToHarmVisRendgrid(std::string value) const
 {
     if (value == "grid") return harmVis_RENDGRID_grid;
     if (value == "gridtext") return harmVis_RENDGRID_gridtext;
@@ -2118,7 +2118,7 @@ harmVis_RENDGRID AttConverter::StrToHarmVisRendgrid(std::string value)
     return harmVis_RENDGRID_NONE;
 }
 
-std::string AttConverter::HarpPedalLogAToStr(harpPedalLog_A data)
+std::string AttConverter::HarpPedalLogAToStr(harpPedalLog_A data) const
 {
     std::string value;
     switch (data) {
@@ -2133,7 +2133,7 @@ std::string AttConverter::HarpPedalLogAToStr(harpPedalLog_A data)
     return value;
 }
 
-harpPedalLog_A AttConverter::StrToHarpPedalLogA(std::string value)
+harpPedalLog_A AttConverter::StrToHarpPedalLogA(std::string value) const
 {
     if (value == "f") return harpPedalLog_A_f;
     if (value == "n") return harpPedalLog_A_n;
@@ -2142,7 +2142,7 @@ harpPedalLog_A AttConverter::StrToHarpPedalLogA(std::string value)
     return harpPedalLog_A_NONE;
 }
 
-std::string AttConverter::HarpPedalLogBToStr(harpPedalLog_B data)
+std::string AttConverter::HarpPedalLogBToStr(harpPedalLog_B data) const
 {
     std::string value;
     switch (data) {
@@ -2157,7 +2157,7 @@ std::string AttConverter::HarpPedalLogBToStr(harpPedalLog_B data)
     return value;
 }
 
-harpPedalLog_B AttConverter::StrToHarpPedalLogB(std::string value)
+harpPedalLog_B AttConverter::StrToHarpPedalLogB(std::string value) const
 {
     if (value == "f") return harpPedalLog_B_f;
     if (value == "n") return harpPedalLog_B_n;
@@ -2166,7 +2166,7 @@ harpPedalLog_B AttConverter::StrToHarpPedalLogB(std::string value)
     return harpPedalLog_B_NONE;
 }
 
-std::string AttConverter::HarpPedalLogCToStr(harpPedalLog_C data)
+std::string AttConverter::HarpPedalLogCToStr(harpPedalLog_C data) const
 {
     std::string value;
     switch (data) {
@@ -2181,7 +2181,7 @@ std::string AttConverter::HarpPedalLogCToStr(harpPedalLog_C data)
     return value;
 }
 
-harpPedalLog_C AttConverter::StrToHarpPedalLogC(std::string value)
+harpPedalLog_C AttConverter::StrToHarpPedalLogC(std::string value) const
 {
     if (value == "f") return harpPedalLog_C_f;
     if (value == "n") return harpPedalLog_C_n;
@@ -2190,7 +2190,7 @@ harpPedalLog_C AttConverter::StrToHarpPedalLogC(std::string value)
     return harpPedalLog_C_NONE;
 }
 
-std::string AttConverter::HarpPedalLogDToStr(harpPedalLog_D data)
+std::string AttConverter::HarpPedalLogDToStr(harpPedalLog_D data) const
 {
     std::string value;
     switch (data) {
@@ -2205,7 +2205,7 @@ std::string AttConverter::HarpPedalLogDToStr(harpPedalLog_D data)
     return value;
 }
 
-harpPedalLog_D AttConverter::StrToHarpPedalLogD(std::string value)
+harpPedalLog_D AttConverter::StrToHarpPedalLogD(std::string value) const
 {
     if (value == "f") return harpPedalLog_D_f;
     if (value == "n") return harpPedalLog_D_n;
@@ -2214,7 +2214,7 @@ harpPedalLog_D AttConverter::StrToHarpPedalLogD(std::string value)
     return harpPedalLog_D_NONE;
 }
 
-std::string AttConverter::HarpPedalLogEToStr(harpPedalLog_E data)
+std::string AttConverter::HarpPedalLogEToStr(harpPedalLog_E data) const
 {
     std::string value;
     switch (data) {
@@ -2229,7 +2229,7 @@ std::string AttConverter::HarpPedalLogEToStr(harpPedalLog_E data)
     return value;
 }
 
-harpPedalLog_E AttConverter::StrToHarpPedalLogE(std::string value)
+harpPedalLog_E AttConverter::StrToHarpPedalLogE(std::string value) const
 {
     if (value == "f") return harpPedalLog_E_f;
     if (value == "n") return harpPedalLog_E_n;
@@ -2238,7 +2238,7 @@ harpPedalLog_E AttConverter::StrToHarpPedalLogE(std::string value)
     return harpPedalLog_E_NONE;
 }
 
-std::string AttConverter::HarpPedalLogFToStr(harpPedalLog_F data)
+std::string AttConverter::HarpPedalLogFToStr(harpPedalLog_F data) const
 {
     std::string value;
     switch (data) {
@@ -2253,7 +2253,7 @@ std::string AttConverter::HarpPedalLogFToStr(harpPedalLog_F data)
     return value;
 }
 
-harpPedalLog_F AttConverter::StrToHarpPedalLogF(std::string value)
+harpPedalLog_F AttConverter::StrToHarpPedalLogF(std::string value) const
 {
     if (value == "f") return harpPedalLog_F_f;
     if (value == "n") return harpPedalLog_F_n;
@@ -2262,7 +2262,7 @@ harpPedalLog_F AttConverter::StrToHarpPedalLogF(std::string value)
     return harpPedalLog_F_NONE;
 }
 
-std::string AttConverter::HarpPedalLogGToStr(harpPedalLog_G data)
+std::string AttConverter::HarpPedalLogGToStr(harpPedalLog_G data) const
 {
     std::string value;
     switch (data) {
@@ -2277,7 +2277,7 @@ std::string AttConverter::HarpPedalLogGToStr(harpPedalLog_G data)
     return value;
 }
 
-harpPedalLog_G AttConverter::StrToHarpPedalLogG(std::string value)
+harpPedalLog_G AttConverter::StrToHarpPedalLogG(std::string value) const
 {
     if (value == "f") return harpPedalLog_G_f;
     if (value == "n") return harpPedalLog_G_n;
@@ -2286,7 +2286,7 @@ harpPedalLog_G AttConverter::StrToHarpPedalLogG(std::string value)
     return harpPedalLog_G_NONE;
 }
 
-std::string AttConverter::MeiversionMeiversionToStr(meiversion_MEIVERSION data)
+std::string AttConverter::MeiversionMeiversionToStr(meiversion_MEIVERSION data) const
 {
     std::string value;
     switch (data) {
@@ -2299,14 +2299,14 @@ std::string AttConverter::MeiversionMeiversionToStr(meiversion_MEIVERSION data)
     return value;
 }
 
-meiversion_MEIVERSION AttConverter::StrToMeiversionMeiversion(std::string value)
+meiversion_MEIVERSION AttConverter::StrToMeiversionMeiversion(std::string value) const
 {
     if (value == "3.0.0") return meiversion_MEIVERSION_3_0_0;
     LogWarning("Unsupported value '%s' for att.meiversion@meiversion", value.c_str());
     return meiversion_MEIVERSION_NONE;
 }
 
-std::string AttConverter::MensurVisFormToStr(mensurVis_FORM data)
+std::string AttConverter::MensurVisFormToStr(mensurVis_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2320,7 +2320,7 @@ std::string AttConverter::MensurVisFormToStr(mensurVis_FORM data)
     return value;
 }
 
-mensurVis_FORM AttConverter::StrToMensurVisForm(std::string value)
+mensurVis_FORM AttConverter::StrToMensurVisForm(std::string value) const
 {
     if (value == "horizontal") return mensurVis_FORM_horizontal;
     if (value == "vertical") return mensurVis_FORM_vertical;
@@ -2328,7 +2328,7 @@ mensurVis_FORM AttConverter::StrToMensurVisForm(std::string value)
     return mensurVis_FORM_NONE;
 }
 
-std::string AttConverter::MensuralVisMensurformToStr(mensuralVis_MENSURFORM data)
+std::string AttConverter::MensuralVisMensurformToStr(mensuralVis_MENSURFORM data) const
 {
     std::string value;
     switch (data) {
@@ -2342,7 +2342,7 @@ std::string AttConverter::MensuralVisMensurformToStr(mensuralVis_MENSURFORM data
     return value;
 }
 
-mensuralVis_MENSURFORM AttConverter::StrToMensuralVisMensurform(std::string value)
+mensuralVis_MENSURFORM AttConverter::StrToMensuralVisMensurform(std::string value) const
 {
     if (value == "horizontal") return mensuralVis_MENSURFORM_horizontal;
     if (value == "vertical") return mensuralVis_MENSURFORM_vertical;
@@ -2350,7 +2350,7 @@ mensuralVis_MENSURFORM AttConverter::StrToMensuralVisMensurform(std::string valu
     return mensuralVis_MENSURFORM_NONE;
 }
 
-std::string AttConverter::MeterSigVisFormToStr(meterSigVis_FORM data)
+std::string AttConverter::MeterSigVisFormToStr(meterSigVis_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2366,7 +2366,7 @@ std::string AttConverter::MeterSigVisFormToStr(meterSigVis_FORM data)
     return value;
 }
 
-meterSigVis_FORM AttConverter::StrToMeterSigVisForm(std::string value)
+meterSigVis_FORM AttConverter::StrToMeterSigVisForm(std::string value) const
 {
     if (value == "num") return meterSigVis_FORM_num;
     if (value == "denomsym") return meterSigVis_FORM_denomsym;
@@ -2376,7 +2376,7 @@ meterSigVis_FORM AttConverter::StrToMeterSigVisForm(std::string value)
     return meterSigVis_FORM_NONE;
 }
 
-std::string AttConverter::MeterSigDefaultVisMeterrendToStr(meterSigDefaultVis_METERREND data)
+std::string AttConverter::MeterSigDefaultVisMeterrendToStr(meterSigDefaultVis_METERREND data) const
 {
     std::string value;
     switch (data) {
@@ -2392,7 +2392,7 @@ std::string AttConverter::MeterSigDefaultVisMeterrendToStr(meterSigDefaultVis_ME
     return value;
 }
 
-meterSigDefaultVis_METERREND AttConverter::StrToMeterSigDefaultVisMeterrend(std::string value)
+meterSigDefaultVis_METERREND AttConverter::StrToMeterSigDefaultVisMeterrend(std::string value) const
 {
     if (value == "num") return meterSigDefaultVis_METERREND_num;
     if (value == "denomsym") return meterSigDefaultVis_METERREND_denomsym;
@@ -2402,7 +2402,7 @@ meterSigDefaultVis_METERREND AttConverter::StrToMeterSigDefaultVisMeterrend(std:
     return meterSigDefaultVis_METERREND_NONE;
 }
 
-std::string AttConverter::MeterconformanceMetconToStr(meterconformance_METCON data)
+std::string AttConverter::MeterconformanceMetconToStr(meterconformance_METCON data) const
 {
     std::string value;
     switch (data) {
@@ -2417,7 +2417,7 @@ std::string AttConverter::MeterconformanceMetconToStr(meterconformance_METCON da
     return value;
 }
 
-meterconformance_METCON AttConverter::StrToMeterconformanceMetcon(std::string value)
+meterconformance_METCON AttConverter::StrToMeterconformanceMetcon(std::string value) const
 {
     if (value == "c") return meterconformance_METCON_c;
     if (value == "i") return meterconformance_METCON_i;
@@ -2426,7 +2426,7 @@ meterconformance_METCON AttConverter::StrToMeterconformanceMetcon(std::string va
     return meterconformance_METCON_NONE;
 }
 
-std::string AttConverter::MordentLogFormToStr(mordentLog_FORM data)
+std::string AttConverter::MordentLogFormToStr(mordentLog_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2440,7 +2440,7 @@ std::string AttConverter::MordentLogFormToStr(mordentLog_FORM data)
     return value;
 }
 
-mordentLog_FORM AttConverter::StrToMordentLogForm(std::string value)
+mordentLog_FORM AttConverter::StrToMordentLogForm(std::string value) const
 {
     if (value == "inv") return mordentLog_FORM_inv;
     if (value == "norm") return mordentLog_FORM_norm;
@@ -2448,7 +2448,7 @@ mordentLog_FORM AttConverter::StrToMordentLogForm(std::string value)
     return mordentLog_FORM_NONE;
 }
 
-std::string AttConverter::NoteLogMensuralLigToStr(noteLogMensural_LIG data)
+std::string AttConverter::NoteLogMensuralLigToStr(noteLogMensural_LIG data) const
 {
     std::string value;
     switch (data) {
@@ -2462,7 +2462,7 @@ std::string AttConverter::NoteLogMensuralLigToStr(noteLogMensural_LIG data)
     return value;
 }
 
-noteLogMensural_LIG AttConverter::StrToNoteLogMensuralLig(std::string value)
+noteLogMensural_LIG AttConverter::StrToNoteLogMensuralLig(std::string value) const
 {
     if (value == "recta") return noteLogMensural_LIG_recta;
     if (value == "obliqua") return noteLogMensural_LIG_obliqua;
@@ -2470,7 +2470,7 @@ noteLogMensural_LIG AttConverter::StrToNoteLogMensuralLig(std::string value)
     return noteLogMensural_LIG_NONE;
 }
 
-std::string AttConverter::OctaveLogCollToStr(octaveLog_COLL data)
+std::string AttConverter::OctaveLogCollToStr(octaveLog_COLL data) const
 {
     std::string value;
     switch (data) {
@@ -2483,14 +2483,14 @@ std::string AttConverter::OctaveLogCollToStr(octaveLog_COLL data)
     return value;
 }
 
-octaveLog_COLL AttConverter::StrToOctaveLogColl(std::string value)
+octaveLog_COLL AttConverter::StrToOctaveLogColl(std::string value) const
 {
     if (value == "coll") return octaveLog_COLL_coll;
     LogWarning("Unsupported value '%s' for att.octave.log@coll", value.c_str());
     return octaveLog_COLL_NONE;
 }
 
-std::string AttConverter::PbVisFoliumToStr(pbVis_FOLIUM data)
+std::string AttConverter::PbVisFoliumToStr(pbVis_FOLIUM data) const
 {
     std::string value;
     switch (data) {
@@ -2504,7 +2504,7 @@ std::string AttConverter::PbVisFoliumToStr(pbVis_FOLIUM data)
     return value;
 }
 
-pbVis_FOLIUM AttConverter::StrToPbVisFolium(std::string value)
+pbVis_FOLIUM AttConverter::StrToPbVisFolium(std::string value) const
 {
     if (value == "verso") return pbVis_FOLIUM_verso;
     if (value == "recto") return pbVis_FOLIUM_recto;
@@ -2512,7 +2512,7 @@ pbVis_FOLIUM AttConverter::StrToPbVisFolium(std::string value)
     return pbVis_FOLIUM_NONE;
 }
 
-std::string AttConverter::PedalLogDirToStr(pedalLog_DIR data)
+std::string AttConverter::PedalLogDirToStr(pedalLog_DIR data) const
 {
     std::string value;
     switch (data) {
@@ -2528,7 +2528,7 @@ std::string AttConverter::PedalLogDirToStr(pedalLog_DIR data)
     return value;
 }
 
-pedalLog_DIR AttConverter::StrToPedalLogDir(std::string value)
+pedalLog_DIR AttConverter::StrToPedalLogDir(std::string value) const
 {
     if (value == "down") return pedalLog_DIR_down;
     if (value == "up") return pedalLog_DIR_up;
@@ -2538,7 +2538,7 @@ pedalLog_DIR AttConverter::StrToPedalLogDir(std::string value)
     return pedalLog_DIR_NONE;
 }
 
-std::string AttConverter::PedalVisFormToStr(pedalVis_FORM data)
+std::string AttConverter::PedalVisFormToStr(pedalVis_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2553,7 +2553,7 @@ std::string AttConverter::PedalVisFormToStr(pedalVis_FORM data)
     return value;
 }
 
-pedalVis_FORM AttConverter::StrToPedalVisForm(std::string value)
+pedalVis_FORM AttConverter::StrToPedalVisForm(std::string value) const
 {
     if (value == "line") return pedalVis_FORM_line;
     if (value == "pedstar") return pedalVis_FORM_pedstar;
@@ -2562,7 +2562,7 @@ pedalVis_FORM AttConverter::StrToPedalVisForm(std::string value)
     return pedalVis_FORM_NONE;
 }
 
-std::string AttConverter::PianopedalsPedalstyleToStr(pianopedals_PEDALSTYLE data)
+std::string AttConverter::PianopedalsPedalstyleToStr(pianopedals_PEDALSTYLE data) const
 {
     std::string value;
     switch (data) {
@@ -2577,7 +2577,7 @@ std::string AttConverter::PianopedalsPedalstyleToStr(pianopedals_PEDALSTYLE data
     return value;
 }
 
-pianopedals_PEDALSTYLE AttConverter::StrToPianopedalsPedalstyle(std::string value)
+pianopedals_PEDALSTYLE AttConverter::StrToPianopedalsPedalstyle(std::string value) const
 {
     if (value == "line") return pianopedals_PEDALSTYLE_line;
     if (value == "pedstar") return pianopedals_PEDALSTYLE_pedstar;
@@ -2586,7 +2586,7 @@ pianopedals_PEDALSTYLE AttConverter::StrToPianopedalsPedalstyle(std::string valu
     return pianopedals_PEDALSTYLE_NONE;
 }
 
-std::string AttConverter::PlistEvaluateToStr(plist_EVALUATE data)
+std::string AttConverter::PlistEvaluateToStr(plist_EVALUATE data) const
 {
     std::string value;
     switch (data) {
@@ -2601,7 +2601,7 @@ std::string AttConverter::PlistEvaluateToStr(plist_EVALUATE data)
     return value;
 }
 
-plist_EVALUATE AttConverter::StrToPlistEvaluate(std::string value)
+plist_EVALUATE AttConverter::StrToPlistEvaluate(std::string value) const
 {
     if (value == "all") return plist_EVALUATE_all;
     if (value == "one") return plist_EVALUATE_one;
@@ -2610,7 +2610,7 @@ plist_EVALUATE AttConverter::StrToPlistEvaluate(std::string value)
     return plist_EVALUATE_NONE;
 }
 
-std::string AttConverter::PointingXlinkactuateToStr(pointing_XLINKACTUATE data)
+std::string AttConverter::PointingXlinkactuateToStr(pointing_XLINKACTUATE data) const
 {
     std::string value;
     switch (data) {
@@ -2626,7 +2626,7 @@ std::string AttConverter::PointingXlinkactuateToStr(pointing_XLINKACTUATE data)
     return value;
 }
 
-pointing_XLINKACTUATE AttConverter::StrToPointingXlinkactuate(std::string value)
+pointing_XLINKACTUATE AttConverter::StrToPointingXlinkactuate(std::string value) const
 {
     if (value == "onLoad") return pointing_XLINKACTUATE_onLoad;
     if (value == "onRequest") return pointing_XLINKACTUATE_onRequest;
@@ -2636,7 +2636,7 @@ pointing_XLINKACTUATE AttConverter::StrToPointingXlinkactuate(std::string value)
     return pointing_XLINKACTUATE_NONE;
 }
 
-std::string AttConverter::PointingXlinkshowToStr(pointing_XLINKSHOW data)
+std::string AttConverter::PointingXlinkshowToStr(pointing_XLINKSHOW data) const
 {
     std::string value;
     switch (data) {
@@ -2653,7 +2653,7 @@ std::string AttConverter::PointingXlinkshowToStr(pointing_XLINKSHOW data)
     return value;
 }
 
-pointing_XLINKSHOW AttConverter::StrToPointingXlinkshow(std::string value)
+pointing_XLINKSHOW AttConverter::StrToPointingXlinkshow(std::string value) const
 {
     if (value == "new") return pointing_XLINKSHOW_new;
     if (value == "replace") return pointing_XLINKSHOW_replace;
@@ -2664,7 +2664,7 @@ pointing_XLINKSHOW AttConverter::StrToPointingXlinkshow(std::string value)
     return pointing_XLINKSHOW_NONE;
 }
 
-std::string AttConverter::RegularmethodMethodToStr(regularmethod_METHOD data)
+std::string AttConverter::RegularmethodMethodToStr(regularmethod_METHOD data) const
 {
     std::string value;
     switch (data) {
@@ -2678,7 +2678,7 @@ std::string AttConverter::RegularmethodMethodToStr(regularmethod_METHOD data)
     return value;
 }
 
-regularmethod_METHOD AttConverter::StrToRegularmethodMethod(std::string value)
+regularmethod_METHOD AttConverter::StrToRegularmethodMethod(std::string value) const
 {
     if (value == "silent") return regularmethod_METHOD_silent;
     if (value == "tags") return regularmethod_METHOD_tags;
@@ -2686,7 +2686,7 @@ regularmethod_METHOD AttConverter::StrToRegularmethodMethod(std::string value)
     return regularmethod_METHOD_NONE;
 }
 
-std::string AttConverter::RehearsalRehencloseToStr(rehearsal_REHENCLOSE data)
+std::string AttConverter::RehearsalRehencloseToStr(rehearsal_REHENCLOSE data) const
 {
     std::string value;
     switch (data) {
@@ -2701,7 +2701,7 @@ std::string AttConverter::RehearsalRehencloseToStr(rehearsal_REHENCLOSE data)
     return value;
 }
 
-rehearsal_REHENCLOSE AttConverter::StrToRehearsalRehenclose(std::string value)
+rehearsal_REHENCLOSE AttConverter::StrToRehearsalRehenclose(std::string value) const
 {
     if (value == "box") return rehearsal_REHENCLOSE_box;
     if (value == "circle") return rehearsal_REHENCLOSE_circle;
@@ -2710,7 +2710,7 @@ rehearsal_REHENCLOSE AttConverter::StrToRehearsalRehenclose(std::string value)
     return rehearsal_REHENCLOSE_NONE;
 }
 
-std::string AttConverter::SbVisFormToStr(sbVis_FORM data)
+std::string AttConverter::SbVisFormToStr(sbVis_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2723,14 +2723,14 @@ std::string AttConverter::SbVisFormToStr(sbVis_FORM data)
     return value;
 }
 
-sbVis_FORM AttConverter::StrToSbVisForm(std::string value)
+sbVis_FORM AttConverter::StrToSbVisForm(std::string value) const
 {
     if (value == "hash") return sbVis_FORM_hash;
     LogWarning("Unsupported value '%s' for att.sb.vis@form", value.c_str());
     return sbVis_FORM_NONE;
 }
 
-std::string AttConverter::StaffgroupingsymSymbolToStr(staffgroupingsym_SYMBOL data)
+std::string AttConverter::StaffgroupingsymSymbolToStr(staffgroupingsym_SYMBOL data) const
 {
     std::string value;
     switch (data) {
@@ -2747,7 +2747,7 @@ std::string AttConverter::StaffgroupingsymSymbolToStr(staffgroupingsym_SYMBOL da
     return value;
 }
 
-staffgroupingsym_SYMBOL AttConverter::StrToStaffgroupingsymSymbol(std::string value)
+staffgroupingsym_SYMBOL AttConverter::StrToStaffgroupingsymSymbol(std::string value) const
 {
     if (value == "brace") return staffgroupingsym_SYMBOL_brace;
     if (value == "bracket") return staffgroupingsym_SYMBOL_bracket;
@@ -2758,7 +2758,7 @@ staffgroupingsym_SYMBOL AttConverter::StrToStaffgroupingsymSymbol(std::string va
     return staffgroupingsym_SYMBOL_NONE;
 }
 
-std::string AttConverter::SylLogConToStr(sylLog_CON data)
+std::string AttConverter::SylLogConToStr(sylLog_CON data) const
 {
     std::string value;
     switch (data) {
@@ -2778,7 +2778,7 @@ std::string AttConverter::SylLogConToStr(sylLog_CON data)
     return value;
 }
 
-sylLog_CON AttConverter::StrToSylLogCon(std::string value)
+sylLog_CON AttConverter::StrToSylLogCon(std::string value) const
 {
     if (value == "s") return sylLog_CON_s;
     if (value == "d") return sylLog_CON_d;
@@ -2792,7 +2792,7 @@ sylLog_CON AttConverter::StrToSylLogCon(std::string value)
     return sylLog_CON_NONE;
 }
 
-std::string AttConverter::SylLogWordposToStr(sylLog_WORDPOS data)
+std::string AttConverter::SylLogWordposToStr(sylLog_WORDPOS data) const
 {
     std::string value;
     switch (data) {
@@ -2807,7 +2807,7 @@ std::string AttConverter::SylLogWordposToStr(sylLog_WORDPOS data)
     return value;
 }
 
-sylLog_WORDPOS AttConverter::StrToSylLogWordpos(std::string value)
+sylLog_WORDPOS AttConverter::StrToSylLogWordpos(std::string value) const
 {
     if (value == "i") return sylLog_WORDPOS_i;
     if (value == "m") return sylLog_WORDPOS_m;
@@ -2816,7 +2816,7 @@ sylLog_WORDPOS AttConverter::StrToSylLogWordpos(std::string value)
     return sylLog_WORDPOS_NONE;
 }
 
-std::string AttConverter::TupletVisNumformatToStr(tupletVis_NUMFORMAT data)
+std::string AttConverter::TupletVisNumformatToStr(tupletVis_NUMFORMAT data) const
 {
     std::string value;
     switch (data) {
@@ -2830,7 +2830,7 @@ std::string AttConverter::TupletVisNumformatToStr(tupletVis_NUMFORMAT data)
     return value;
 }
 
-tupletVis_NUMFORMAT AttConverter::StrToTupletVisNumformat(std::string value)
+tupletVis_NUMFORMAT AttConverter::StrToTupletVisNumformat(std::string value) const
 {
     if (value == "count") return tupletVis_NUMFORMAT_count;
     if (value == "ratio") return tupletVis_NUMFORMAT_ratio;
@@ -2838,7 +2838,7 @@ tupletVis_NUMFORMAT AttConverter::StrToTupletVisNumformat(std::string value)
     return tupletVis_NUMFORMAT_NONE;
 }
 
-std::string AttConverter::TurnLogFormToStr(turnLog_FORM data)
+std::string AttConverter::TurnLogFormToStr(turnLog_FORM data) const
 {
     std::string value;
     switch (data) {
@@ -2852,7 +2852,7 @@ std::string AttConverter::TurnLogFormToStr(turnLog_FORM data)
     return value;
 }
 
-turnLog_FORM AttConverter::StrToTurnLogForm(std::string value)
+turnLog_FORM AttConverter::StrToTurnLogForm(std::string value) const
 {
     if (value == "inv") return turnLog_FORM_inv;
     if (value == "norm") return turnLog_FORM_norm;
@@ -2860,7 +2860,7 @@ turnLog_FORM AttConverter::StrToTurnLogForm(std::string value)
     return turnLog_FORM_NONE;
 }
 
-std::string AttConverter::WhitespaceXmlspaceToStr(whitespace_XMLSPACE data)
+std::string AttConverter::WhitespaceXmlspaceToStr(whitespace_XMLSPACE data) const
 {
     std::string value;
     switch (data) {
@@ -2874,7 +2874,7 @@ std::string AttConverter::WhitespaceXmlspaceToStr(whitespace_XMLSPACE data)
     return value;
 }
 
-whitespace_XMLSPACE AttConverter::StrToWhitespaceXmlspace(std::string value)
+whitespace_XMLSPACE AttConverter::StrToWhitespaceXmlspace(std::string value) const
 {
     if (value == "default") return whitespace_XMLSPACE_default;
     if (value == "preserve") return whitespace_XMLSPACE_preserve;
diff --git a/libmei/attconverter.h b/libmei/attconverter.h
index 48822d09d81..cd8605b08c2 100644
--- a/libmei/attconverter.h
+++ b/libmei/attconverter.h
@@ -29,272 +29,272 @@ namespace vrv {
 
 class AttConverter {
 public:
-    std::string AccidentalExplicitToStr(data_ACCIDENTAL_EXPLICIT data);
-    data_ACCIDENTAL_EXPLICIT StrToAccidentalExplicit(std::string value);
+    std::string AccidentalExplicitToStr(data_ACCIDENTAL_EXPLICIT data) const;
+    data_ACCIDENTAL_EXPLICIT StrToAccidentalExplicit(std::string value) const;
 
-    std::string AccidentalImplicitToStr(data_ACCIDENTAL_IMPLICIT data);
-    data_ACCIDENTAL_IMPLICIT StrToAccidentalImplicit(std::string value);
+    std::string AccidentalImplicitToStr(data_ACCIDENTAL_IMPLICIT data) const;
+    data_ACCIDENTAL_IMPLICIT StrToAccidentalImplicit(std::string value) const;
 
-    std::string ArticulationToStr(data_ARTICULATION data);
-    data_ARTICULATION StrToArticulation(std::string value);
+    std::string ArticulationToStr(data_ARTICULATION data) const;
+    data_ARTICULATION StrToArticulation(std::string value) const;
 
-    std::string BarplaceToStr(data_BARPLACE data);
-    data_BARPLACE StrToBarplace(std::string value);
+    std::string BarplaceToStr(data_BARPLACE data) const;
+    data_BARPLACE StrToBarplace(std::string value) const;
 
-    std::string BarrenditionToStr(data_BARRENDITION data);
-    data_BARRENDITION StrToBarrendition(std::string value);
+    std::string BarrenditionToStr(data_BARRENDITION data) const;
+    data_BARRENDITION StrToBarrendition(std::string value) const;
 
-    std::string BetypeToStr(data_BETYPE data);
-    data_BETYPE StrToBetype(std::string value);
+    std::string BetypeToStr(data_BETYPE data) const;
+    data_BETYPE StrToBetype(std::string value) const;
 
-    std::string BooleanToStr(data_BOOLEAN data);
-    data_BOOLEAN StrToBoolean(std::string value);
+    std::string BooleanToStr(data_BOOLEAN data) const;
+    data_BOOLEAN StrToBoolean(std::string value) const;
 
-    std::string CertaintyToStr(data_CERTAINTY data);
-    data_CERTAINTY StrToCertainty(std::string value);
+    std::string CertaintyToStr(data_CERTAINTY data) const;
+    data_CERTAINTY StrToCertainty(std::string value) const;
 
-    std::string ClefshapeToStr(data_CLEFSHAPE data);
-    data_CLEFSHAPE StrToClefshape(std::string value);
+    std::string ClefshapeToStr(data_CLEFSHAPE data) const;
+    data_CLEFSHAPE StrToClefshape(std::string value) const;
 
-    std::string ClusterToStr(data_CLUSTER data);
-    data_CLUSTER StrToCluster(std::string value);
+    std::string ClusterToStr(data_CLUSTER data) const;
+    data_CLUSTER StrToCluster(std::string value) const;
 
-    std::string ColornamesToStr(data_COLORNAMES data);
-    data_COLORNAMES StrToColornames(std::string value);
+    std::string ColornamesToStr(data_COLORNAMES data) const;
+    data_COLORNAMES StrToColornames(std::string value) const;
 
-    std::string CurverenditionToStr(data_CURVERENDITION data);
-    data_CURVERENDITION StrToCurverendition(std::string value);
+    std::string CurverenditionToStr(data_CURVERENDITION data) const;
+    data_CURVERENDITION StrToCurverendition(std::string value) const;
 
-    std::string EnclosureToStr(data_ENCLOSURE data);
-    data_ENCLOSURE StrToEnclosure(std::string value);
+    std::string EnclosureToStr(data_ENCLOSURE data) const;
+    data_ENCLOSURE StrToEnclosure(std::string value) const;
 
-    std::string FontstyleToStr(data_FONTSTYLE data);
-    data_FONTSTYLE StrToFontstyle(std::string value);
+    std::string FontstyleToStr(data_FONTSTYLE data) const;
+    data_FONTSTYLE StrToFontstyle(std::string value) const;
 
-    std::string FontweightToStr(data_FONTWEIGHT data);
-    data_FONTWEIGHT StrToFontweight(std::string value);
+    std::string FontweightToStr(data_FONTWEIGHT data) const;
+    data_FONTWEIGHT StrToFontweight(std::string value) const;
 
-    std::string GlissandoToStr(data_GLISSANDO data);
-    data_GLISSANDO StrToGlissando(std::string value);
+    std::string GlissandoToStr(data_GLISSANDO data) const;
+    data_GLISSANDO StrToGlissando(std::string value) const;
 
-    std::string GraceToStr(data_GRACE data);
-    data_GRACE StrToGrace(std::string value);
+    std::string GraceToStr(data_GRACE data) const;
+    data_GRACE StrToGrace(std::string value) const;
 
-    std::string HorizontalalignmentToStr(data_HORIZONTALALIGNMENT data);
-    data_HORIZONTALALIGNMENT StrToHorizontalalignment(std::string value);
+    std::string HorizontalalignmentToStr(data_HORIZONTALALIGNMENT data) const;
+    data_HORIZONTALALIGNMENT StrToHorizontalalignment(std::string value) const;
 
-    std::string IneumeformToStr(data_INEUMEFORM data);
-    data_INEUMEFORM StrToIneumeform(std::string value);
+    std::string IneumeformToStr(data_INEUMEFORM data) const;
+    data_INEUMEFORM StrToIneumeform(std::string value) const;
 
-    std::string IneumenameToStr(data_INEUMENAME data);
-    data_INEUMENAME StrToIneumename(std::string value);
+    std::string IneumenameToStr(data_INEUMENAME data) const;
+    data_INEUMENAME StrToIneumename(std::string value) const;
 
-    std::string LayerschemeToStr(data_LAYERSCHEME data);
-    data_LAYERSCHEME StrToLayerscheme(std::string value);
+    std::string LayerschemeToStr(data_LAYERSCHEME data) const;
+    data_LAYERSCHEME StrToLayerscheme(std::string value) const;
 
-    std::string LigatureformToStr(data_LIGATUREFORM data);
-    data_LIGATUREFORM StrToLigatureform(std::string value);
+    std::string LigatureformToStr(data_LIGATUREFORM data) const;
+    data_LIGATUREFORM StrToLigatureform(std::string value) const;
 
-    std::string LineformToStr(data_LINEFORM data);
-    data_LINEFORM StrToLineform(std::string value);
+    std::string LineformToStr(data_LINEFORM data) const;
+    data_LINEFORM StrToLineform(std::string value) const;
 
-    std::string LinestartendsymbolToStr(data_LINESTARTENDSYMBOL data);
-    data_LINESTARTENDSYMBOL StrToLinestartendsymbol(std::string value);
+    std::string LinestartendsymbolToStr(data_LINESTARTENDSYMBOL data) const;
+    data_LINESTARTENDSYMBOL StrToLinestartendsymbol(std::string value) const;
 
-    std::string LinewidthtermToStr(data_LINEWIDTHTERM data);
-    data_LINEWIDTHTERM StrToLinewidthterm(std::string value);
+    std::string LinewidthtermToStr(data_LINEWIDTHTERM data) const;
+    data_LINEWIDTHTERM StrToLinewidthterm(std::string value) const;
 
-    std::string MelodicfunctionToStr(data_MELODICFUNCTION data);
-    data_MELODICFUNCTION StrToMelodicfunction(std::string value);
+    std::string MelodicfunctionToStr(data_MELODICFUNCTION data) const;
+    data_MELODICFUNCTION StrToMelodicfunction(std::string value) const;
 
-    std::string MensurationsignToStr(data_MENSURATIONSIGN data);
-    data_MENSURATIONSIGN StrToMensurationsign(std::string value);
+    std::string MensurationsignToStr(data_MENSURATIONSIGN data) const;
+    data_MENSURATIONSIGN StrToMensurationsign(std::string value) const;
 
-    std::string MetersignToStr(data_METERSIGN data);
-    data_METERSIGN StrToMetersign(std::string value);
+    std::string MetersignToStr(data_METERSIGN data) const;
+    data_METERSIGN StrToMetersign(std::string value) const;
 
-    std::string MidinamesToStr(data_MIDINAMES data);
-    data_MIDINAMES StrToMidinames(std::string value);
+    std::string MidinamesToStr(data_MIDINAMES data) const;
+    data_MIDINAMES StrToMidinames(std::string value) const;
 
-    std::string ModeToStr(data_MODE data);
-    data_MODE StrToMode(std::string value);
+    std::string ModeToStr(data_MODE data) const;
+    data_MODE StrToMode(std::string value) const;
 
-    std::string NotationtypeToStr(data_NOTATIONTYPE data);
-    data_NOTATIONTYPE StrToNotationtype(std::string value);
+    std::string NotationtypeToStr(data_NOTATIONTYPE data) const;
+    data_NOTATIONTYPE StrToNotationtype(std::string value) const;
 
-    std::string NoteheadmodifierListToStr(data_NOTEHEADMODIFIER_list data);
-    data_NOTEHEADMODIFIER_list StrToNoteheadmodifierList(std::string value);
+    std::string NoteheadmodifierListToStr(data_NOTEHEADMODIFIER_list data) const;
+    data_NOTEHEADMODIFIER_list StrToNoteheadmodifierList(std::string value) const;
 
-    std::string OtherstaffToStr(data_OTHERSTAFF data);
-    data_OTHERSTAFF StrToOtherstaff(std::string value);
+    std::string OtherstaffToStr(data_OTHERSTAFF data) const;
+    data_OTHERSTAFF StrToOtherstaff(std::string value) const;
 
-    std::string PlaceToStr(data_PLACE data);
-    data_PLACE StrToPlace(std::string value);
+    std::string PlaceToStr(data_PLACE data) const;
+    data_PLACE StrToPlace(std::string value) const;
 
-    std::string RotationdirectionToStr(data_ROTATIONDIRECTION data);
-    data_ROTATIONDIRECTION StrToRotationdirection(std::string value);
+    std::string RotationdirectionToStr(data_ROTATIONDIRECTION data) const;
+    data_ROTATIONDIRECTION StrToRotationdirection(std::string value) const;
 
-    std::string SizeToStr(data_SIZE data);
-    data_SIZE StrToSize(std::string value);
+    std::string SizeToStr(data_SIZE data) const;
+    data_SIZE StrToSize(std::string value) const;
 
-    std::string StaffrelToStr(data_STAFFREL data);
-    data_STAFFREL StrToStaffrel(std::string value);
+    std::string StaffrelToStr(data_STAFFREL data) const;
+    data_STAFFREL StrToStaffrel(std::string value) const;
 
-    std::string StemmodifierToStr(data_STEMMODIFIER data);
-    data_STEMMODIFIER StrToStemmodifier(std::string value);
+    std::string StemmodifierToStr(data_STEMMODIFIER data) const;
+    data_STEMMODIFIER StrToStemmodifier(std::string value) const;
 
-    std::string StempositionToStr(data_STEMPOSITION data);
-    data_STEMPOSITION StrToStemposition(std::string value);
+    std::string StempositionToStr(data_STEMPOSITION data) const;
+    data_STEMPOSITION StrToStemposition(std::string value) const;
 
-    std::string TemperamentToStr(data_TEMPERAMENT data);
-    data_TEMPERAMENT StrToTemperament(std::string value);
+    std::string TemperamentToStr(data_TEMPERAMENT data) const;
+    data_TEMPERAMENT StrToTemperament(std::string value) const;
 
-    std::string TextrenditionlistToStr(data_TEXTRENDITIONLIST data);
-    data_TEXTRENDITIONLIST StrToTextrenditionlist(std::string value);
+    std::string TextrenditionlistToStr(data_TEXTRENDITIONLIST data) const;
+    data_TEXTRENDITIONLIST StrToTextrenditionlist(std::string value) const;
 
-    std::string UneumeformToStr(data_UNEUMEFORM data);
-    data_UNEUMEFORM StrToUneumeform(std::string value);
+    std::string UneumeformToStr(data_UNEUMEFORM data) const;
+    data_UNEUMEFORM StrToUneumeform(std::string value) const;
 
-    std::string UneumenameToStr(data_UNEUMENAME data);
-    data_UNEUMENAME StrToUneumename(std::string value);
+    std::string UneumenameToStr(data_UNEUMENAME data) const;
+    data_UNEUMENAME StrToUneumename(std::string value) const;
 
-    std::string AccidLogFuncToStr(accidLog_FUNC data);
-    accidLog_FUNC StrToAccidLogFunc(std::string value);
+    std::string AccidLogFuncToStr(accidLog_FUNC data) const;
+    accidLog_FUNC StrToAccidLogFunc(std::string value) const;
 
-    std::string ArpegLogOrderToStr(arpegLog_ORDER data);
-    arpegLog_ORDER StrToArpegLogOrder(std::string value);
+    std::string ArpegLogOrderToStr(arpegLog_ORDER data) const;
+    arpegLog_ORDER StrToArpegLogOrder(std::string value) const;
 
-    std::string BTremLogFormToStr(bTremLog_FORM data);
-    bTremLog_FORM StrToBTremLogForm(std::string value);
+    std::string BTremLogFormToStr(bTremLog_FORM data) const;
+    bTremLog_FORM StrToBTremLogForm(std::string value) const;
 
-    std::string BeamingVisBeamrendToStr(beamingVis_BEAMREND data);
-    beamingVis_BEAMREND StrToBeamingVisBeamrend(std::string value);
+    std::string BeamingVisBeamrendToStr(beamingVis_BEAMREND data) const;
+    beamingVis_BEAMREND StrToBeamingVisBeamrend(std::string value) const;
 
-    std::string BeamrendFormToStr(beamrend_FORM data);
-    beamrend_FORM StrToBeamrendForm(std::string value);
+    std::string BeamrendFormToStr(beamrend_FORM data) const;
+    beamrend_FORM StrToBeamrendForm(std::string value) const;
 
-    std::string CurvatureCurvedirToStr(curvature_CURVEDIR data);
-    curvature_CURVEDIR StrToCurvatureCurvedir(std::string value);
+    std::string CurvatureCurvedirToStr(curvature_CURVEDIR data) const;
+    curvature_CURVEDIR StrToCurvatureCurvedir(std::string value) const;
 
-    std::string CutoutCutoutToStr(cutout_CUTOUT data);
-    cutout_CUTOUT StrToCutoutCutout(std::string value);
+    std::string CutoutCutoutToStr(cutout_CUTOUT data) const;
+    cutout_CUTOUT StrToCutoutCutout(std::string value) const;
 
-    std::string DotLogFormToStr(dotLog_FORM data);
-    dotLog_FORM StrToDotLogForm(std::string value);
+    std::string DotLogFormToStr(dotLog_FORM data) const;
+    dotLog_FORM StrToDotLogForm(std::string value) const;
 
-    std::string EndingsEndingrendToStr(endings_ENDINGREND data);
-    endings_ENDINGREND StrToEndingsEndingrend(std::string value);
+    std::string EndingsEndingrendToStr(endings_ENDINGREND data) const;
+    endings_ENDINGREND StrToEndingsEndingrend(std::string value) const;
 
-    std::string FTremLogFormToStr(fTremLog_FORM data);
-    fTremLog_FORM StrToFTremLogForm(std::string value);
+    std::string FTremLogFormToStr(fTremLog_FORM data) const;
+    fTremLog_FORM StrToFTremLogForm(std::string value) const;
 
-    std::string FermataVisFormToStr(fermataVis_FORM data);
-    fermataVis_FORM StrToFermataVisForm(std::string value);
+    std::string FermataVisFormToStr(fermataVis_FORM data) const;
+    fermataVis_FORM StrToFermataVisForm(std::string value) const;
 
-    std::string FermataVisShapeToStr(fermataVis_SHAPE data);
-    fermataVis_SHAPE StrToFermataVisShape(std::string value);
+    std::string FermataVisShapeToStr(fermataVis_SHAPE data) const;
+    fermataVis_SHAPE StrToFermataVisShape(std::string value) const;
 
-    std::string HairpinLogFormToStr(hairpinLog_FORM data);
-    hairpinLog_FORM StrToHairpinLogForm(std::string value);
+    std::string HairpinLogFormToStr(hairpinLog_FORM data) const;
+    hairpinLog_FORM StrToHairpinLogForm(std::string value) const;
 
-    std::string HarmVisRendgridToStr(harmVis_RENDGRID data);
-    harmVis_RENDGRID StrToHarmVisRendgrid(std::string value);
+    std::string HarmVisRendgridToStr(harmVis_RENDGRID data) const;
+    harmVis_RENDGRID StrToHarmVisRendgrid(std::string value) const;
 
-    std::string HarpPedalLogAToStr(harpPedalLog_A data);
-    harpPedalLog_A StrToHarpPedalLogA(std::string value);
+    std::string HarpPedalLogAToStr(harpPedalLog_A data) const;
+    harpPedalLog_A StrToHarpPedalLogA(std::string value) const;
 
-    std::string HarpPedalLogBToStr(harpPedalLog_B data);
-    harpPedalLog_B StrToHarpPedalLogB(std::string value);
+    std::string HarpPedalLogBToStr(harpPedalLog_B data) const;
+    harpPedalLog_B StrToHarpPedalLogB(std::string value) const;
 
-    std::string HarpPedalLogCToStr(harpPedalLog_C data);
-    harpPedalLog_C StrToHarpPedalLogC(std::string value);
+    std::string HarpPedalLogCToStr(harpPedalLog_C data) const;
+    harpPedalLog_C StrToHarpPedalLogC(std::string value) const;
 
-    std::string HarpPedalLogDToStr(harpPedalLog_D data);
-    harpPedalLog_D StrToHarpPedalLogD(std::string value);
+    std::string HarpPedalLogDToStr(harpPedalLog_D data) const;
+    harpPedalLog_D StrToHarpPedalLogD(std::string value) const;
 
-    std::string HarpPedalLogEToStr(harpPedalLog_E data);
-    harpPedalLog_E StrToHarpPedalLogE(std::string value);
+    std::string HarpPedalLogEToStr(harpPedalLog_E data) const;
+    harpPedalLog_E StrToHarpPedalLogE(std::string value) const;
 
-    std::string HarpPedalLogFToStr(harpPedalLog_F data);
-    harpPedalLog_F StrToHarpPedalLogF(std::string value);
+    std::string HarpPedalLogFToStr(harpPedalLog_F data) const;
+    harpPedalLog_F StrToHarpPedalLogF(std::string value) const;
 
-    std::string HarpPedalLogGToStr(harpPedalLog_G data);
-    harpPedalLog_G StrToHarpPedalLogG(std::string value);
+    std::string HarpPedalLogGToStr(harpPedalLog_G data) const;
+    harpPedalLog_G StrToHarpPedalLogG(std::string value) const;
 
-    std::string MeiversionMeiversionToStr(meiversion_MEIVERSION data);
-    meiversion_MEIVERSION StrToMeiversionMeiversion(std::string value);
+    std::string MeiversionMeiversionToStr(meiversion_MEIVERSION data) const;
+    meiversion_MEIVERSION StrToMeiversionMeiversion(std::string value) const;
 
-    std::string MensurVisFormToStr(mensurVis_FORM data);
-    mensurVis_FORM StrToMensurVisForm(std::string value);
+    std::string MensurVisFormToStr(mensurVis_FORM data) const;
+    mensurVis_FORM StrToMensurVisForm(std::string value) const;
 
-    std::string MensuralVisMensurformToStr(mensuralVis_MENSURFORM data);
-    mensuralVis_MENSURFORM StrToMensuralVisMensurform(std::string value);
+    std::string MensuralVisMensurformToStr(mensuralVis_MENSURFORM data) const;
+    mensuralVis_MENSURFORM StrToMensuralVisMensurform(std::string value) const;
 
-    std::string MeterSigVisFormToStr(meterSigVis_FORM data);
-    meterSigVis_FORM StrToMeterSigVisForm(std::string value);
+    std::string MeterSigVisFormToStr(meterSigVis_FORM data) const;
+    meterSigVis_FORM StrToMeterSigVisForm(std::string value) const;
 
-    std::string MeterSigDefaultVisMeterrendToStr(meterSigDefaultVis_METERREND data);
-    meterSigDefaultVis_METERREND StrToMeterSigDefaultVisMeterrend(std::string value);
+    std::string MeterSigDefaultVisMeterrendToStr(meterSigDefaultVis_METERREND data) const;
+    meterSigDefaultVis_METERREND StrToMeterSigDefaultVisMeterrend(std::string value) const;
 
-    std::string MeterconformanceMetconToStr(meterconformance_METCON data);
-    meterconformance_METCON StrToMeterconformanceMetcon(std::string value);
+    std::string MeterconformanceMetconToStr(meterconformance_METCON data) const;
+    meterconformance_METCON StrToMeterconformanceMetcon(std::string value) const;
 
-    std::string MordentLogFormToStr(mordentLog_FORM data);
-    mordentLog_FORM StrToMordentLogForm(std::string value);
+    std::string MordentLogFormToStr(mordentLog_FORM data) const;
+    mordentLog_FORM StrToMordentLogForm(std::string value) const;
 
-    std::string NoteLogMensuralLigToStr(noteLogMensural_LIG data);
-    noteLogMensural_LIG StrToNoteLogMensuralLig(std::string value);
+    std::string NoteLogMensuralLigToStr(noteLogMensural_LIG data) const;
+    noteLogMensural_LIG StrToNoteLogMensuralLig(std::string value) const;
 
-    std::string OctaveLogCollToStr(octaveLog_COLL data);
-    octaveLog_COLL StrToOctaveLogColl(std::string value);
+    std::string OctaveLogCollToStr(octaveLog_COLL data) const;
+    octaveLog_COLL StrToOctaveLogColl(std::string value) const;
 
-    std::string PbVisFoliumToStr(pbVis_FOLIUM data);
-    pbVis_FOLIUM StrToPbVisFolium(std::string value);
+    std::string PbVisFoliumToStr(pbVis_FOLIUM data) const;
+    pbVis_FOLIUM StrToPbVisFolium(std::string value) const;
 
-    std::string PedalLogDirToStr(pedalLog_DIR data);
-    pedalLog_DIR StrToPedalLogDir(std::string value);
+    std::string PedalLogDirToStr(pedalLog_DIR data) const;
+    pedalLog_DIR StrToPedalLogDir(std::string value) const;
 
-    std::string PedalVisFormToStr(pedalVis_FORM data);
-    pedalVis_FORM StrToPedalVisForm(std::string value);
+    std::string PedalVisFormToStr(pedalVis_FORM data) const;
+    pedalVis_FORM StrToPedalVisForm(std::string value) const;
 
-    std::string PianopedalsPedalstyleToStr(pianopedals_PEDALSTYLE data);
-    pianopedals_PEDALSTYLE StrToPianopedalsPedalstyle(std::string value);
+    std::string PianopedalsPedalstyleToStr(pianopedals_PEDALSTYLE data) const;
+    pianopedals_PEDALSTYLE StrToPianopedalsPedalstyle(std::string value) const;
 
-    std::string PlistEvaluateToStr(plist_EVALUATE data);
-    plist_EVALUATE StrToPlistEvaluate(std::string value);
+    std::string PlistEvaluateToStr(plist_EVALUATE data) const;
+    plist_EVALUATE StrToPlistEvaluate(std::string value) const;
 
-    std::string PointingXlinkactuateToStr(pointing_XLINKACTUATE data);
-    pointing_XLINKACTUATE StrToPointingXlinkactuate(std::string value);
+    std::string PointingXlinkactuateToStr(pointing_XLINKACTUATE data) const;
+    pointing_XLINKACTUATE StrToPointingXlinkactuate(std::string value) const;
 
-    std::string PointingXlinkshowToStr(pointing_XLINKSHOW data);
-    pointing_XLINKSHOW StrToPointingXlinkshow(std::string value);
+    std::string PointingXlinkshowToStr(pointing_XLINKSHOW data) const;
+    pointing_XLINKSHOW StrToPointingXlinkshow(std::string value) const;
 
-    std::string RegularmethodMethodToStr(regularmethod_METHOD data);
-    regularmethod_METHOD StrToRegularmethodMethod(std::string value);
+    std::string RegularmethodMethodToStr(regularmethod_METHOD data) const;
+    regularmethod_METHOD StrToRegularmethodMethod(std::string value) const;
 
-    std::string RehearsalRehencloseToStr(rehearsal_REHENCLOSE data);
-    rehearsal_REHENCLOSE StrToRehearsalRehenclose(std::string value);
+    std::string RehearsalRehencloseToStr(rehearsal_REHENCLOSE data) const;
+    rehearsal_REHENCLOSE StrToRehearsalRehenclose(std::string value) const;
 
-    std::string SbVisFormToStr(sbVis_FORM data);
-    sbVis_FORM StrToSbVisForm(std::string value);
+    std::string SbVisFormToStr(sbVis_FORM data) const;
+    sbVis_FORM StrToSbVisForm(std::string value) const;
 
-    std::string StaffgroupingsymSymbolToStr(staffgroupingsym_SYMBOL data);
-    staffgroupingsym_SYMBOL StrToStaffgroupingsymSymbol(std::string value);
+    std::string StaffgroupingsymSymbolToStr(staffgroupingsym_SYMBOL data) const;
+    staffgroupingsym_SYMBOL StrToStaffgroupingsymSymbol(std::string value) const;
 
-    std::string SylLogConToStr(sylLog_CON data);
-    sylLog_CON StrToSylLogCon(std::string value);
+    std::string SylLogConToStr(sylLog_CON data) const;
+    sylLog_CON StrToSylLogCon(std::string value) const;
 
-    std::string SylLogWordposToStr(sylLog_WORDPOS data);
-    sylLog_WORDPOS StrToSylLogWordpos(std::string value);
+    std::string SylLogWordposToStr(sylLog_WORDPOS data) const;
+    sylLog_WORDPOS StrToSylLogWordpos(std::string value) const;
 
-    std::string TupletVisNumformatToStr(tupletVis_NUMFORMAT data);
-    tupletVis_NUMFORMAT StrToTupletVisNumformat(std::string value);
+    std::string TupletVisNumformatToStr(tupletVis_NUMFORMAT data) const;
+    tupletVis_NUMFORMAT StrToTupletVisNumformat(std::string value) const;
 
-    std::string TurnLogFormToStr(turnLog_FORM data);
-    turnLog_FORM StrToTurnLogForm(std::string value);
+    std::string TurnLogFormToStr(turnLog_FORM data) const;
+    turnLog_FORM StrToTurnLogForm(std::string value) const;
 
-    std::string WhitespaceXmlspaceToStr(whitespace_XMLSPACE data);
-    whitespace_XMLSPACE StrToWhitespaceXmlspace(std::string value);
+    std::string WhitespaceXmlspaceToStr(whitespace_XMLSPACE data) const;
+    whitespace_XMLSPACE StrToWhitespaceXmlspace(std::string value) const;
 };
 
 } // vrv namespace
diff --git a/libmei/atts_analysis.cpp b/libmei/atts_analysis.cpp
index a06e0d8782c..ff0bfd73f46 100644
--- a/libmei/atts_analysis.cpp
+++ b/libmei/atts_analysis.cpp
@@ -115,32 +115,32 @@ bool AttCommonAnl::WriteCommonAnl(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCommonAnl::HasCopyof()
+bool AttCommonAnl::HasCopyof() const
 {
     return (m_copyof != "");
 }
 
-bool AttCommonAnl::HasCorresp()
+bool AttCommonAnl::HasCorresp() const
 {
     return (m_corresp != "");
 }
 
-bool AttCommonAnl::HasNext()
+bool AttCommonAnl::HasNext() const
 {
     return (m_next != "");
 }
 
-bool AttCommonAnl::HasPrev()
+bool AttCommonAnl::HasPrev() const
 {
     return (m_prev != "");
 }
 
-bool AttCommonAnl::HasSameas()
+bool AttCommonAnl::HasSameas() const
 {
     return (m_sameas != "");
 }
 
-bool AttCommonAnl::HasSynch()
+bool AttCommonAnl::HasSynch() const
 {
     return (m_synch != "");
 }
@@ -186,7 +186,7 @@ bool AttHarmonicfunction::WriteHarmonicfunction(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHarmonicfunction::HasDeg()
+bool AttHarmonicfunction::HasDeg() const
 {
     return (m_deg != SCALEDEGREE_NONE);
 }
@@ -232,7 +232,7 @@ bool AttIntervalharmonic::WriteIntervalharmonic(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttIntervalharmonic::HasInth()
+bool AttIntervalharmonic::HasInth() const
 {
     return (m_inth != "");
 }
@@ -278,7 +278,7 @@ bool AttIntervallicdesc::WriteIntervallicdesc(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttIntervallicdesc::HasIntm()
+bool AttIntervallicdesc::HasIntm() const
 {
     return (m_intm != INTERVAL_AMOUNT_NONE);
 }
@@ -324,7 +324,7 @@ bool AttMelodicfunction::WriteMelodicfunction(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMelodicfunction::HasMfunc()
+bool AttMelodicfunction::HasMfunc() const
 {
     return (m_mfunc != MELODICFUNCTION_NONE);
 }
@@ -370,7 +370,7 @@ bool AttPitchclass::WritePitchclass(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPitchclass::HasPclass()
+bool AttPitchclass::HasPclass() const
 {
     return (m_pclass != PITCHCLASS_NONE);
 }
@@ -416,7 +416,7 @@ bool AttSolfa::WriteSolfa(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSolfa::HasPsolfa()
+bool AttSolfa::HasPsolfa() const
 {
     return (m_psolfa != "");
 }
@@ -505,10 +505,10 @@ bool Att::SetAnalysis(Object *element, std::string attrType, std::string attrVal
     return false;
 }
 
-void Att::GetAnalysis(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetAnalysis(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_COMMONANL)) {
-        AttCommonAnl *att = dynamic_cast<AttCommonAnl *>(element);
+        const AttCommonAnl *att = dynamic_cast<const AttCommonAnl *>(element);
         assert(att);
         if (att->HasCopyof()) {
             attributes->push_back(std::make_pair("copyof", att->StrToStr(att->GetCopyof())));
@@ -530,42 +530,42 @@ void Att::GetAnalysis(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_HARMONICFUNCTION)) {
-        AttHarmonicfunction *att = dynamic_cast<AttHarmonicfunction *>(element);
+        const AttHarmonicfunction *att = dynamic_cast<const AttHarmonicfunction *>(element);
         assert(att);
         if (att->HasDeg()) {
             attributes->push_back(std::make_pair("deg", att->ScaledegreeToStr(att->GetDeg())));
         }
     }
     if (element->HasAttClass(ATT_INTERVALHARMONIC)) {
-        AttIntervalharmonic *att = dynamic_cast<AttIntervalharmonic *>(element);
+        const AttIntervalharmonic *att = dynamic_cast<const AttIntervalharmonic *>(element);
         assert(att);
         if (att->HasInth()) {
             attributes->push_back(std::make_pair("inth", att->StrToStr(att->GetInth())));
         }
     }
     if (element->HasAttClass(ATT_INTERVALLICDESC)) {
-        AttIntervallicdesc *att = dynamic_cast<AttIntervallicdesc *>(element);
+        const AttIntervallicdesc *att = dynamic_cast<const AttIntervallicdesc *>(element);
         assert(att);
         if (att->HasIntm()) {
             attributes->push_back(std::make_pair("intm", att->IntervalAmountToStr(att->GetIntm())));
         }
     }
     if (element->HasAttClass(ATT_MELODICFUNCTION)) {
-        AttMelodicfunction *att = dynamic_cast<AttMelodicfunction *>(element);
+        const AttMelodicfunction *att = dynamic_cast<const AttMelodicfunction *>(element);
         assert(att);
         if (att->HasMfunc()) {
             attributes->push_back(std::make_pair("mfunc", att->MelodicfunctionToStr(att->GetMfunc())));
         }
     }
     if (element->HasAttClass(ATT_PITCHCLASS)) {
-        AttPitchclass *att = dynamic_cast<AttPitchclass *>(element);
+        const AttPitchclass *att = dynamic_cast<const AttPitchclass *>(element);
         assert(att);
         if (att->HasPclass()) {
             attributes->push_back(std::make_pair("pclass", att->PitchclassToStr(att->GetPclass())));
         }
     }
     if (element->HasAttClass(ATT_SOLFA)) {
-        AttSolfa *att = dynamic_cast<AttSolfa *>(element);
+        const AttSolfa *att = dynamic_cast<const AttSolfa *>(element);
         assert(att);
         if (att->HasPsolfa()) {
             attributes->push_back(std::make_pair("psolfa", att->StrToStr(att->GetPsolfa())));
diff --git a/libmei/atts_analysis.h b/libmei/atts_analysis.h
index bc56c54c299..b34e62753b0 100644
--- a/libmei/atts_analysis.h
+++ b/libmei/atts_analysis.h
@@ -51,27 +51,27 @@ class AttCommonAnl : public Att {
     ///@{
     void SetCopyof(std::string copyof_) { m_copyof = copyof_; };
     std::string GetCopyof() const { return m_copyof; };
-    bool HasCopyof();
+    bool HasCopyof() const;
     //
     void SetCorresp(std::string corresp_) { m_corresp = corresp_; };
     std::string GetCorresp() const { return m_corresp; };
-    bool HasCorresp();
+    bool HasCorresp() const;
     //
     void SetNext(std::string next_) { m_next = next_; };
     std::string GetNext() const { return m_next; };
-    bool HasNext();
+    bool HasNext() const;
     //
     void SetPrev(std::string prev_) { m_prev = prev_; };
     std::string GetPrev() const { return m_prev; };
-    bool HasPrev();
+    bool HasPrev() const;
     //
     void SetSameas(std::string sameas_) { m_sameas = sameas_; };
     std::string GetSameas() const { return m_sameas; };
-    bool HasSameas();
+    bool HasSameas() const;
     //
     void SetSynch(std::string synch_) { m_synch = synch_; };
     std::string GetSynch() const { return m_synch; };
-    bool HasSynch();
+    bool HasSynch() const;
     ///@}
 
 private:
@@ -123,7 +123,7 @@ class AttHarmonicfunction : public Att {
     ///@{
     void SetDeg(data_SCALEDEGREE deg_) { m_deg = deg_; };
     data_SCALEDEGREE GetDeg() const { return m_deg; };
-    bool HasDeg();
+    bool HasDeg() const;
     ///@}
 
 private:
@@ -165,7 +165,7 @@ class AttIntervalharmonic : public Att {
     ///@{
     void SetInth(std::string inth_) { m_inth = inth_; };
     std::string GetInth() const { return m_inth; };
-    bool HasInth();
+    bool HasInth() const;
     ///@}
 
 private:
@@ -204,7 +204,7 @@ class AttIntervallicdesc : public Att {
     ///@{
     void SetIntm(data_INTERVAL_AMOUNT intm_) { m_intm = intm_; };
     data_INTERVAL_AMOUNT GetIntm() const { return m_intm; };
-    bool HasIntm();
+    bool HasIntm() const;
     ///@}
 
 private:
@@ -245,7 +245,7 @@ class AttMelodicfunction : public Att {
     ///@{
     void SetMfunc(data_MELODICFUNCTION mfunc_) { m_mfunc = mfunc_; };
     data_MELODICFUNCTION GetMfunc() const { return m_mfunc; };
-    bool HasMfunc();
+    bool HasMfunc() const;
     ///@}
 
 private:
@@ -281,7 +281,7 @@ class AttPitchclass : public Att {
     ///@{
     void SetPclass(data_PITCHCLASS pclass_) { m_pclass = pclass_; };
     data_PITCHCLASS GetPclass() const { return m_pclass; };
-    bool HasPclass();
+    bool HasPclass() const;
     ///@}
 
 private:
@@ -317,7 +317,7 @@ class AttSolfa : public Att {
     ///@{
     void SetPsolfa(std::string psolfa_) { m_psolfa = psolfa_; };
     std::string GetPsolfa() const { return m_psolfa; };
-    bool HasPsolfa();
+    bool HasPsolfa() const;
     ///@}
 
 private:
diff --git a/libmei/atts_cmn.cpp b/libmei/atts_cmn.cpp
index 2ef4e06ba18..4202a9e3445 100644
--- a/libmei/atts_cmn.cpp
+++ b/libmei/atts_cmn.cpp
@@ -65,7 +65,7 @@ bool AttArpegLog::WriteArpegLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttArpegLog::HasOrder()
+bool AttArpegLog::HasOrder() const
 {
     return (m_order != arpegLog_ORDER_NONE);
 }
@@ -111,7 +111,7 @@ bool AttArpegVis::WriteArpegVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttArpegVis::HasArrow()
+bool AttArpegVis::HasArrow() const
 {
     return (m_arrow != BOOLEAN_NONE);
 }
@@ -157,7 +157,7 @@ bool AttBTremLog::WriteBTremLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBTremLog::HasForm()
+bool AttBTremLog::HasForm() const
 {
     return (m_form != bTremLog_FORM_NONE);
 }
@@ -203,7 +203,7 @@ bool AttBeamed::WriteBeamed(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeamed::HasBeam()
+bool AttBeamed::HasBeam() const
 {
     return (m_beam != "");
 }
@@ -249,7 +249,7 @@ bool AttBeamedwith::WriteBeamedwith(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeamedwith::HasBeamWith()
+bool AttBeamedwith::HasBeamWith() const
 {
     return (m_beamWith != OTHERSTAFF_NONE);
 }
@@ -305,12 +305,12 @@ bool AttBeamingLog::WriteBeamingLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeamingLog::HasBeamGroup()
+bool AttBeamingLog::HasBeamGroup() const
 {
     return (m_beamGroup != "");
 }
 
-bool AttBeamingLog::HasBeamRests()
+bool AttBeamingLog::HasBeamRests() const
 {
     return (m_beamRests != BOOLEAN_NONE);
 }
@@ -366,12 +366,12 @@ bool AttBeamrend::WriteBeamrend(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeamrend::HasForm()
+bool AttBeamrend::HasForm() const
 {
     return (m_form != beamrend_FORM_NONE);
 }
 
-bool AttBeamrend::HasSlope()
+bool AttBeamrend::HasSlope() const
 {
     return (m_slope != 0.0);
 }
@@ -417,7 +417,7 @@ bool AttBeamsecondary::WriteBeamsecondary(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeamsecondary::HasBreaksec()
+bool AttBeamsecondary::HasBreaksec() const
 {
     return (m_breaksec != 0);
 }
@@ -463,7 +463,7 @@ bool AttBeatRptLog::WriteBeatRptLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeatRptLog::HasBeatDef()
+bool AttBeatRptLog::HasBeatDef() const
 {
     return (m_beatDef != DURATION_NONE);
 }
@@ -509,7 +509,7 @@ bool AttBeatRptVis::WriteBeatRptVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeatRptVis::HasForm()
+bool AttBeatRptVis::HasForm() const
 {
     return (m_form != BEATRPT_REND_NONE);
 }
@@ -555,7 +555,7 @@ bool AttBendGes::WriteBendGes(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBendGes::HasAmount()
+bool AttBendGes::HasAmount() const
 {
     return (m_amount != "");
 }
@@ -601,7 +601,7 @@ bool AttCutout::WriteCutout(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCutout::HasCutout()
+bool AttCutout::HasCutout() const
 {
     return (m_cutout != cutout_CUTOUT_NONE);
 }
@@ -647,7 +647,7 @@ bool AttExpandable::WriteExpandable(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttExpandable::HasExpand()
+bool AttExpandable::HasExpand() const
 {
     return (m_expand != BOOLEAN_NONE);
 }
@@ -693,7 +693,7 @@ bool AttFTremLog::WriteFTremLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttFTremLog::HasForm()
+bool AttFTremLog::HasForm() const
 {
     return (m_form != fTremLog_FORM_NONE);
 }
@@ -749,12 +749,12 @@ bool AttFermataVis::WriteFermataVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttFermataVis::HasForm()
+bool AttFermataVis::HasForm() const
 {
     return (m_form != fermataVis_FORM_NONE);
 }
 
-bool AttFermataVis::HasShape()
+bool AttFermataVis::HasShape() const
 {
     return (m_shape != fermataVis_SHAPE_NONE);
 }
@@ -810,12 +810,12 @@ bool AttGraced::WriteGraced(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttGraced::HasGrace()
+bool AttGraced::HasGrace() const
 {
     return (m_grace != GRACE_NONE);
 }
 
-bool AttGraced::HasGraceTime()
+bool AttGraced::HasGraceTime() const
 {
     return (m_graceTime != 0);
 }
@@ -871,12 +871,12 @@ bool AttHairpinLog::WriteHairpinLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHairpinLog::HasForm()
+bool AttHairpinLog::HasForm() const
 {
     return (m_form != hairpinLog_FORM_NONE);
 }
 
-bool AttHairpinLog::HasNiente()
+bool AttHairpinLog::HasNiente() const
 {
     return (m_niente != BOOLEAN_NONE);
 }
@@ -922,7 +922,7 @@ bool AttHairpinVis::WriteHairpinVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHairpinVis::HasOpening()
+bool AttHairpinVis::HasOpening() const
 {
     return (m_opening != "");
 }
@@ -1028,37 +1028,37 @@ bool AttHarpPedalLog::WriteHarpPedalLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHarpPedalLog::HasC()
+bool AttHarpPedalLog::HasC() const
 {
     return (m_c != harpPedalLog_C_NONE);
 }
 
-bool AttHarpPedalLog::HasD()
+bool AttHarpPedalLog::HasD() const
 {
     return (m_d != harpPedalLog_D_NONE);
 }
 
-bool AttHarpPedalLog::HasE()
+bool AttHarpPedalLog::HasE() const
 {
     return (m_e != harpPedalLog_E_NONE);
 }
 
-bool AttHarpPedalLog::HasF()
+bool AttHarpPedalLog::HasF() const
 {
     return (m_f != harpPedalLog_F_NONE);
 }
 
-bool AttHarpPedalLog::HasG()
+bool AttHarpPedalLog::HasG() const
 {
     return (m_g != harpPedalLog_G_NONE);
 }
 
-bool AttHarpPedalLog::HasA()
+bool AttHarpPedalLog::HasA() const
 {
     return (m_a != harpPedalLog_A_NONE);
 }
 
-bool AttHarpPedalLog::HasB()
+bool AttHarpPedalLog::HasB() const
 {
     return (m_b != harpPedalLog_B_NONE);
 }
@@ -1104,7 +1104,7 @@ bool AttLvpresent::WriteLvpresent(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLvpresent::HasLv()
+bool AttLvpresent::HasLv() const
 {
     return (m_lv != BOOLEAN_NONE);
 }
@@ -1150,7 +1150,7 @@ bool AttMultiRestVis::WriteMultiRestVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMultiRestVis::HasBlock()
+bool AttMultiRestVis::HasBlock() const
 {
     return (m_block != BOOLEAN_NONE);
 }
@@ -1196,7 +1196,7 @@ bool AttNoteGesCmn::WriteNoteGesCmn(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNoteGesCmn::HasGliss()
+bool AttNoteGesCmn::HasGliss() const
 {
     return (m_gliss != GLISSANDO_NONE);
 }
@@ -1242,7 +1242,7 @@ bool AttNumbered::WriteNumbered(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNumbered::HasNum()
+bool AttNumbered::HasNum() const
 {
     return (m_num != 0);
 }
@@ -1298,12 +1298,12 @@ bool AttNumberplacement::WriteNumberplacement(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNumberplacement::HasNumPlace()
+bool AttNumberplacement::HasNumPlace() const
 {
     return (m_numPlace != PLACE_NONE);
 }
 
-bool AttNumberplacement::HasNumVisible()
+bool AttNumberplacement::HasNumVisible() const
 {
     return (m_numVisible != BOOLEAN_NONE);
 }
@@ -1349,7 +1349,7 @@ bool AttOctaveLog::WriteOctaveLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOctaveLog::HasColl()
+bool AttOctaveLog::HasColl() const
 {
     return (m_coll != octaveLog_COLL_NONE);
 }
@@ -1395,7 +1395,7 @@ bool AttPedalLog::WritePedalLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPedalLog::HasDir()
+bool AttPedalLog::HasDir() const
 {
     return (m_dir != pedalLog_DIR_NONE);
 }
@@ -1441,7 +1441,7 @@ bool AttPedalVis::WritePedalVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPedalVis::HasForm()
+bool AttPedalVis::HasForm() const
 {
     return (m_form != pedalVis_FORM_NONE);
 }
@@ -1487,7 +1487,7 @@ bool AttPianopedals::WritePianopedals(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPianopedals::HasPedalStyle()
+bool AttPianopedals::HasPedalStyle() const
 {
     return (m_pedalStyle != pianopedals_PEDALSTYLE_NONE);
 }
@@ -1533,7 +1533,7 @@ bool AttRehearsal::WriteRehearsal(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttRehearsal::HasRehEnclose()
+bool AttRehearsal::HasRehEnclose() const
 {
     return (m_rehEnclose != rehearsal_REHENCLOSE_NONE);
 }
@@ -1579,7 +1579,7 @@ bool AttScoreDefVisCmn::WriteScoreDefVisCmn(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttScoreDefVisCmn::HasGridShow()
+bool AttScoreDefVisCmn::HasGridShow() const
 {
     return (m_gridShow != BOOLEAN_NONE);
 }
@@ -1625,7 +1625,7 @@ bool AttSlurrend::WriteSlurrend(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSlurrend::HasSlurRend()
+bool AttSlurrend::HasSlurRend() const
 {
     return (m_slurRend != CURVERENDITION_NONE);
 }
@@ -1671,7 +1671,7 @@ bool AttStemsCmn::WriteStemsCmn(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStemsCmn::HasStemWith()
+bool AttStemsCmn::HasStemWith() const
 {
     return (m_stemWith != OTHERSTAFF_NONE);
 }
@@ -1717,7 +1717,7 @@ bool AttTierend::WriteTierend(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTierend::HasTieRend()
+bool AttTierend::HasTieRend() const
 {
     return (m_tieRend != CURVERENDITION_NONE);
 }
@@ -1763,7 +1763,7 @@ bool AttTremmeasured::WriteTremmeasured(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTremmeasured::HasMeasperf()
+bool AttTremmeasured::HasMeasperf() const
 {
     return (m_measperf != DURATION_NONE);
 }
@@ -1839,22 +1839,22 @@ bool AttTupletVis::WriteTupletVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTupletVis::HasBracketPlace()
+bool AttTupletVis::HasBracketPlace() const
 {
     return (m_bracketPlace != PLACE_NONE);
 }
 
-bool AttTupletVis::HasBracketVisible()
+bool AttTupletVis::HasBracketVisible() const
 {
     return (m_bracketVisible != BOOLEAN_NONE);
 }
 
-bool AttTupletVis::HasDurVisible()
+bool AttTupletVis::HasDurVisible() const
 {
     return (m_durVisible != BOOLEAN_NONE);
 }
 
-bool AttTupletVis::HasNumFormat()
+bool AttTupletVis::HasNumFormat() const
 {
     return (m_numFormat != tupletVis_NUMFORMAT_NONE);
 }
@@ -2207,45 +2207,45 @@ bool Att::SetCmn(Object *element, std::string attrType, std::string attrValue)
     return false;
 }
 
-void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetCmn(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_ARPEGLOG)) {
-        AttArpegLog *att = dynamic_cast<AttArpegLog *>(element);
+        const AttArpegLog *att = dynamic_cast<const AttArpegLog *>(element);
         assert(att);
         if (att->HasOrder()) {
             attributes->push_back(std::make_pair("order", att->ArpegLogOrderToStr(att->GetOrder())));
         }
     }
     if (element->HasAttClass(ATT_ARPEGVIS)) {
-        AttArpegVis *att = dynamic_cast<AttArpegVis *>(element);
+        const AttArpegVis *att = dynamic_cast<const AttArpegVis *>(element);
         assert(att);
         if (att->HasArrow()) {
             attributes->push_back(std::make_pair("arrow", att->BooleanToStr(att->GetArrow())));
         }
     }
     if (element->HasAttClass(ATT_BTREMLOG)) {
-        AttBTremLog *att = dynamic_cast<AttBTremLog *>(element);
+        const AttBTremLog *att = dynamic_cast<const AttBTremLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->BTremLogFormToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_BEAMED)) {
-        AttBeamed *att = dynamic_cast<AttBeamed *>(element);
+        const AttBeamed *att = dynamic_cast<const AttBeamed *>(element);
         assert(att);
         if (att->HasBeam()) {
             attributes->push_back(std::make_pair("beam", att->StrToStr(att->GetBeam())));
         }
     }
     if (element->HasAttClass(ATT_BEAMEDWITH)) {
-        AttBeamedwith *att = dynamic_cast<AttBeamedwith *>(element);
+        const AttBeamedwith *att = dynamic_cast<const AttBeamedwith *>(element);
         assert(att);
         if (att->HasBeamWith()) {
             attributes->push_back(std::make_pair("beam.with", att->OtherstaffToStr(att->GetBeamWith())));
         }
     }
     if (element->HasAttClass(ATT_BEAMINGLOG)) {
-        AttBeamingLog *att = dynamic_cast<AttBeamingLog *>(element);
+        const AttBeamingLog *att = dynamic_cast<const AttBeamingLog *>(element);
         assert(att);
         if (att->HasBeamGroup()) {
             attributes->push_back(std::make_pair("beam.group", att->StrToStr(att->GetBeamGroup())));
@@ -2255,7 +2255,7 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_BEAMREND)) {
-        AttBeamrend *att = dynamic_cast<AttBeamrend *>(element);
+        const AttBeamrend *att = dynamic_cast<const AttBeamrend *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->BeamrendFormToStr(att->GetForm())));
@@ -2265,56 +2265,56 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_BEAMSECONDARY)) {
-        AttBeamsecondary *att = dynamic_cast<AttBeamsecondary *>(element);
+        const AttBeamsecondary *att = dynamic_cast<const AttBeamsecondary *>(element);
         assert(att);
         if (att->HasBreaksec()) {
             attributes->push_back(std::make_pair("breaksec", att->IntToStr(att->GetBreaksec())));
         }
     }
     if (element->HasAttClass(ATT_BEATRPTLOG)) {
-        AttBeatRptLog *att = dynamic_cast<AttBeatRptLog *>(element);
+        const AttBeatRptLog *att = dynamic_cast<const AttBeatRptLog *>(element);
         assert(att);
         if (att->HasBeatDef()) {
             attributes->push_back(std::make_pair("beatDef", att->DurationToStr(att->GetBeatDef())));
         }
     }
     if (element->HasAttClass(ATT_BEATRPTVIS)) {
-        AttBeatRptVis *att = dynamic_cast<AttBeatRptVis *>(element);
+        const AttBeatRptVis *att = dynamic_cast<const AttBeatRptVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->BeatrptRendToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_BENDGES)) {
-        AttBendGes *att = dynamic_cast<AttBendGes *>(element);
+        const AttBendGes *att = dynamic_cast<const AttBendGes *>(element);
         assert(att);
         if (att->HasAmount()) {
             attributes->push_back(std::make_pair("amount", att->StrToStr(att->GetAmount())));
         }
     }
     if (element->HasAttClass(ATT_CUTOUT)) {
-        AttCutout *att = dynamic_cast<AttCutout *>(element);
+        const AttCutout *att = dynamic_cast<const AttCutout *>(element);
         assert(att);
         if (att->HasCutout()) {
             attributes->push_back(std::make_pair("cutout", att->CutoutCutoutToStr(att->GetCutout())));
         }
     }
     if (element->HasAttClass(ATT_EXPANDABLE)) {
-        AttExpandable *att = dynamic_cast<AttExpandable *>(element);
+        const AttExpandable *att = dynamic_cast<const AttExpandable *>(element);
         assert(att);
         if (att->HasExpand()) {
             attributes->push_back(std::make_pair("expand", att->BooleanToStr(att->GetExpand())));
         }
     }
     if (element->HasAttClass(ATT_FTREMLOG)) {
-        AttFTremLog *att = dynamic_cast<AttFTremLog *>(element);
+        const AttFTremLog *att = dynamic_cast<const AttFTremLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->FTremLogFormToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_FERMATAVIS)) {
-        AttFermataVis *att = dynamic_cast<AttFermataVis *>(element);
+        const AttFermataVis *att = dynamic_cast<const AttFermataVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->FermataVisFormToStr(att->GetForm())));
@@ -2324,7 +2324,7 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_GRACED)) {
-        AttGraced *att = dynamic_cast<AttGraced *>(element);
+        const AttGraced *att = dynamic_cast<const AttGraced *>(element);
         assert(att);
         if (att->HasGrace()) {
             attributes->push_back(std::make_pair("grace", att->GraceToStr(att->GetGrace())));
@@ -2334,7 +2334,7 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_HAIRPINLOG)) {
-        AttHairpinLog *att = dynamic_cast<AttHairpinLog *>(element);
+        const AttHairpinLog *att = dynamic_cast<const AttHairpinLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->HairpinLogFormToStr(att->GetForm())));
@@ -2344,14 +2344,14 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_HAIRPINVIS)) {
-        AttHairpinVis *att = dynamic_cast<AttHairpinVis *>(element);
+        const AttHairpinVis *att = dynamic_cast<const AttHairpinVis *>(element);
         assert(att);
         if (att->HasOpening()) {
             attributes->push_back(std::make_pair("opening", att->StrToStr(att->GetOpening())));
         }
     }
     if (element->HasAttClass(ATT_HARPPEDALLOG)) {
-        AttHarpPedalLog *att = dynamic_cast<AttHarpPedalLog *>(element);
+        const AttHarpPedalLog *att = dynamic_cast<const AttHarpPedalLog *>(element);
         assert(att);
         if (att->HasC()) {
             attributes->push_back(std::make_pair("c", att->HarpPedalLogCToStr(att->GetC())));
@@ -2376,35 +2376,35 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_LVPRESENT)) {
-        AttLvpresent *att = dynamic_cast<AttLvpresent *>(element);
+        const AttLvpresent *att = dynamic_cast<const AttLvpresent *>(element);
         assert(att);
         if (att->HasLv()) {
             attributes->push_back(std::make_pair("lv", att->BooleanToStr(att->GetLv())));
         }
     }
     if (element->HasAttClass(ATT_MULTIRESTVIS)) {
-        AttMultiRestVis *att = dynamic_cast<AttMultiRestVis *>(element);
+        const AttMultiRestVis *att = dynamic_cast<const AttMultiRestVis *>(element);
         assert(att);
         if (att->HasBlock()) {
             attributes->push_back(std::make_pair("block", att->BooleanToStr(att->GetBlock())));
         }
     }
     if (element->HasAttClass(ATT_NOTEGESCMN)) {
-        AttNoteGesCmn *att = dynamic_cast<AttNoteGesCmn *>(element);
+        const AttNoteGesCmn *att = dynamic_cast<const AttNoteGesCmn *>(element);
         assert(att);
         if (att->HasGliss()) {
             attributes->push_back(std::make_pair("gliss", att->GlissandoToStr(att->GetGliss())));
         }
     }
     if (element->HasAttClass(ATT_NUMBERED)) {
-        AttNumbered *att = dynamic_cast<AttNumbered *>(element);
+        const AttNumbered *att = dynamic_cast<const AttNumbered *>(element);
         assert(att);
         if (att->HasNum()) {
             attributes->push_back(std::make_pair("num", att->IntToStr(att->GetNum())));
         }
     }
     if (element->HasAttClass(ATT_NUMBERPLACEMENT)) {
-        AttNumberplacement *att = dynamic_cast<AttNumberplacement *>(element);
+        const AttNumberplacement *att = dynamic_cast<const AttNumberplacement *>(element);
         assert(att);
         if (att->HasNumPlace()) {
             attributes->push_back(std::make_pair("num.place", att->PlaceToStr(att->GetNumPlace())));
@@ -2414,77 +2414,77 @@ void Att::GetCmn(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_OCTAVELOG)) {
-        AttOctaveLog *att = dynamic_cast<AttOctaveLog *>(element);
+        const AttOctaveLog *att = dynamic_cast<const AttOctaveLog *>(element);
         assert(att);
         if (att->HasColl()) {
             attributes->push_back(std::make_pair("coll", att->OctaveLogCollToStr(att->GetColl())));
         }
     }
     if (element->HasAttClass(ATT_PEDALLOG)) {
-        AttPedalLog *att = dynamic_cast<AttPedalLog *>(element);
+        const AttPedalLog *att = dynamic_cast<const AttPedalLog *>(element);
         assert(att);
         if (att->HasDir()) {
             attributes->push_back(std::make_pair("dir", att->PedalLogDirToStr(att->GetDir())));
         }
     }
     if (element->HasAttClass(ATT_PEDALVIS)) {
-        AttPedalVis *att = dynamic_cast<AttPedalVis *>(element);
+        const AttPedalVis *att = dynamic_cast<const AttPedalVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->PedalVisFormToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_PIANOPEDALS)) {
-        AttPianopedals *att = dynamic_cast<AttPianopedals *>(element);
+        const AttPianopedals *att = dynamic_cast<const AttPianopedals *>(element);
         assert(att);
         if (att->HasPedalStyle()) {
             attributes->push_back(std::make_pair("pedal.style", att->PianopedalsPedalstyleToStr(att->GetPedalStyle())));
         }
     }
     if (element->HasAttClass(ATT_REHEARSAL)) {
-        AttRehearsal *att = dynamic_cast<AttRehearsal *>(element);
+        const AttRehearsal *att = dynamic_cast<const AttRehearsal *>(element);
         assert(att);
         if (att->HasRehEnclose()) {
             attributes->push_back(std::make_pair("reh.enclose", att->RehearsalRehencloseToStr(att->GetRehEnclose())));
         }
     }
     if (element->HasAttClass(ATT_SCOREDEFVISCMN)) {
-        AttScoreDefVisCmn *att = dynamic_cast<AttScoreDefVisCmn *>(element);
+        const AttScoreDefVisCmn *att = dynamic_cast<const AttScoreDefVisCmn *>(element);
         assert(att);
         if (att->HasGridShow()) {
             attributes->push_back(std::make_pair("grid.show", att->BooleanToStr(att->GetGridShow())));
         }
     }
     if (element->HasAttClass(ATT_SLURREND)) {
-        AttSlurrend *att = dynamic_cast<AttSlurrend *>(element);
+        const AttSlurrend *att = dynamic_cast<const AttSlurrend *>(element);
         assert(att);
         if (att->HasSlurRend()) {
             attributes->push_back(std::make_pair("slur.rend", att->CurverenditionToStr(att->GetSlurRend())));
         }
     }
     if (element->HasAttClass(ATT_STEMSCMN)) {
-        AttStemsCmn *att = dynamic_cast<AttStemsCmn *>(element);
+        const AttStemsCmn *att = dynamic_cast<const AttStemsCmn *>(element);
         assert(att);
         if (att->HasStemWith()) {
             attributes->push_back(std::make_pair("stem.with", att->OtherstaffToStr(att->GetStemWith())));
         }
     }
     if (element->HasAttClass(ATT_TIEREND)) {
-        AttTierend *att = dynamic_cast<AttTierend *>(element);
+        const AttTierend *att = dynamic_cast<const AttTierend *>(element);
         assert(att);
         if (att->HasTieRend()) {
             attributes->push_back(std::make_pair("tie.rend", att->CurverenditionToStr(att->GetTieRend())));
         }
     }
     if (element->HasAttClass(ATT_TREMMEASURED)) {
-        AttTremmeasured *att = dynamic_cast<AttTremmeasured *>(element);
+        const AttTremmeasured *att = dynamic_cast<const AttTremmeasured *>(element);
         assert(att);
         if (att->HasMeasperf()) {
             attributes->push_back(std::make_pair("measperf", att->DurationToStr(att->GetMeasperf())));
         }
     }
     if (element->HasAttClass(ATT_TUPLETVIS)) {
-        AttTupletVis *att = dynamic_cast<AttTupletVis *>(element);
+        const AttTupletVis *att = dynamic_cast<const AttTupletVis *>(element);
         assert(att);
         if (att->HasBracketPlace()) {
             attributes->push_back(std::make_pair("bracket.place", att->PlaceToStr(att->GetBracketPlace())));
diff --git a/libmei/atts_cmn.h b/libmei/atts_cmn.h
index f0170532301..c898d9ffece 100644
--- a/libmei/atts_cmn.h
+++ b/libmei/atts_cmn.h
@@ -51,7 +51,7 @@ class AttArpegLog : public Att {
     ///@{
     void SetOrder(arpegLog_ORDER order_) { m_order = order_; };
     arpegLog_ORDER GetOrder() const { return m_order; };
-    bool HasOrder();
+    bool HasOrder() const;
     ///@}
 
 private:
@@ -87,7 +87,7 @@ class AttArpegVis : public Att {
     ///@{
     void SetArrow(data_BOOLEAN arrow_) { m_arrow = arrow_; };
     data_BOOLEAN GetArrow() const { return m_arrow; };
-    bool HasArrow();
+    bool HasArrow() const;
     ///@}
 
 private:
@@ -123,7 +123,7 @@ class AttBTremLog : public Att {
     ///@{
     void SetForm(bTremLog_FORM form_) { m_form = form_; };
     bTremLog_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -159,7 +159,7 @@ class AttBeamed : public Att {
     ///@{
     void SetBeam(std::string beam_) { m_beam = beam_; };
     std::string GetBeam() const { return m_beam; };
-    bool HasBeam();
+    bool HasBeam() const;
     ///@}
 
 private:
@@ -195,7 +195,7 @@ class AttBeamedwith : public Att {
     ///@{
     void SetBeamWith(data_OTHERSTAFF beamWith_) { m_beamWith = beamWith_; };
     data_OTHERSTAFF GetBeamWith() const { return m_beamWith; };
-    bool HasBeamWith();
+    bool HasBeamWith() const;
     ///@}
 
 private:
@@ -235,11 +235,11 @@ class AttBeamingLog : public Att {
     ///@{
     void SetBeamGroup(std::string beamGroup_) { m_beamGroup = beamGroup_; };
     std::string GetBeamGroup() const { return m_beamGroup; };
-    bool HasBeamGroup();
+    bool HasBeamGroup() const;
     //
     void SetBeamRests(data_BOOLEAN beamRests_) { m_beamRests = beamRests_; };
     data_BOOLEAN GetBeamRests() const { return m_beamRests; };
-    bool HasBeamRests();
+    bool HasBeamRests() const;
     ///@}
 
 private:
@@ -283,11 +283,11 @@ class AttBeamrend : public Att {
     ///@{
     void SetForm(beamrend_FORM form_) { m_form = form_; };
     beamrend_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetSlope(double slope_) { m_slope = slope_; };
     double GetSlope() const { return m_slope; };
-    bool HasSlope();
+    bool HasSlope() const;
     ///@}
 
 private:
@@ -325,7 +325,7 @@ class AttBeamsecondary : public Att {
     ///@{
     void SetBreaksec(int breaksec_) { m_breaksec = breaksec_; };
     int GetBreaksec() const { return m_breaksec; };
-    bool HasBreaksec();
+    bool HasBreaksec() const;
     ///@}
 
 private:
@@ -366,7 +366,7 @@ class AttBeatRptLog : public Att {
     ///@{
     void SetBeatDef(data_DURATION beatDef_) { m_beatDef = beatDef_; };
     data_DURATION GetBeatDef() const { return m_beatDef; };
-    bool HasBeatDef();
+    bool HasBeatDef() const;
     ///@}
 
 private:
@@ -402,7 +402,7 @@ class AttBeatRptVis : public Att {
     ///@{
     void SetForm(data_BEATRPT_REND form_) { m_form = form_; };
     data_BEATRPT_REND GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -438,7 +438,7 @@ class AttBendGes : public Att {
     ///@{
     void SetAmount(std::string amount_) { m_amount = amount_; };
     std::string GetAmount() const { return m_amount; };
-    bool HasAmount();
+    bool HasAmount() const;
     ///@}
 
 private:
@@ -478,7 +478,7 @@ class AttCutout : public Att {
     ///@{
     void SetCutout(cutout_CUTOUT cutout_) { m_cutout = cutout_; };
     cutout_CUTOUT GetCutout() const { return m_cutout; };
-    bool HasCutout();
+    bool HasCutout() const;
     ///@}
 
 private:
@@ -514,7 +514,7 @@ class AttExpandable : public Att {
     ///@{
     void SetExpand(data_BOOLEAN expand_) { m_expand = expand_; };
     data_BOOLEAN GetExpand() const { return m_expand; };
-    bool HasExpand();
+    bool HasExpand() const;
     ///@}
 
 private:
@@ -555,7 +555,7 @@ class AttFTremLog : public Att {
     ///@{
     void SetForm(fTremLog_FORM form_) { m_form = form_; };
     fTremLog_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -591,11 +591,11 @@ class AttFermataVis : public Att {
     ///@{
     void SetForm(fermataVis_FORM form_) { m_form = form_; };
     fermataVis_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetShape(fermataVis_SHAPE shape_) { m_shape = shape_; };
     fermataVis_SHAPE GetShape() const { return m_shape; };
-    bool HasShape();
+    bool HasShape() const;
     ///@}
 
 private:
@@ -633,11 +633,11 @@ class AttGraced : public Att {
     ///@{
     void SetGrace(data_GRACE grace_) { m_grace = grace_; };
     data_GRACE GetGrace() const { return m_grace; };
-    bool HasGrace();
+    bool HasGrace() const;
     //
     void SetGraceTime(int graceTime_) { m_graceTime = graceTime_; };
     int GetGraceTime() const { return m_graceTime; };
-    bool HasGraceTime();
+    bool HasGraceTime() const;
     ///@}
 
 private:
@@ -678,11 +678,11 @@ class AttHairpinLog : public Att {
     ///@{
     void SetForm(hairpinLog_FORM form_) { m_form = form_; };
     hairpinLog_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetNiente(data_BOOLEAN niente_) { m_niente = niente_; };
     data_BOOLEAN GetNiente() const { return m_niente; };
-    bool HasNiente();
+    bool HasNiente() const;
     ///@}
 
 private:
@@ -724,7 +724,7 @@ class AttHairpinVis : public Att {
     ///@{
     void SetOpening(std::string opening_) { m_opening = opening_; };
     std::string GetOpening() const { return m_opening; };
-    bool HasOpening();
+    bool HasOpening() const;
     ///@}
 
 private:
@@ -763,31 +763,31 @@ class AttHarpPedalLog : public Att {
     ///@{
     void SetC(harpPedalLog_C c_) { m_c = c_; };
     harpPedalLog_C GetC() const { return m_c; };
-    bool HasC();
+    bool HasC() const;
     //
     void SetD(harpPedalLog_D d_) { m_d = d_; };
     harpPedalLog_D GetD() const { return m_d; };
-    bool HasD();
+    bool HasD() const;
     //
     void SetE(harpPedalLog_E e_) { m_e = e_; };
     harpPedalLog_E GetE() const { return m_e; };
-    bool HasE();
+    bool HasE() const;
     //
     void SetF(harpPedalLog_F f_) { m_f = f_; };
     harpPedalLog_F GetF() const { return m_f; };
-    bool HasF();
+    bool HasF() const;
     //
     void SetG(harpPedalLog_G g_) { m_g = g_; };
     harpPedalLog_G GetG() const { return m_g; };
-    bool HasG();
+    bool HasG() const;
     //
     void SetA(harpPedalLog_A a_) { m_a = a_; };
     harpPedalLog_A GetA() const { return m_a; };
-    bool HasA();
+    bool HasA() const;
     //
     void SetB(harpPedalLog_B b_) { m_b = b_; };
     harpPedalLog_B GetB() const { return m_b; };
-    bool HasB();
+    bool HasB() const;
     ///@}
 
 private:
@@ -835,7 +835,7 @@ class AttLvpresent : public Att {
     ///@{
     void SetLv(data_BOOLEAN lv_) { m_lv = lv_; };
     data_BOOLEAN GetLv() const { return m_lv; };
-    bool HasLv();
+    bool HasLv() const;
     ///@}
 
 private:
@@ -874,7 +874,7 @@ class AttMultiRestVis : public Att {
     ///@{
     void SetBlock(data_BOOLEAN block_) { m_block = block_; };
     data_BOOLEAN GetBlock() const { return m_block; };
-    bool HasBlock();
+    bool HasBlock() const;
     ///@}
 
 private:
@@ -914,7 +914,7 @@ class AttNoteGesCmn : public Att {
     ///@{
     void SetGliss(data_GLISSANDO gliss_) { m_gliss = gliss_; };
     data_GLISSANDO GetGliss() const { return m_gliss; };
-    bool HasGliss();
+    bool HasGliss() const;
     ///@}
 
 private:
@@ -950,7 +950,7 @@ class AttNumbered : public Att {
     ///@{
     void SetNum(int num_) { m_num = num_; };
     int GetNum() const { return m_num; };
-    bool HasNum();
+    bool HasNum() const;
     ///@}
 
 private:
@@ -989,11 +989,11 @@ class AttNumberplacement : public Att {
     ///@{
     void SetNumPlace(data_PLACE numPlace_) { m_numPlace = numPlace_; };
     data_PLACE GetNumPlace() const { return m_numPlace; };
-    bool HasNumPlace();
+    bool HasNumPlace() const;
     //
     void SetNumVisible(data_BOOLEAN numVisible_) { m_numVisible = numVisible_; };
     data_BOOLEAN GetNumVisible() const { return m_numVisible; };
-    bool HasNumVisible();
+    bool HasNumVisible() const;
     ///@}
 
 private:
@@ -1031,7 +1031,7 @@ class AttOctaveLog : public Att {
     ///@{
     void SetColl(octaveLog_COLL coll_) { m_coll = coll_; };
     octaveLog_COLL GetColl() const { return m_coll; };
-    bool HasColl();
+    bool HasColl() const;
     ///@}
 
 private:
@@ -1073,7 +1073,7 @@ class AttPedalLog : public Att {
     ///@{
     void SetDir(pedalLog_DIR dir_) { m_dir = dir_; };
     pedalLog_DIR GetDir() const { return m_dir; };
-    bool HasDir();
+    bool HasDir() const;
     ///@}
 
 private:
@@ -1109,7 +1109,7 @@ class AttPedalVis : public Att {
     ///@{
     void SetForm(pedalVis_FORM form_) { m_form = form_; };
     pedalVis_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -1145,7 +1145,7 @@ class AttPianopedals : public Att {
     ///@{
     void SetPedalStyle(pianopedals_PEDALSTYLE pedalStyle_) { m_pedalStyle = pedalStyle_; };
     pianopedals_PEDALSTYLE GetPedalStyle() const { return m_pedalStyle; };
-    bool HasPedalStyle();
+    bool HasPedalStyle() const;
     ///@}
 
 private:
@@ -1181,7 +1181,7 @@ class AttRehearsal : public Att {
     ///@{
     void SetRehEnclose(rehearsal_REHENCLOSE rehEnclose_) { m_rehEnclose = rehEnclose_; };
     rehearsal_REHENCLOSE GetRehEnclose() const { return m_rehEnclose; };
-    bool HasRehEnclose();
+    bool HasRehEnclose() const;
     ///@}
 
 private:
@@ -1217,7 +1217,7 @@ class AttScoreDefVisCmn : public Att {
     ///@{
     void SetGridShow(data_BOOLEAN gridShow_) { m_gridShow = gridShow_; };
     data_BOOLEAN GetGridShow() const { return m_gridShow; };
-    bool HasGridShow();
+    bool HasGridShow() const;
     ///@}
 
 private:
@@ -1253,7 +1253,7 @@ class AttSlurrend : public Att {
     ///@{
     void SetSlurRend(data_CURVERENDITION slurRend_) { m_slurRend = slurRend_; };
     data_CURVERENDITION GetSlurRend() const { return m_slurRend; };
-    bool HasSlurRend();
+    bool HasSlurRend() const;
     ///@}
 
 private:
@@ -1289,7 +1289,7 @@ class AttStemsCmn : public Att {
     ///@{
     void SetStemWith(data_OTHERSTAFF stemWith_) { m_stemWith = stemWith_; };
     data_OTHERSTAFF GetStemWith() const { return m_stemWith; };
-    bool HasStemWith();
+    bool HasStemWith() const;
     ///@}
 
 private:
@@ -1329,7 +1329,7 @@ class AttTierend : public Att {
     ///@{
     void SetTieRend(data_CURVERENDITION tieRend_) { m_tieRend = tieRend_; };
     data_CURVERENDITION GetTieRend() const { return m_tieRend; };
-    bool HasTieRend();
+    bool HasTieRend() const;
     ///@}
 
 private:
@@ -1365,7 +1365,7 @@ class AttTremmeasured : public Att {
     ///@{
     void SetMeasperf(data_DURATION measperf_) { m_measperf = measperf_; };
     data_DURATION GetMeasperf() const { return m_measperf; };
-    bool HasMeasperf();
+    bool HasMeasperf() const;
     ///@}
 
 private:
@@ -1401,19 +1401,19 @@ class AttTupletVis : public Att {
     ///@{
     void SetBracketPlace(data_PLACE bracketPlace_) { m_bracketPlace = bracketPlace_; };
     data_PLACE GetBracketPlace() const { return m_bracketPlace; };
-    bool HasBracketPlace();
+    bool HasBracketPlace() const;
     //
     void SetBracketVisible(data_BOOLEAN bracketVisible_) { m_bracketVisible = bracketVisible_; };
     data_BOOLEAN GetBracketVisible() const { return m_bracketVisible; };
-    bool HasBracketVisible();
+    bool HasBracketVisible() const;
     //
     void SetDurVisible(data_BOOLEAN durVisible_) { m_durVisible = durVisible_; };
     data_BOOLEAN GetDurVisible() const { return m_durVisible; };
-    bool HasDurVisible();
+    bool HasDurVisible() const;
     //
     void SetNumFormat(tupletVis_NUMFORMAT numFormat_) { m_numFormat = numFormat_; };
     tupletVis_NUMFORMAT GetNumFormat() const { return m_numFormat; };
-    bool HasNumFormat();
+    bool HasNumFormat() const;
     ///@}
 
 private:
diff --git a/libmei/atts_cmnornaments.cpp b/libmei/atts_cmnornaments.cpp
index 371e3ac4bd1..851217280b4 100644
--- a/libmei/atts_cmnornaments.cpp
+++ b/libmei/atts_cmnornaments.cpp
@@ -75,12 +75,12 @@ bool AttMordentLog::WriteMordentLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMordentLog::HasForm()
+bool AttMordentLog::HasForm() const
 {
     return (m_form != mordentLog_FORM_NONE);
 }
 
-bool AttMordentLog::HasLong()
+bool AttMordentLog::HasLong() const
 {
     return (m_long != BOOLEAN_NONE);
 }
@@ -126,7 +126,7 @@ bool AttOrnam::WriteOrnam(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOrnam::HasOrnam()
+bool AttOrnam::HasOrnam() const
 {
     return (m_ornam != ORNAM_cmn_NONE);
 }
@@ -182,12 +182,12 @@ bool AttOrnamentaccid::WriteOrnamentaccid(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOrnamentaccid::HasAccidupper()
+bool AttOrnamentaccid::HasAccidupper() const
 {
     return (m_accidupper != ACCIDENTAL_EXPLICIT_NONE);
 }
 
-bool AttOrnamentaccid::HasAccidlower()
+bool AttOrnamentaccid::HasAccidlower() const
 {
     return (m_accidlower != ACCIDENTAL_EXPLICIT_NONE);
 }
@@ -243,12 +243,12 @@ bool AttTurnLog::WriteTurnLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTurnLog::HasDelayed()
+bool AttTurnLog::HasDelayed() const
 {
     return (m_delayed != BOOLEAN_NONE);
 }
 
-bool AttTurnLog::HasForm()
+bool AttTurnLog::HasForm() const
 {
     return (m_form != turnLog_FORM_NONE);
 }
@@ -305,10 +305,10 @@ bool Att::SetCmnornaments(Object *element, std::string attrType, std::string att
     return false;
 }
 
-void Att::GetCmnornaments(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetCmnornaments(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_MORDENTLOG)) {
-        AttMordentLog *att = dynamic_cast<AttMordentLog *>(element);
+        const AttMordentLog *att = dynamic_cast<const AttMordentLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->MordentLogFormToStr(att->GetForm())));
@@ -318,14 +318,14 @@ void Att::GetCmnornaments(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_ORNAM)) {
-        AttOrnam *att = dynamic_cast<AttOrnam *>(element);
+        const AttOrnam *att = dynamic_cast<const AttOrnam *>(element);
         assert(att);
         if (att->HasOrnam()) {
             attributes->push_back(std::make_pair("ornam", att->OrnamCmnToStr(att->GetOrnam())));
         }
     }
     if (element->HasAttClass(ATT_ORNAMENTACCID)) {
-        AttOrnamentaccid *att = dynamic_cast<AttOrnamentaccid *>(element);
+        const AttOrnamentaccid *att = dynamic_cast<const AttOrnamentaccid *>(element);
         assert(att);
         if (att->HasAccidupper()) {
             attributes->push_back(std::make_pair("accidupper", att->AccidentalExplicitToStr(att->GetAccidupper())));
@@ -335,7 +335,7 @@ void Att::GetCmnornaments(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_TURNLOG)) {
-        AttTurnLog *att = dynamic_cast<AttTurnLog *>(element);
+        const AttTurnLog *att = dynamic_cast<const AttTurnLog *>(element);
         assert(att);
         if (att->HasDelayed()) {
             attributes->push_back(std::make_pair("delayed", att->BooleanToStr(att->GetDelayed())));
diff --git a/libmei/atts_cmnornaments.h b/libmei/atts_cmnornaments.h
index 825aac8a066..6e2cfb5ff97 100644
--- a/libmei/atts_cmnornaments.h
+++ b/libmei/atts_cmnornaments.h
@@ -51,11 +51,11 @@ class AttMordentLog : public Att {
     ///@{
     void SetForm(mordentLog_FORM form_) { m_form = form_; };
     mordentLog_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetLong(data_BOOLEAN long_) { m_long = long_; };
     data_BOOLEAN GetLong() const { return m_long; };
-    bool HasLong();
+    bool HasLong() const;
     ///@}
 
 private:
@@ -96,7 +96,7 @@ class AttOrnam : public Att {
     ///@{
     void SetOrnam(data_ORNAM_cmn ornam_) { m_ornam = ornam_; };
     data_ORNAM_cmn GetOrnam() const { return m_ornam; };
-    bool HasOrnam();
+    bool HasOrnam() const;
     ///@}
 
 private:
@@ -136,11 +136,11 @@ class AttOrnamentaccid : public Att {
     ///@{
     void SetAccidupper(data_ACCIDENTAL_EXPLICIT accidupper_) { m_accidupper = accidupper_; };
     data_ACCIDENTAL_EXPLICIT GetAccidupper() const { return m_accidupper; };
-    bool HasAccidupper();
+    bool HasAccidupper() const;
     //
     void SetAccidlower(data_ACCIDENTAL_EXPLICIT accidlower_) { m_accidlower = accidlower_; };
     data_ACCIDENTAL_EXPLICIT GetAccidlower() const { return m_accidlower; };
-    bool HasAccidlower();
+    bool HasAccidlower() const;
     ///@}
 
 private:
@@ -178,11 +178,11 @@ class AttTurnLog : public Att {
     ///@{
     void SetDelayed(data_BOOLEAN delayed_) { m_delayed = delayed_; };
     data_BOOLEAN GetDelayed() const { return m_delayed; };
-    bool HasDelayed();
+    bool HasDelayed() const;
     //
     void SetForm(turnLog_FORM form_) { m_form = form_; };
     turnLog_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
diff --git a/libmei/atts_critapp.cpp b/libmei/atts_critapp.cpp
index fd53983dadf..3a844504834 100644
--- a/libmei/atts_critapp.cpp
+++ b/libmei/atts_critapp.cpp
@@ -65,7 +65,7 @@ bool AttCrit::WriteCrit(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCrit::HasCause()
+bool AttCrit::HasCause() const
 {
     return (m_cause != "");
 }
@@ -111,7 +111,7 @@ bool AttSource::WriteSource(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSource::HasSource()
+bool AttSource::HasSource() const
 {
     return (m_source != "");
 }
@@ -140,17 +140,17 @@ bool Att::SetCritapp(Object *element, std::string attrType, std::string attrValu
     return false;
 }
 
-void Att::GetCritapp(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetCritapp(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_CRIT)) {
-        AttCrit *att = dynamic_cast<AttCrit *>(element);
+        const AttCrit *att = dynamic_cast<const AttCrit *>(element);
         assert(att);
         if (att->HasCause()) {
             attributes->push_back(std::make_pair("cause", att->StrToStr(att->GetCause())));
         }
     }
     if (element->HasAttClass(ATT_SOURCE)) {
-        AttSource *att = dynamic_cast<AttSource *>(element);
+        const AttSource *att = dynamic_cast<const AttSource *>(element);
         assert(att);
         if (att->HasSource()) {
             attributes->push_back(std::make_pair("source", att->StrToStr(att->GetSource())));
diff --git a/libmei/atts_critapp.h b/libmei/atts_critapp.h
index 75c4b306f4a..c76112496df 100644
--- a/libmei/atts_critapp.h
+++ b/libmei/atts_critapp.h
@@ -51,7 +51,7 @@ class AttCrit : public Att {
     ///@{
     void SetCause(std::string cause_) { m_cause = cause_; };
     std::string GetCause() const { return m_cause; };
-    bool HasCause();
+    bool HasCause() const;
     ///@}
 
 private:
@@ -90,7 +90,7 @@ class AttSource : public Att {
     ///@{
     void SetSource(std::string source_) { m_source = source_; };
     std::string GetSource() const { return m_source; };
-    bool HasSource();
+    bool HasSource() const;
     ///@}
 
 private:
diff --git a/libmei/atts_edittrans.cpp b/libmei/atts_edittrans.cpp
index e83b593fc09..3b9c7a2b22c 100644
--- a/libmei/atts_edittrans.cpp
+++ b/libmei/atts_edittrans.cpp
@@ -65,7 +65,7 @@ bool AttAgentident::WriteAgentident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAgentident::HasAgent()
+bool AttAgentident::HasAgent() const
 {
     return (m_agent != "");
 }
@@ -121,12 +121,12 @@ bool AttEvidence::WriteEvidence(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttEvidence::HasCert()
+bool AttEvidence::HasCert() const
 {
     return (m_cert != CERTAINTY_NONE);
 }
 
-bool AttEvidence::HasEvidence()
+bool AttEvidence::HasEvidence() const
 {
     return (m_evidence != "");
 }
@@ -172,7 +172,7 @@ bool AttExtent::WriteExtent(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttExtent::HasExtent()
+bool AttExtent::HasExtent() const
 {
     return (m_extent != "");
 }
@@ -218,7 +218,7 @@ bool AttReasonident::WriteReasonident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttReasonident::HasReason()
+bool AttReasonident::HasReason() const
 {
     return (m_reason != "");
 }
@@ -267,17 +267,17 @@ bool Att::SetEdittrans(Object *element, std::string attrType, std::string attrVa
     return false;
 }
 
-void Att::GetEdittrans(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetEdittrans(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_AGENTIDENT)) {
-        AttAgentident *att = dynamic_cast<AttAgentident *>(element);
+        const AttAgentident *att = dynamic_cast<const AttAgentident *>(element);
         assert(att);
         if (att->HasAgent()) {
             attributes->push_back(std::make_pair("agent", att->StrToStr(att->GetAgent())));
         }
     }
     if (element->HasAttClass(ATT_EVIDENCE)) {
-        AttEvidence *att = dynamic_cast<AttEvidence *>(element);
+        const AttEvidence *att = dynamic_cast<const AttEvidence *>(element);
         assert(att);
         if (att->HasCert()) {
             attributes->push_back(std::make_pair("cert", att->CertaintyToStr(att->GetCert())));
@@ -287,14 +287,14 @@ void Att::GetEdittrans(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_EXTENT)) {
-        AttExtent *att = dynamic_cast<AttExtent *>(element);
+        const AttExtent *att = dynamic_cast<const AttExtent *>(element);
         assert(att);
         if (att->HasExtent()) {
             attributes->push_back(std::make_pair("extent", att->StrToStr(att->GetExtent())));
         }
     }
     if (element->HasAttClass(ATT_REASONIDENT)) {
-        AttReasonident *att = dynamic_cast<AttReasonident *>(element);
+        const AttReasonident *att = dynamic_cast<const AttReasonident *>(element);
         assert(att);
         if (att->HasReason()) {
             attributes->push_back(std::make_pair("reason", att->StrToStr(att->GetReason())));
diff --git a/libmei/atts_edittrans.h b/libmei/atts_edittrans.h
index 94a8a16785e..c26d01637d0 100644
--- a/libmei/atts_edittrans.h
+++ b/libmei/atts_edittrans.h
@@ -51,7 +51,7 @@ class AttAgentident : public Att {
     ///@{
     void SetAgent(std::string agent_) { m_agent = agent_; };
     std::string GetAgent() const { return m_agent; };
-    bool HasAgent();
+    bool HasAgent() const;
     ///@}
 
 private:
@@ -90,11 +90,11 @@ class AttEvidence : public Att {
     ///@{
     void SetCert(data_CERTAINTY cert_) { m_cert = cert_; };
     data_CERTAINTY GetCert() const { return m_cert; };
-    bool HasCert();
+    bool HasCert() const;
     //
     void SetEvidence(std::string evidence_) { m_evidence = evidence_; };
     std::string GetEvidence() const { return m_evidence; };
-    bool HasEvidence();
+    bool HasEvidence() const;
     ///@}
 
 private:
@@ -136,7 +136,7 @@ class AttExtent : public Att {
     ///@{
     void SetExtent(std::string extent_) { m_extent = extent_; };
     std::string GetExtent() const { return m_extent; };
-    bool HasExtent();
+    bool HasExtent() const;
     ///@}
 
 private:
@@ -172,7 +172,7 @@ class AttReasonident : public Att {
     ///@{
     void SetReason(std::string reason_) { m_reason = reason_; };
     std::string GetReason() const { return m_reason; };
-    bool HasReason();
+    bool HasReason() const;
     ///@}
 
 private:
diff --git a/libmei/atts_facsimile.cpp b/libmei/atts_facsimile.cpp
index 120bfafc150..f573e9e857e 100644
--- a/libmei/atts_facsimile.cpp
+++ b/libmei/atts_facsimile.cpp
@@ -65,7 +65,7 @@ bool AttFacsimile::WriteFacsimile(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttFacsimile::HasFacs()
+bool AttFacsimile::HasFacs() const
 {
     return (m_facs != URIS_NONE);
 }
@@ -86,10 +86,10 @@ bool Att::SetFacsimile(Object *element, std::string attrType, std::string attrVa
     return false;
 }
 
-void Att::GetFacsimile(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetFacsimile(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_FACSIMILE)) {
-        AttFacsimile *att = dynamic_cast<AttFacsimile *>(element);
+        const AttFacsimile *att = dynamic_cast<const AttFacsimile *>(element);
         assert(att);
         if (att->HasFacs()) {
             attributes->push_back(std::make_pair("facs", att->UrisToStr(att->GetFacs())));
diff --git a/libmei/atts_facsimile.h b/libmei/atts_facsimile.h
index a06a3479f34..3a767c42ace 100644
--- a/libmei/atts_facsimile.h
+++ b/libmei/atts_facsimile.h
@@ -51,7 +51,7 @@ class AttFacsimile : public Att {
     ///@{
     void SetFacs(data_URIS facs_) { m_facs = facs_; };
     data_URIS GetFacs() const { return m_facs; };
-    bool HasFacs();
+    bool HasFacs() const;
     ///@}
 
 private:
diff --git a/libmei/atts_figtable.cpp b/libmei/atts_figtable.cpp
index d9329ee7a3e..d0cb7409a99 100644
--- a/libmei/atts_figtable.cpp
+++ b/libmei/atts_figtable.cpp
@@ -75,12 +75,12 @@ bool AttTabular::WriteTabular(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTabular::HasColspan()
+bool AttTabular::HasColspan() const
 {
     return (m_colspan != 0);
 }
 
-bool AttTabular::HasRowspan()
+bool AttTabular::HasRowspan() const
 {
     return (m_rowspan != 0);
 }
@@ -105,10 +105,10 @@ bool Att::SetFigtable(Object *element, std::string attrType, std::string attrVal
     return false;
 }
 
-void Att::GetFigtable(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetFigtable(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_TABULAR)) {
-        AttTabular *att = dynamic_cast<AttTabular *>(element);
+        const AttTabular *att = dynamic_cast<const AttTabular *>(element);
         assert(att);
         if (att->HasColspan()) {
             attributes->push_back(std::make_pair("colspan", att->IntToStr(att->GetColspan())));
diff --git a/libmei/atts_figtable.h b/libmei/atts_figtable.h
index 11e68dcd58f..86ee670d17d 100644
--- a/libmei/atts_figtable.h
+++ b/libmei/atts_figtable.h
@@ -51,11 +51,11 @@ class AttTabular : public Att {
     ///@{
     void SetColspan(int colspan_) { m_colspan = colspan_; };
     int GetColspan() const { return m_colspan; };
-    bool HasColspan();
+    bool HasColspan() const;
     //
     void SetRowspan(int rowspan_) { m_rowspan = rowspan_; };
     int GetRowspan() const { return m_rowspan; };
-    bool HasRowspan();
+    bool HasRowspan() const;
     ///@}
 
 private:
diff --git a/libmei/atts_harmony.cpp b/libmei/atts_harmony.cpp
index d7b7f30c624..e08f52a846a 100644
--- a/libmei/atts_harmony.cpp
+++ b/libmei/atts_harmony.cpp
@@ -65,7 +65,7 @@ bool AttFretlocation::WriteFretlocation(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttFretlocation::HasFret()
+bool AttFretlocation::HasFret() const
 {
     return (m_fret != FRET_NONE);
 }
@@ -111,7 +111,7 @@ bool AttHarmLog::WriteHarmLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHarmLog::HasChordref()
+bool AttHarmLog::HasChordref() const
 {
     return (m_chordref != "");
 }
@@ -157,7 +157,7 @@ bool AttHarmVis::WriteHarmVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHarmVis::HasRendgrid()
+bool AttHarmVis::HasRendgrid() const
 {
     return (m_rendgrid != harmVis_RENDGRID_NONE);
 }
@@ -194,24 +194,24 @@ bool Att::SetHarmony(Object *element, std::string attrType, std::string attrValu
     return false;
 }
 
-void Att::GetHarmony(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetHarmony(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_FRETLOCATION)) {
-        AttFretlocation *att = dynamic_cast<AttFretlocation *>(element);
+        const AttFretlocation *att = dynamic_cast<const AttFretlocation *>(element);
         assert(att);
         if (att->HasFret()) {
             attributes->push_back(std::make_pair("fret", att->FretToStr(att->GetFret())));
         }
     }
     if (element->HasAttClass(ATT_HARMLOG)) {
-        AttHarmLog *att = dynamic_cast<AttHarmLog *>(element);
+        const AttHarmLog *att = dynamic_cast<const AttHarmLog *>(element);
         assert(att);
         if (att->HasChordref()) {
             attributes->push_back(std::make_pair("chordref", att->StrToStr(att->GetChordref())));
         }
     }
     if (element->HasAttClass(ATT_HARMVIS)) {
-        AttHarmVis *att = dynamic_cast<AttHarmVis *>(element);
+        const AttHarmVis *att = dynamic_cast<const AttHarmVis *>(element);
         assert(att);
         if (att->HasRendgrid()) {
             attributes->push_back(std::make_pair("rendgrid", att->HarmVisRendgridToStr(att->GetRendgrid())));
diff --git a/libmei/atts_harmony.h b/libmei/atts_harmony.h
index 804c950b5b6..b7c97a3b741 100644
--- a/libmei/atts_harmony.h
+++ b/libmei/atts_harmony.h
@@ -51,7 +51,7 @@ class AttFretlocation : public Att {
     ///@{
     void SetFret(data_FRET fret_) { m_fret = fret_; };
     data_FRET GetFret() const { return m_fret; };
-    bool HasFret();
+    bool HasFret() const;
     ///@}
 
 private:
@@ -87,7 +87,7 @@ class AttHarmLog : public Att {
     ///@{
     void SetChordref(std::string chordref_) { m_chordref = chordref_; };
     std::string GetChordref() const { return m_chordref; };
-    bool HasChordref();
+    bool HasChordref() const;
     ///@}
 
 private:
@@ -123,7 +123,7 @@ class AttHarmVis : public Att {
     ///@{
     void SetRendgrid(harmVis_RENDGRID rendgrid_) { m_rendgrid = rendgrid_; };
     harmVis_RENDGRID GetRendgrid() const { return m_rendgrid; };
-    bool HasRendgrid();
+    bool HasRendgrid() const;
     ///@}
 
 private:
diff --git a/libmei/atts_header.cpp b/libmei/atts_header.cpp
index 7fa14608535..3f2e925d4be 100644
--- a/libmei/atts_header.cpp
+++ b/libmei/atts_header.cpp
@@ -65,7 +65,7 @@ bool AttRegularmethod::WriteRegularmethod(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttRegularmethod::HasMethod()
+bool AttRegularmethod::HasMethod() const
 {
     return (m_method != regularmethod_METHOD_NONE);
 }
@@ -86,10 +86,10 @@ bool Att::SetHeader(Object *element, std::string attrType, std::string attrValue
     return false;
 }
 
-void Att::GetHeader(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetHeader(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_REGULARMETHOD)) {
-        AttRegularmethod *att = dynamic_cast<AttRegularmethod *>(element);
+        const AttRegularmethod *att = dynamic_cast<const AttRegularmethod *>(element);
         assert(att);
         if (att->HasMethod()) {
             attributes->push_back(std::make_pair("method", att->RegularmethodMethodToStr(att->GetMethod())));
diff --git a/libmei/atts_header.h b/libmei/atts_header.h
index 98a191741f1..a7e3bfd5ce0 100644
--- a/libmei/atts_header.h
+++ b/libmei/atts_header.h
@@ -51,7 +51,7 @@ class AttRegularmethod : public Att {
     ///@{
     void SetMethod(regularmethod_METHOD method_) { m_method = method_; };
     regularmethod_METHOD GetMethod() const { return m_method; };
-    bool HasMethod();
+    bool HasMethod() const;
     ///@}
 
 private:
diff --git a/libmei/atts_lyrics.cpp b/libmei/atts_lyrics.cpp
index 7c555f2f048..70c0f77a4c0 100644
--- a/libmei/atts_lyrics.cpp
+++ b/libmei/atts_lyrics.cpp
@@ -75,12 +75,12 @@ bool AttVerseLog::WriteVerseLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVerseLog::HasRefrain()
+bool AttVerseLog::HasRefrain() const
 {
     return (m_refrain != BOOLEAN_NONE);
 }
 
-bool AttVerseLog::HasRhythm()
+bool AttVerseLog::HasRhythm() const
 {
     return (m_rhythm != "");
 }
@@ -105,10 +105,10 @@ bool Att::SetLyrics(Object *element, std::string attrType, std::string attrValue
     return false;
 }
 
-void Att::GetLyrics(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetLyrics(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_VERSELOG)) {
-        AttVerseLog *att = dynamic_cast<AttVerseLog *>(element);
+        const AttVerseLog *att = dynamic_cast<const AttVerseLog *>(element);
         assert(att);
         if (att->HasRefrain()) {
             attributes->push_back(std::make_pair("refrain", att->BooleanToStr(att->GetRefrain())));
diff --git a/libmei/atts_lyrics.h b/libmei/atts_lyrics.h
index 1c31896cf05..0abcd08b875 100644
--- a/libmei/atts_lyrics.h
+++ b/libmei/atts_lyrics.h
@@ -51,11 +51,11 @@ class AttVerseLog : public Att {
     ///@{
     void SetRefrain(data_BOOLEAN refrain_) { m_refrain = refrain_; };
     data_BOOLEAN GetRefrain() const { return m_refrain; };
-    bool HasRefrain();
+    bool HasRefrain() const;
     //
     void SetRhythm(std::string rhythm_) { m_rhythm = rhythm_; };
     std::string GetRhythm() const { return m_rhythm; };
-    bool HasRhythm();
+    bool HasRhythm() const;
     ///@}
 
 private:
diff --git a/libmei/atts_mei.cpp b/libmei/atts_mei.cpp
index a23476635e1..ea9150b18a2 100644
--- a/libmei/atts_mei.cpp
+++ b/libmei/atts_mei.cpp
@@ -75,12 +75,12 @@ bool AttNotationtype::WriteNotationtype(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNotationtype::HasNotationtype()
+bool AttNotationtype::HasNotationtype() const
 {
     return (m_notationtype != NOTATIONTYPE_NONE);
 }
 
-bool AttNotationtype::HasNotationsubtype()
+bool AttNotationtype::HasNotationsubtype() const
 {
     return (m_notationsubtype != "");
 }
@@ -105,10 +105,10 @@ bool Att::SetMei(Object *element, std::string attrType, std::string attrValue)
     return false;
 }
 
-void Att::GetMei(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetMei(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_NOTATIONTYPE)) {
-        AttNotationtype *att = dynamic_cast<AttNotationtype *>(element);
+        const AttNotationtype *att = dynamic_cast<const AttNotationtype *>(element);
         assert(att);
         if (att->HasNotationtype()) {
             attributes->push_back(std::make_pair("notationtype", att->NotationtypeToStr(att->GetNotationtype())));
diff --git a/libmei/atts_mei.h b/libmei/atts_mei.h
index 27345e39f6e..16f6e03c841 100644
--- a/libmei/atts_mei.h
+++ b/libmei/atts_mei.h
@@ -51,11 +51,11 @@ class AttNotationtype : public Att {
     ///@{
     void SetNotationtype(data_NOTATIONTYPE notationtype_) { m_notationtype = notationtype_; };
     data_NOTATIONTYPE GetNotationtype() const { return m_notationtype; };
-    bool HasNotationtype();
+    bool HasNotationtype() const;
     //
     void SetNotationsubtype(std::string notationsubtype_) { m_notationsubtype = notationsubtype_; };
     std::string GetNotationsubtype() const { return m_notationsubtype; };
-    bool HasNotationsubtype();
+    bool HasNotationsubtype() const;
     ///@}
 
 private:
diff --git a/libmei/atts_mensural.cpp b/libmei/atts_mensural.cpp
index 718c93a3eb6..439f8658cb3 100644
--- a/libmei/atts_mensural.cpp
+++ b/libmei/atts_mensural.cpp
@@ -65,7 +65,7 @@ bool AttLigatureLog::WriteLigatureLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLigatureLog::HasForm()
+bool AttLigatureLog::HasForm() const
 {
     return (m_form != LIGATUREFORM_NONE);
 }
@@ -121,12 +121,12 @@ bool AttMensurVis::WriteMensurVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMensurVis::HasForm()
+bool AttMensurVis::HasForm() const
 {
     return (m_form != mensurVis_FORM_NONE);
 }
 
-bool AttMensurVis::HasOrient()
+bool AttMensurVis::HasOrient() const
 {
     return (m_orient != ORIENTATION_NONE);
 }
@@ -212,27 +212,27 @@ bool AttMensuralLog::WriteMensuralLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMensuralLog::HasMensurDot()
+bool AttMensuralLog::HasMensurDot() const
 {
     return (m_mensurDot != BOOLEAN_NONE);
 }
 
-bool AttMensuralLog::HasMensurSign()
+bool AttMensuralLog::HasMensurSign() const
 {
     return (m_mensurSign != MENSURATIONSIGN_NONE);
 }
 
-bool AttMensuralLog::HasMensurSlash()
+bool AttMensuralLog::HasMensurSlash() const
 {
     return (m_mensurSlash != 0);
 }
 
-bool AttMensuralLog::HasProportNum()
+bool AttMensuralLog::HasProportNum() const
 {
     return (m_proportNum != -1);
 }
 
-bool AttMensuralLog::HasProportNumbase()
+bool AttMensuralLog::HasProportNumbase() const
 {
     return (m_proportNumbase != -1);
 }
@@ -308,22 +308,22 @@ bool AttMensuralShared::WriteMensuralShared(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMensuralShared::HasModusmaior()
+bool AttMensuralShared::HasModusmaior() const
 {
     return (m_modusmaior != MODUSMAIOR_NONE);
 }
 
-bool AttMensuralShared::HasModusminor()
+bool AttMensuralShared::HasModusminor() const
 {
     return (m_modusminor != MODUSMINOR_NONE);
 }
 
-bool AttMensuralShared::HasProlatio()
+bool AttMensuralShared::HasProlatio() const
 {
     return (m_prolatio != PROLATIO_NONE);
 }
 
-bool AttMensuralShared::HasTempus()
+bool AttMensuralShared::HasTempus() const
 {
     return (m_tempus != TEMPUS_NONE);
 }
@@ -409,27 +409,27 @@ bool AttMensuralVis::WriteMensuralVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMensuralVis::HasMensurColor()
+bool AttMensuralVis::HasMensurColor() const
 {
     return (m_mensurColor != "");
 }
 
-bool AttMensuralVis::HasMensurForm()
+bool AttMensuralVis::HasMensurForm() const
 {
     return (m_mensurForm != mensuralVis_MENSURFORM_NONE);
 }
 
-bool AttMensuralVis::HasMensurLoc()
+bool AttMensuralVis::HasMensurLoc() const
 {
     return (m_mensurLoc != 0);
 }
 
-bool AttMensuralVis::HasMensurOrient()
+bool AttMensuralVis::HasMensurOrient() const
 {
     return (m_mensurOrient != ORIENTATION_NONE);
 }
 
-bool AttMensuralVis::HasMensurSize()
+bool AttMensuralVis::HasMensurSize() const
 {
     return (m_mensurSize != SIZE_NONE);
 }
@@ -475,7 +475,7 @@ bool AttNoteLogMensural::WriteNoteLogMensural(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNoteLogMensural::HasLig()
+bool AttNoteLogMensural::HasLig() const
 {
     return (m_lig != noteLogMensural_LIG_NONE);
 }
@@ -521,7 +521,7 @@ bool AttRestVisMensural::WriteRestVisMensural(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttRestVisMensural::HasSpaces()
+bool AttRestVisMensural::HasSpaces() const
 {
     return (m_spaces != 0);
 }
@@ -638,17 +638,17 @@ bool Att::SetMensural(Object *element, std::string attrType, std::string attrVal
     return false;
 }
 
-void Att::GetMensural(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetMensural(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_LIGATURELOG)) {
-        AttLigatureLog *att = dynamic_cast<AttLigatureLog *>(element);
+        const AttLigatureLog *att = dynamic_cast<const AttLigatureLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->LigatureformToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_MENSURVIS)) {
-        AttMensurVis *att = dynamic_cast<AttMensurVis *>(element);
+        const AttMensurVis *att = dynamic_cast<const AttMensurVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->MensurVisFormToStr(att->GetForm())));
@@ -658,7 +658,7 @@ void Att::GetMensural(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MENSURALLOG)) {
-        AttMensuralLog *att = dynamic_cast<AttMensuralLog *>(element);
+        const AttMensuralLog *att = dynamic_cast<const AttMensuralLog *>(element);
         assert(att);
         if (att->HasMensurDot()) {
             attributes->push_back(std::make_pair("mensur.dot", att->BooleanToStr(att->GetMensurDot())));
@@ -677,7 +677,7 @@ void Att::GetMensural(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MENSURALSHARED)) {
-        AttMensuralShared *att = dynamic_cast<AttMensuralShared *>(element);
+        const AttMensuralShared *att = dynamic_cast<const AttMensuralShared *>(element);
         assert(att);
         if (att->HasModusmaior()) {
             attributes->push_back(std::make_pair("modusmaior", att->ModusmaiorToStr(att->GetModusmaior())));
@@ -693,7 +693,7 @@ void Att::GetMensural(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MENSURALVIS)) {
-        AttMensuralVis *att = dynamic_cast<AttMensuralVis *>(element);
+        const AttMensuralVis *att = dynamic_cast<const AttMensuralVis *>(element);
         assert(att);
         if (att->HasMensurColor()) {
             attributes->push_back(std::make_pair("mensur.color", att->StrToStr(att->GetMensurColor())));
@@ -712,14 +712,14 @@ void Att::GetMensural(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_NOTELOGMENSURAL)) {
-        AttNoteLogMensural *att = dynamic_cast<AttNoteLogMensural *>(element);
+        const AttNoteLogMensural *att = dynamic_cast<const AttNoteLogMensural *>(element);
         assert(att);
         if (att->HasLig()) {
             attributes->push_back(std::make_pair("lig", att->NoteLogMensuralLigToStr(att->GetLig())));
         }
     }
     if (element->HasAttClass(ATT_RESTVISMENSURAL)) {
-        AttRestVisMensural *att = dynamic_cast<AttRestVisMensural *>(element);
+        const AttRestVisMensural *att = dynamic_cast<const AttRestVisMensural *>(element);
         assert(att);
         if (att->HasSpaces()) {
             attributes->push_back(std::make_pair("spaces", att->IntToStr(att->GetSpaces())));
diff --git a/libmei/atts_mensural.h b/libmei/atts_mensural.h
index 7b138e7dc59..12c65b517cd 100644
--- a/libmei/atts_mensural.h
+++ b/libmei/atts_mensural.h
@@ -51,7 +51,7 @@ class AttLigatureLog : public Att {
     ///@{
     void SetForm(data_LIGATUREFORM form_) { m_form = form_; };
     data_LIGATUREFORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -87,11 +87,11 @@ class AttMensurVis : public Att {
     ///@{
     void SetForm(mensurVis_FORM form_) { m_form = form_; };
     mensurVis_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetOrient(data_ORIENTATION orient_) { m_orient = orient_; };
     data_ORIENTATION GetOrient() const { return m_orient; };
-    bool HasOrient();
+    bool HasOrient() const;
     ///@}
 
 private:
@@ -129,23 +129,23 @@ class AttMensuralLog : public Att {
     ///@{
     void SetMensurDot(data_BOOLEAN mensurDot_) { m_mensurDot = mensurDot_; };
     data_BOOLEAN GetMensurDot() const { return m_mensurDot; };
-    bool HasMensurDot();
+    bool HasMensurDot() const;
     //
     void SetMensurSign(data_MENSURATIONSIGN mensurSign_) { m_mensurSign = mensurSign_; };
     data_MENSURATIONSIGN GetMensurSign() const { return m_mensurSign; };
-    bool HasMensurSign();
+    bool HasMensurSign() const;
     //
     void SetMensurSlash(int mensurSlash_) { m_mensurSlash = mensurSlash_; };
     int GetMensurSlash() const { return m_mensurSlash; };
-    bool HasMensurSlash();
+    bool HasMensurSlash() const;
     //
     void SetProportNum(int proportNum_) { m_proportNum = proportNum_; };
     int GetProportNum() const { return m_proportNum; };
-    bool HasProportNum();
+    bool HasProportNum() const;
     //
     void SetProportNumbase(int proportNumbase_) { m_proportNumbase = proportNumbase_; };
     int GetProportNumbase() const { return m_proportNumbase; };
-    bool HasProportNumbase();
+    bool HasProportNumbase() const;
     ///@}
 
 private:
@@ -200,19 +200,19 @@ class AttMensuralShared : public Att {
     ///@{
     void SetModusmaior(data_MODUSMAIOR modusmaior_) { m_modusmaior = modusmaior_; };
     data_MODUSMAIOR GetModusmaior() const { return m_modusmaior; };
-    bool HasModusmaior();
+    bool HasModusmaior() const;
     //
     void SetModusminor(data_MODUSMINOR modusminor_) { m_modusminor = modusminor_; };
     data_MODUSMINOR GetModusminor() const { return m_modusminor; };
-    bool HasModusminor();
+    bool HasModusminor() const;
     //
     void SetProlatio(data_PROLATIO prolatio_) { m_prolatio = prolatio_; };
     data_PROLATIO GetProlatio() const { return m_prolatio; };
-    bool HasProlatio();
+    bool HasProlatio() const;
     //
     void SetTempus(data_TEMPUS tempus_) { m_tempus = tempus_; };
     data_TEMPUS GetTempus() const { return m_tempus; };
-    bool HasTempus();
+    bool HasTempus() const;
     ///@}
 
 private:
@@ -254,23 +254,23 @@ class AttMensuralVis : public Att {
     ///@{
     void SetMensurColor(std::string mensurColor_) { m_mensurColor = mensurColor_; };
     std::string GetMensurColor() const { return m_mensurColor; };
-    bool HasMensurColor();
+    bool HasMensurColor() const;
     //
     void SetMensurForm(mensuralVis_MENSURFORM mensurForm_) { m_mensurForm = mensurForm_; };
     mensuralVis_MENSURFORM GetMensurForm() const { return m_mensurForm; };
-    bool HasMensurForm();
+    bool HasMensurForm() const;
     //
     void SetMensurLoc(int mensurLoc_) { m_mensurLoc = mensurLoc_; };
     int GetMensurLoc() const { return m_mensurLoc; };
-    bool HasMensurLoc();
+    bool HasMensurLoc() const;
     //
     void SetMensurOrient(data_ORIENTATION mensurOrient_) { m_mensurOrient = mensurOrient_; };
     data_ORIENTATION GetMensurOrient() const { return m_mensurOrient; };
-    bool HasMensurOrient();
+    bool HasMensurOrient() const;
     //
     void SetMensurSize(data_SIZE mensurSize_) { m_mensurSize = mensurSize_; };
     data_SIZE GetMensurSize() const { return m_mensurSize; };
-    bool HasMensurSize();
+    bool HasMensurSize() const;
     ///@}
 
 private:
@@ -317,7 +317,7 @@ class AttNoteLogMensural : public Att {
     ///@{
     void SetLig(noteLogMensural_LIG lig_) { m_lig = lig_; };
     noteLogMensural_LIG GetLig() const { return m_lig; };
-    bool HasLig();
+    bool HasLig() const;
     ///@}
 
 private:
@@ -353,7 +353,7 @@ class AttRestVisMensural : public Att {
     ///@{
     void SetSpaces(int spaces_) { m_spaces = spaces_; };
     int GetSpaces() const { return m_spaces; };
-    bool HasSpaces();
+    bool HasSpaces() const;
     ///@}
 
 private:
diff --git a/libmei/atts_midi.cpp b/libmei/atts_midi.cpp
index f3778e826b2..8cbfd08482a 100644
--- a/libmei/atts_midi.cpp
+++ b/libmei/atts_midi.cpp
@@ -95,22 +95,22 @@ bool AttChannelized::WriteChannelized(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttChannelized::HasMidiChannel()
+bool AttChannelized::HasMidiChannel() const
 {
     return (m_midiChannel != MIDICHANNEL_NONE);
 }
 
-bool AttChannelized::HasMidiDuty()
+bool AttChannelized::HasMidiDuty() const
 {
     return (m_midiDuty != 0);
 }
 
-bool AttChannelized::HasMidiPort()
+bool AttChannelized::HasMidiPort() const
 {
     return (m_midiPort != MIDIVALUE_NONE);
 }
 
-bool AttChannelized::HasMidiTrack()
+bool AttChannelized::HasMidiTrack() const
 {
     return (m_midiTrack != 0);
 }
@@ -186,22 +186,22 @@ bool AttMidiinstrument::WriteMidiinstrument(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMidiinstrument::HasMidiInstrnum()
+bool AttMidiinstrument::HasMidiInstrnum() const
 {
     return (m_midiInstrnum != MIDIVALUE_NONE);
 }
 
-bool AttMidiinstrument::HasMidiInstrname()
+bool AttMidiinstrument::HasMidiInstrname() const
 {
     return (m_midiInstrname != MIDINAMES_NONE);
 }
 
-bool AttMidiinstrument::HasMidiPan()
+bool AttMidiinstrument::HasMidiPan() const
 {
     return (m_midiPan != MIDIVALUE_NONE);
 }
 
-bool AttMidiinstrument::HasMidiVolume()
+bool AttMidiinstrument::HasMidiVolume() const
 {
     return (m_midiVolume != MIDIVALUE_NONE);
 }
@@ -247,7 +247,7 @@ bool AttMidinumber::WriteMidinumber(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMidinumber::HasNum()
+bool AttMidinumber::HasNum() const
 {
     return (m_num != 0);
 }
@@ -293,7 +293,7 @@ bool AttMiditempo::WriteMiditempo(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMiditempo::HasMidiTempo()
+bool AttMiditempo::HasMidiTempo() const
 {
     return (m_midiTempo != MIDITEMPO_NONE);
 }
@@ -339,7 +339,7 @@ bool AttMidivalue::WriteMidivalue(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMidivalue::HasVal()
+bool AttMidivalue::HasVal() const
 {
     return (m_val != MIDIVALUE_NONE);
 }
@@ -385,7 +385,7 @@ bool AttMidivalue2::WriteMidivalue2(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMidivalue2::HasVal2()
+bool AttMidivalue2::HasVal2() const
 {
     return (m_val2 != MIDIVALUE_NONE);
 }
@@ -431,7 +431,7 @@ bool AttMidivelocity::WriteMidivelocity(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMidivelocity::HasVel()
+bool AttMidivelocity::HasVel() const
 {
     return (m_vel != MIDIVALUE_NONE);
 }
@@ -477,7 +477,7 @@ bool AttTimebase::WriteTimebase(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTimebase::HasPpq()
+bool AttTimebase::HasPpq() const
 {
     return (m_ppq != 0);
 }
@@ -578,10 +578,10 @@ bool Att::SetMidi(Object *element, std::string attrType, std::string attrValue)
     return false;
 }
 
-void Att::GetMidi(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetMidi(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_CHANNELIZED)) {
-        AttChannelized *att = dynamic_cast<AttChannelized *>(element);
+        const AttChannelized *att = dynamic_cast<const AttChannelized *>(element);
         assert(att);
         if (att->HasMidiChannel()) {
             attributes->push_back(std::make_pair("midi.channel", att->MidichannelToStr(att->GetMidiChannel())));
@@ -597,7 +597,7 @@ void Att::GetMidi(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MIDIINSTRUMENT)) {
-        AttMidiinstrument *att = dynamic_cast<AttMidiinstrument *>(element);
+        const AttMidiinstrument *att = dynamic_cast<const AttMidiinstrument *>(element);
         assert(att);
         if (att->HasMidiInstrnum()) {
             attributes->push_back(std::make_pair("midi.instrnum", att->MidivalueToStr(att->GetMidiInstrnum())));
@@ -613,42 +613,42 @@ void Att::GetMidi(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MIDINUMBER)) {
-        AttMidinumber *att = dynamic_cast<AttMidinumber *>(element);
+        const AttMidinumber *att = dynamic_cast<const AttMidinumber *>(element);
         assert(att);
         if (att->HasNum()) {
             attributes->push_back(std::make_pair("num", att->IntToStr(att->GetNum())));
         }
     }
     if (element->HasAttClass(ATT_MIDITEMPO)) {
-        AttMiditempo *att = dynamic_cast<AttMiditempo *>(element);
+        const AttMiditempo *att = dynamic_cast<const AttMiditempo *>(element);
         assert(att);
         if (att->HasMidiTempo()) {
             attributes->push_back(std::make_pair("midi.tempo", att->MiditempoToStr(att->GetMidiTempo())));
         }
     }
     if (element->HasAttClass(ATT_MIDIVALUE)) {
-        AttMidivalue *att = dynamic_cast<AttMidivalue *>(element);
+        const AttMidivalue *att = dynamic_cast<const AttMidivalue *>(element);
         assert(att);
         if (att->HasVal()) {
             attributes->push_back(std::make_pair("val", att->MidivalueToStr(att->GetVal())));
         }
     }
     if (element->HasAttClass(ATT_MIDIVALUE2)) {
-        AttMidivalue2 *att = dynamic_cast<AttMidivalue2 *>(element);
+        const AttMidivalue2 *att = dynamic_cast<const AttMidivalue2 *>(element);
         assert(att);
         if (att->HasVal2()) {
             attributes->push_back(std::make_pair("val2", att->MidivalueToStr(att->GetVal2())));
         }
     }
     if (element->HasAttClass(ATT_MIDIVELOCITY)) {
-        AttMidivelocity *att = dynamic_cast<AttMidivelocity *>(element);
+        const AttMidivelocity *att = dynamic_cast<const AttMidivelocity *>(element);
         assert(att);
         if (att->HasVel()) {
             attributes->push_back(std::make_pair("vel", att->MidivalueToStr(att->GetVel())));
         }
     }
     if (element->HasAttClass(ATT_TIMEBASE)) {
-        AttTimebase *att = dynamic_cast<AttTimebase *>(element);
+        const AttTimebase *att = dynamic_cast<const AttTimebase *>(element);
         assert(att);
         if (att->HasPpq()) {
             attributes->push_back(std::make_pair("ppq", att->IntToStr(att->GetPpq())));
diff --git a/libmei/atts_midi.h b/libmei/atts_midi.h
index 769309a1b18..63a5b27f085 100644
--- a/libmei/atts_midi.h
+++ b/libmei/atts_midi.h
@@ -51,19 +51,19 @@ class AttChannelized : public Att {
     ///@{
     void SetMidiChannel(data_MIDICHANNEL midiChannel_) { m_midiChannel = midiChannel_; };
     data_MIDICHANNEL GetMidiChannel() const { return m_midiChannel; };
-    bool HasMidiChannel();
+    bool HasMidiChannel() const;
     //
     void SetMidiDuty(int midiDuty_) { m_midiDuty = midiDuty_; };
     int GetMidiDuty() const { return m_midiDuty; };
-    bool HasMidiDuty();
+    bool HasMidiDuty() const;
     //
     void SetMidiPort(data_MIDIVALUE midiPort_) { m_midiPort = midiPort_; };
     data_MIDIVALUE GetMidiPort() const { return m_midiPort; };
-    bool HasMidiPort();
+    bool HasMidiPort() const;
     //
     void SetMidiTrack(int midiTrack_) { m_midiTrack = midiTrack_; };
     int GetMidiTrack() const { return m_midiTrack; };
-    bool HasMidiTrack();
+    bool HasMidiTrack() const;
     ///@}
 
 private:
@@ -105,19 +105,19 @@ class AttMidiinstrument : public Att {
     ///@{
     void SetMidiInstrnum(data_MIDIVALUE midiInstrnum_) { m_midiInstrnum = midiInstrnum_; };
     data_MIDIVALUE GetMidiInstrnum() const { return m_midiInstrnum; };
-    bool HasMidiInstrnum();
+    bool HasMidiInstrnum() const;
     //
     void SetMidiInstrname(data_MIDINAMES midiInstrname_) { m_midiInstrname = midiInstrname_; };
     data_MIDINAMES GetMidiInstrname() const { return m_midiInstrname; };
-    bool HasMidiInstrname();
+    bool HasMidiInstrname() const;
     //
     void SetMidiPan(data_MIDIVALUE midiPan_) { m_midiPan = midiPan_; };
     data_MIDIVALUE GetMidiPan() const { return m_midiPan; };
-    bool HasMidiPan();
+    bool HasMidiPan() const;
     //
     void SetMidiVolume(data_MIDIVALUE midiVolume_) { m_midiVolume = midiVolume_; };
     data_MIDIVALUE GetMidiVolume() const { return m_midiVolume; };
-    bool HasMidiVolume();
+    bool HasMidiVolume() const;
     ///@}
 
 private:
@@ -162,7 +162,7 @@ class AttMidinumber : public Att {
     ///@{
     void SetNum(int num_) { m_num = num_; };
     int GetNum() const { return m_num; };
-    bool HasNum();
+    bool HasNum() const;
     ///@}
 
 private:
@@ -201,7 +201,7 @@ class AttMiditempo : public Att {
     ///@{
     void SetMidiTempo(data_MIDITEMPO midiTempo_) { m_midiTempo = midiTempo_; };
     data_MIDITEMPO GetMidiTempo() const { return m_midiTempo; };
-    bool HasMidiTempo();
+    bool HasMidiTempo() const;
     ///@}
 
 private:
@@ -240,7 +240,7 @@ class AttMidivalue : public Att {
     ///@{
     void SetVal(data_MIDIVALUE val_) { m_val = val_; };
     data_MIDIVALUE GetVal() const { return m_val; };
-    bool HasVal();
+    bool HasVal() const;
     ///@}
 
 private:
@@ -276,7 +276,7 @@ class AttMidivalue2 : public Att {
     ///@{
     void SetVal2(data_MIDIVALUE val2_) { m_val2 = val2_; };
     data_MIDIVALUE GetVal2() const { return m_val2; };
-    bool HasVal2();
+    bool HasVal2() const;
     ///@}
 
 private:
@@ -312,7 +312,7 @@ class AttMidivelocity : public Att {
     ///@{
     void SetVel(data_MIDIVALUE vel_) { m_vel = vel_; };
     data_MIDIVALUE GetVel() const { return m_vel; };
-    bool HasVel();
+    bool HasVel() const;
     ///@}
 
 private:
@@ -348,7 +348,7 @@ class AttTimebase : public Att {
     ///@{
     void SetPpq(int ppq_) { m_ppq = ppq_; };
     int GetPpq() const { return m_ppq; };
-    bool HasPpq();
+    bool HasPpq() const;
     ///@}
 
 private:
diff --git a/libmei/atts_neumes.cpp b/libmei/atts_neumes.cpp
index 92836ec4373..eed2bec4627 100644
--- a/libmei/atts_neumes.cpp
+++ b/libmei/atts_neumes.cpp
@@ -75,12 +75,12 @@ bool AttIneumeLog::WriteIneumeLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttIneumeLog::HasForm()
+bool AttIneumeLog::HasForm() const
 {
     return (m_form != INEUMEFORM_NONE);
 }
 
-bool AttIneumeLog::HasName()
+bool AttIneumeLog::HasName() const
 {
     return (m_name != INEUMENAME_NONE);
 }
@@ -136,12 +136,12 @@ bool AttUneumeLog::WriteUneumeLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttUneumeLog::HasForm()
+bool AttUneumeLog::HasForm() const
 {
     return (m_form != UNEUMEFORM_NONE);
 }
 
-bool AttUneumeLog::HasName()
+bool AttUneumeLog::HasName() const
 {
     return (m_name != UNEUMENAME_NONE);
 }
@@ -178,10 +178,10 @@ bool Att::SetNeumes(Object *element, std::string attrType, std::string attrValue
     return false;
 }
 
-void Att::GetNeumes(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetNeumes(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_INEUMELOG)) {
-        AttIneumeLog *att = dynamic_cast<AttIneumeLog *>(element);
+        const AttIneumeLog *att = dynamic_cast<const AttIneumeLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->IneumeformToStr(att->GetForm())));
@@ -191,7 +191,7 @@ void Att::GetNeumes(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_UNEUMELOG)) {
-        AttUneumeLog *att = dynamic_cast<AttUneumeLog *>(element);
+        const AttUneumeLog *att = dynamic_cast<const AttUneumeLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->UneumeformToStr(att->GetForm())));
diff --git a/libmei/atts_neumes.h b/libmei/atts_neumes.h
index 992318d286e..ef538aea5f2 100644
--- a/libmei/atts_neumes.h
+++ b/libmei/atts_neumes.h
@@ -51,11 +51,11 @@ class AttIneumeLog : public Att {
     ///@{
     void SetForm(data_INEUMEFORM form_) { m_form = form_; };
     data_INEUMEFORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetName(data_INEUMENAME name_) { m_name = name_; };
     data_INEUMENAME GetName() const { return m_name; };
-    bool HasName();
+    bool HasName() const;
     ///@}
 
 private:
@@ -93,11 +93,11 @@ class AttUneumeLog : public Att {
     ///@{
     void SetForm(data_UNEUMEFORM form_) { m_form = form_; };
     data_UNEUMEFORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetName(data_UNEUMENAME name_) { m_name = name_; };
     data_UNEUMENAME GetName() const { return m_name; };
-    bool HasName();
+    bool HasName() const;
     ///@}
 
 private:
diff --git a/libmei/atts_pagebased.cpp b/libmei/atts_pagebased.cpp
index 258e19f8c37..6ce0d69999f 100644
--- a/libmei/atts_pagebased.cpp
+++ b/libmei/atts_pagebased.cpp
@@ -65,7 +65,7 @@ bool AttSurface::WriteSurface(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSurface::HasSurface()
+bool AttSurface::HasSurface() const
 {
     return (m_surface != "");
 }
@@ -86,10 +86,10 @@ bool Att::SetPagebased(Object *element, std::string attrType, std::string attrVa
     return false;
 }
 
-void Att::GetPagebased(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetPagebased(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_SURFACE)) {
-        AttSurface *att = dynamic_cast<AttSurface *>(element);
+        const AttSurface *att = dynamic_cast<const AttSurface *>(element);
         assert(att);
         if (att->HasSurface()) {
             attributes->push_back(std::make_pair("surface", att->StrToStr(att->GetSurface())));
diff --git a/libmei/atts_pagebased.h b/libmei/atts_pagebased.h
index 9fe439034ce..5202e33bd4b 100644
--- a/libmei/atts_pagebased.h
+++ b/libmei/atts_pagebased.h
@@ -51,7 +51,7 @@ class AttSurface : public Att {
     ///@{
     void SetSurface(std::string surface_) { m_surface = surface_; };
     std::string GetSurface() const { return m_surface; };
-    bool HasSurface();
+    bool HasSurface() const;
     ///@}
 
 private:
diff --git a/libmei/atts_performance.cpp b/libmei/atts_performance.cpp
index bea836059ec..ea67a1f9d91 100644
--- a/libmei/atts_performance.cpp
+++ b/libmei/atts_performance.cpp
@@ -65,7 +65,7 @@ bool AttAlignment::WriteAlignment(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAlignment::HasWhen()
+bool AttAlignment::HasWhen() const
 {
     return (m_when != "");
 }
@@ -86,10 +86,10 @@ bool Att::SetPerformance(Object *element, std::string attrType, std::string attr
     return false;
 }
 
-void Att::GetPerformance(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetPerformance(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_ALIGNMENT)) {
-        AttAlignment *att = dynamic_cast<AttAlignment *>(element);
+        const AttAlignment *att = dynamic_cast<const AttAlignment *>(element);
         assert(att);
         if (att->HasWhen()) {
             attributes->push_back(std::make_pair("when", att->StrToStr(att->GetWhen())));
diff --git a/libmei/atts_performance.h b/libmei/atts_performance.h
index 23692b8d7a7..0bd4a0a8a17 100644
--- a/libmei/atts_performance.h
+++ b/libmei/atts_performance.h
@@ -51,7 +51,7 @@ class AttAlignment : public Att {
     ///@{
     void SetWhen(std::string when_) { m_when = when_; };
     std::string GetWhen() const { return m_when; };
-    bool HasWhen();
+    bool HasWhen() const;
     ///@}
 
 private:
diff --git a/libmei/atts_shared.cpp b/libmei/atts_shared.cpp
index 4491cc61488..675a1075ed1 100644
--- a/libmei/atts_shared.cpp
+++ b/libmei/atts_shared.cpp
@@ -65,7 +65,7 @@ bool AttAccidLog::WriteAccidLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAccidLog::HasFunc()
+bool AttAccidLog::HasFunc() const
 {
     return (m_func != accidLog_FUNC_NONE);
 }
@@ -111,7 +111,7 @@ bool AttAccidental::WriteAccidental(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAccidental::HasAccid()
+bool AttAccidental::HasAccid() const
 {
     return (m_accid != ACCIDENTAL_EXPLICIT_NONE);
 }
@@ -157,7 +157,7 @@ bool AttAccidentalPerformed::WriteAccidentalPerformed(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAccidentalPerformed::HasAccidGes()
+bool AttAccidentalPerformed::HasAccidGes() const
 {
     return (m_accidGes != ACCIDENTAL_IMPLICIT_NONE);
 }
@@ -203,7 +203,7 @@ bool AttArticulation::WriteArticulation(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttArticulation::HasArtic()
+bool AttArticulation::HasArtic() const
 {
     return (m_artic != ARTICULATION_NONE);
 }
@@ -249,7 +249,7 @@ bool AttArticulationPerformed::WriteArticulationPerformed(pugi::xml_node element
     return wroteAttribute;
 }
 
-bool AttArticulationPerformed::HasArticGes()
+bool AttArticulationPerformed::HasArticGes() const
 {
     return (m_articGes != ARTICULATION_NONE);
 }
@@ -295,7 +295,7 @@ bool AttAugmentdots::WriteAugmentdots(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAugmentdots::HasDots()
+bool AttAugmentdots::HasDots() const
 {
     return (m_dots != 0);
 }
@@ -351,12 +351,12 @@ bool AttAuthorized::WriteAuthorized(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAuthorized::HasAuthority()
+bool AttAuthorized::HasAuthority() const
 {
     return (m_authority != "");
 }
 
-bool AttAuthorized::HasAuthURI()
+bool AttAuthorized::HasAuthURI() const
 {
     return (m_authURI != "");
 }
@@ -402,7 +402,7 @@ bool AttBarLineLog::WriteBarLineLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBarLineLog::HasForm()
+bool AttBarLineLog::HasForm() const
 {
     return (m_form != BARRENDITION_single);
 }
@@ -458,12 +458,12 @@ bool AttBarplacement::WriteBarplacement(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBarplacement::HasBarplace()
+bool AttBarplacement::HasBarplace() const
 {
     return (m_barplace != BARPLACE_NONE);
 }
 
-bool AttBarplacement::HasTaktplace()
+bool AttBarplacement::HasTaktplace() const
 {
     return (m_taktplace != 0);
 }
@@ -529,17 +529,17 @@ bool AttBeamingVis::WriteBeamingVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBeamingVis::HasBeamColor()
+bool AttBeamingVis::HasBeamColor() const
 {
     return (m_beamColor != "");
 }
 
-bool AttBeamingVis::HasBeamRend()
+bool AttBeamingVis::HasBeamRend() const
 {
     return (m_beamRend != beamingVis_BEAMREND_NONE);
 }
 
-bool AttBeamingVis::HasBeamSlope()
+bool AttBeamingVis::HasBeamSlope() const
 {
     return (m_beamSlope != 0.0);
 }
@@ -585,7 +585,7 @@ bool AttBibl::WriteBibl(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttBibl::HasAnalog()
+bool AttBibl::HasAnalog() const
 {
     return (m_analog != "");
 }
@@ -631,7 +631,7 @@ bool AttCalendared::WriteCalendared(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCalendared::HasCalendar()
+bool AttCalendared::HasCalendar() const
 {
     return (m_calendar != "");
 }
@@ -677,7 +677,7 @@ bool AttCanonical::WriteCanonical(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCanonical::HasCodedval()
+bool AttCanonical::HasCodedval() const
 {
     return (m_codedval != "");
 }
@@ -723,7 +723,7 @@ bool AttChordVis::WriteChordVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttChordVis::HasCluster()
+bool AttChordVis::HasCluster() const
 {
     return (m_cluster != CLUSTER_NONE);
 }
@@ -769,7 +769,7 @@ bool AttClasscodeident::WriteClasscodeident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttClasscodeident::HasClasscode()
+bool AttClasscodeident::HasClasscode() const
 {
     return (m_classcode != "");
 }
@@ -815,7 +815,7 @@ bool AttClefLog::WriteClefLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttClefLog::HasCautionary()
+bool AttClefLog::HasCautionary() const
 {
     return (m_cautionary != BOOLEAN_NONE);
 }
@@ -891,22 +891,22 @@ bool AttCleffingLog::WriteCleffingLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCleffingLog::HasClefShape()
+bool AttCleffingLog::HasClefShape() const
 {
     return (m_clefShape != CLEFSHAPE_NONE);
 }
 
-bool AttCleffingLog::HasClefLine()
+bool AttCleffingLog::HasClefLine() const
 {
     return (m_clefLine != 0);
 }
 
-bool AttCleffingLog::HasClefDis()
+bool AttCleffingLog::HasClefDis() const
 {
     return (m_clefDis != OCTAVE_DIS_NONE);
 }
 
-bool AttCleffingLog::HasClefDisPlace()
+bool AttCleffingLog::HasClefDisPlace() const
 {
     return (m_clefDisPlace != PLACE_NONE);
 }
@@ -962,12 +962,12 @@ bool AttCleffingVis::WriteCleffingVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCleffingVis::HasClefColor()
+bool AttCleffingVis::HasClefColor() const
 {
     return (m_clefColor != "");
 }
 
-bool AttCleffingVis::HasClefVisible()
+bool AttCleffingVis::HasClefVisible() const
 {
     return (m_clefVisible != BOOLEAN_NONE);
 }
@@ -1013,7 +1013,7 @@ bool AttClefshape::WriteClefshape(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttClefshape::HasShape()
+bool AttClefshape::HasShape() const
 {
     return (m_shape != CLEFSHAPE_NONE);
 }
@@ -1059,7 +1059,7 @@ bool AttColor::WriteColor(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttColor::HasColor()
+bool AttColor::HasColor() const
 {
     return (m_color != "");
 }
@@ -1105,7 +1105,7 @@ bool AttColoration::WriteColoration(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttColoration::HasColored()
+bool AttColoration::HasColored() const
 {
     return (m_colored != BOOLEAN_NONE);
 }
@@ -1151,7 +1151,7 @@ bool AttCommon::WriteCommon(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCommon::HasN()
+bool AttCommon::HasN() const
 {
     return (m_n != 0);
 }
@@ -1207,12 +1207,12 @@ bool AttCommonPart::WriteCommonPart(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCommonPart::HasLabel()
+bool AttCommonPart::HasLabel() const
 {
     return (m_label != "");
 }
 
-bool AttCommonPart::HasBase()
+bool AttCommonPart::HasBase() const
 {
     return (m_base != "");
 }
@@ -1288,22 +1288,22 @@ bool AttCoordinated::WriteCoordinated(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCoordinated::HasUlx()
+bool AttCoordinated::HasUlx() const
 {
     return (m_ulx != 0);
 }
 
-bool AttCoordinated::HasUly()
+bool AttCoordinated::HasUly() const
 {
     return (m_uly != 0);
 }
 
-bool AttCoordinated::HasLrx()
+bool AttCoordinated::HasLrx() const
 {
     return (m_lrx != 0);
 }
 
-bool AttCoordinated::HasLry()
+bool AttCoordinated::HasLry() const
 {
     return (m_lry != 0);
 }
@@ -1369,17 +1369,17 @@ bool AttCurvature::WriteCurvature(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCurvature::HasBezier()
+bool AttCurvature::HasBezier() const
 {
     return (m_bezier != "");
 }
 
-bool AttCurvature::HasBulge()
+bool AttCurvature::HasBulge() const
 {
     return (m_bulge != 0.0);
 }
 
-bool AttCurvature::HasCurvedir()
+bool AttCurvature::HasCurvedir() const
 {
     return (m_curvedir != curvature_CURVEDIR_NONE);
 }
@@ -1435,12 +1435,12 @@ bool AttCurverend::WriteCurverend(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCurverend::HasLform()
+bool AttCurverend::HasLform() const
 {
     return (m_lform != LINEFORM_NONE);
 }
 
-bool AttCurverend::HasLwidth()
+bool AttCurverend::HasLwidth() const
 {
     return (m_lwidth != "");
 }
@@ -1486,7 +1486,7 @@ bool AttCustosLog::WriteCustosLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttCustosLog::HasTarget()
+bool AttCustosLog::HasTarget() const
 {
     return (m_target != "");
 }
@@ -1572,27 +1572,27 @@ bool AttDatable::WriteDatable(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDatable::HasEnddate()
+bool AttDatable::HasEnddate() const
 {
     return (m_enddate != "");
 }
 
-bool AttDatable::HasIsodate()
+bool AttDatable::HasIsodate() const
 {
     return (m_isodate != "");
 }
 
-bool AttDatable::HasNotafter()
+bool AttDatable::HasNotafter() const
 {
     return (m_notafter != "");
 }
 
-bool AttDatable::HasNotbefore()
+bool AttDatable::HasNotbefore() const
 {
     return (m_notbefore != "");
 }
 
-bool AttDatable::HasStartdate()
+bool AttDatable::HasStartdate() const
 {
     return (m_startdate != "");
 }
@@ -1638,7 +1638,7 @@ bool AttDatapointing::WriteDatapointing(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDatapointing::HasData()
+bool AttDatapointing::HasData() const
 {
     return (m_data != "");
 }
@@ -1684,7 +1684,7 @@ bool AttDeclaring::WriteDeclaring(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDeclaring::HasDecls()
+bool AttDeclaring::HasDecls() const
 {
     return (m_decls != "");
 }
@@ -1750,17 +1750,17 @@ bool AttDistances::WriteDistances(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDistances::HasDynamDist()
+bool AttDistances::HasDynamDist() const
 {
     return (m_dynamDist != "");
 }
 
-bool AttDistances::HasHarmDist()
+bool AttDistances::HasHarmDist() const
 {
     return (m_harmDist != "");
 }
 
-bool AttDistances::HasTextDist()
+bool AttDistances::HasTextDist() const
 {
     return (m_textDist != "");
 }
@@ -1806,7 +1806,7 @@ bool AttDotLog::WriteDotLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDotLog::HasForm()
+bool AttDotLog::HasForm() const
 {
     return (m_form != dotLog_FORM_NONE);
 }
@@ -1852,7 +1852,7 @@ bool AttDurationAdditive::WriteDurationAdditive(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDurationAdditive::HasDur()
+bool AttDurationAdditive::HasDur() const
 {
     return (m_dur != DURATION_NONE);
 }
@@ -1918,17 +1918,17 @@ bool AttDurationDefault::WriteDurationDefault(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDurationDefault::HasDurDefault()
+bool AttDurationDefault::HasDurDefault() const
 {
     return (m_durDefault != DURATION_NONE);
 }
 
-bool AttDurationDefault::HasNumDefault()
+bool AttDurationDefault::HasNumDefault() const
 {
     return (m_numDefault != 0);
 }
 
-bool AttDurationDefault::HasNumbaseDefault()
+bool AttDurationDefault::HasNumbaseDefault() const
 {
     return (m_numbaseDefault != 0);
 }
@@ -1974,7 +1974,7 @@ bool AttDurationMusical::WriteDurationMusical(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDurationMusical::HasDur()
+bool AttDurationMusical::HasDur() const
 {
     return (m_dur != DURATION_NONE);
 }
@@ -2020,7 +2020,7 @@ bool AttDurationPerformed::WriteDurationPerformed(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDurationPerformed::HasDurGes()
+bool AttDurationPerformed::HasDurGes() const
 {
     return (m_durGes != DURATION_NONE);
 }
@@ -2076,12 +2076,12 @@ bool AttDurationRatio::WriteDurationRatio(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttDurationRatio::HasNum()
+bool AttDurationRatio::HasNum() const
 {
     return (m_num != -1);
 }
 
-bool AttDurationRatio::HasNumbase()
+bool AttDurationRatio::HasNumbase() const
 {
     return (m_numbase != -1);
 }
@@ -2127,7 +2127,7 @@ bool AttEnclosingchars::WriteEnclosingchars(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttEnclosingchars::HasEnclose()
+bool AttEnclosingchars::HasEnclose() const
 {
     return (m_enclose != ENCLOSURE_NONE);
 }
@@ -2173,7 +2173,7 @@ bool AttEndings::WriteEndings(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttEndings::HasEndingRend()
+bool AttEndings::HasEndingRend() const
 {
     return (m_endingRend != endings_ENDINGREND_NONE);
 }
@@ -2219,7 +2219,7 @@ bool AttExtender::WriteExtender(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttExtender::HasExtender()
+bool AttExtender::HasExtender() const
 {
     return (m_extender != BOOLEAN_NONE);
 }
@@ -2265,7 +2265,7 @@ bool AttFermatapresent::WriteFermatapresent(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttFermatapresent::HasFermata()
+bool AttFermatapresent::HasFermata() const
 {
     return (m_fermata != PLACE_NONE);
 }
@@ -2311,7 +2311,7 @@ bool AttFiling::WriteFiling(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttFiling::HasNonfiling()
+bool AttFiling::HasNonfiling() const
 {
     return (m_nonfiling != 0);
 }
@@ -2357,7 +2357,7 @@ bool AttGrpSymLog::WriteGrpSymLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttGrpSymLog::HasLevel()
+bool AttGrpSymLog::HasLevel() const
 {
     return (m_level != 0);
 }
@@ -2403,7 +2403,7 @@ bool AttHandident::WriteHandident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHandident::HasHand()
+bool AttHandident::HasHand() const
 {
     return (m_hand != "");
 }
@@ -2449,7 +2449,7 @@ bool AttHeight::WriteHeight(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHeight::HasHeight()
+bool AttHeight::HasHeight() const
 {
     return (m_height != "");
 }
@@ -2495,7 +2495,7 @@ bool AttHorizontalalign::WriteHorizontalalign(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttHorizontalalign::HasHalign()
+bool AttHorizontalalign::HasHalign() const
 {
     return (m_halign != HORIZONTALALIGNMENT_NONE);
 }
@@ -2541,7 +2541,7 @@ bool AttInstrumentident::WriteInstrumentident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttInstrumentident::HasInstr()
+bool AttInstrumentident::HasInstr() const
 {
     return (m_instr != "");
 }
@@ -2587,7 +2587,7 @@ bool AttInternetmedia::WriteInternetmedia(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttInternetmedia::HasMimetype()
+bool AttInternetmedia::HasMimetype() const
 {
     return (m_mimetype != "");
 }
@@ -2633,7 +2633,7 @@ bool AttJoined::WriteJoined(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttJoined::HasJoin()
+bool AttJoined::HasJoin() const
 {
     return (m_join != "");
 }
@@ -2679,7 +2679,7 @@ bool AttKeySigLog::WriteKeySigLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttKeySigLog::HasMode()
+bool AttKeySigLog::HasMode() const
 {
     return (m_mode != MODE_NONE);
 }
@@ -2765,27 +2765,27 @@ bool AttKeySigDefaultLog::WriteKeySigDefaultLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttKeySigDefaultLog::HasKeyAccid()
+bool AttKeySigDefaultLog::HasKeyAccid() const
 {
     return (m_keyAccid != ACCIDENTAL_IMPLICIT_NONE);
 }
 
-bool AttKeySigDefaultLog::HasKeyMode()
+bool AttKeySigDefaultLog::HasKeyMode() const
 {
     return (m_keyMode != MODE_NONE);
 }
 
-bool AttKeySigDefaultLog::HasKeyPname()
+bool AttKeySigDefaultLog::HasKeyPname() const
 {
     return (m_keyPname != PITCHNAME_NONE);
 }
 
-bool AttKeySigDefaultLog::HasKeySig()
+bool AttKeySigDefaultLog::HasKeySig() const
 {
     return (m_keySig != KEYSIGNATURE_NONE);
 }
 
-bool AttKeySigDefaultLog::HasKeySigMixed()
+bool AttKeySigDefaultLog::HasKeySigMixed() const
 {
     return (m_keySigMixed != "");
 }
@@ -2841,12 +2841,12 @@ bool AttKeySigDefaultVis::WriteKeySigDefaultVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttKeySigDefaultVis::HasKeySigShow()
+bool AttKeySigDefaultVis::HasKeySigShow() const
 {
     return (m_keySigShow != BOOLEAN_NONE);
 }
 
-bool AttKeySigDefaultVis::HasKeySigShowchange()
+bool AttKeySigDefaultVis::HasKeySigShowchange() const
 {
     return (m_keySigShowchange != BOOLEAN_NONE);
 }
@@ -2892,7 +2892,7 @@ bool AttLabelsAddl::WriteLabelsAddl(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLabelsAddl::HasLabelAbbr()
+bool AttLabelsAddl::HasLabelAbbr() const
 {
     return (m_labelAbbr != "");
 }
@@ -2948,12 +2948,12 @@ bool AttLang::WriteLang(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLang::HasLang()
+bool AttLang::HasLang() const
 {
     return (m_lang != "");
 }
 
-bool AttLang::HasTranslit()
+bool AttLang::HasTranslit() const
 {
     return (m_translit != "");
 }
@@ -2999,7 +2999,7 @@ bool AttLayerLog::WriteLayerLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLayerLog::HasDef()
+bool AttLayerLog::HasDef() const
 {
     return (m_def != "");
 }
@@ -3045,7 +3045,7 @@ bool AttLayerident::WriteLayerident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLayerident::HasLayer()
+bool AttLayerident::HasLayer() const
 {
     return (m_layer != 0);
 }
@@ -3141,32 +3141,32 @@ bool AttLineVis::WriteLineVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLineVis::HasForm()
+bool AttLineVis::HasForm() const
 {
     return (m_form != LINEFORM_NONE);
 }
 
-bool AttLineVis::HasWidth()
+bool AttLineVis::HasWidth() const
 {
     return (m_width != "");
 }
 
-bool AttLineVis::HasEndsym()
+bool AttLineVis::HasEndsym() const
 {
     return (m_endsym != LINESTARTENDSYMBOL_NONE);
 }
 
-bool AttLineVis::HasEndsymsize()
+bool AttLineVis::HasEndsymsize() const
 {
     return (m_endsymsize != "");
 }
 
-bool AttLineVis::HasStartsym()
+bool AttLineVis::HasStartsym() const
 {
     return (m_startsym != LINESTARTENDSYMBOL_NONE);
 }
 
-bool AttLineVis::HasStartsymsize()
+bool AttLineVis::HasStartsymsize() const
 {
     return (m_startsymsize != "");
 }
@@ -3212,7 +3212,7 @@ bool AttLineloc::WriteLineloc(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLineloc::HasLine()
+bool AttLineloc::HasLine() const
 {
     return (m_line != 0);
 }
@@ -3288,22 +3288,22 @@ bool AttLinerend::WriteLinerend(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLinerend::HasLendsym()
+bool AttLinerend::HasLendsym() const
 {
     return (m_lendsym != LINESTARTENDSYMBOL_NONE);
 }
 
-bool AttLinerend::HasLendsymsize()
+bool AttLinerend::HasLendsymsize() const
 {
     return (m_lendsymsize != "");
 }
 
-bool AttLinerend::HasLstartsym()
+bool AttLinerend::HasLstartsym() const
 {
     return (m_lstartsym != LINESTARTENDSYMBOL_NONE);
 }
 
-bool AttLinerend::HasLstartsymsize()
+bool AttLinerend::HasLstartsymsize() const
 {
     return (m_lstartsymsize != "");
 }
@@ -3359,12 +3359,12 @@ bool AttLinerendBase::WriteLinerendBase(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLinerendBase::HasLform()
+bool AttLinerendBase::HasLform() const
 {
     return (m_lform != LINEFORM_NONE);
 }
 
-bool AttLinerendBase::HasLwidth()
+bool AttLinerendBase::HasLwidth() const
 {
     return (m_lwidth != "");
 }
@@ -3460,32 +3460,32 @@ bool AttLyricstyle::WriteLyricstyle(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttLyricstyle::HasLyricAlign()
+bool AttLyricstyle::HasLyricAlign() const
 {
     return (m_lyricAlign != "");
 }
 
-bool AttLyricstyle::HasLyricFam()
+bool AttLyricstyle::HasLyricFam() const
 {
     return (m_lyricFam != "");
 }
 
-bool AttLyricstyle::HasLyricName()
+bool AttLyricstyle::HasLyricName() const
 {
     return (m_lyricName != "");
 }
 
-bool AttLyricstyle::HasLyricSize()
+bool AttLyricstyle::HasLyricSize() const
 {
     return (m_lyricSize != "");
 }
 
-bool AttLyricstyle::HasLyricStyle()
+bool AttLyricstyle::HasLyricStyle() const
 {
     return (m_lyricStyle != FONTSTYLE_NONE);
 }
 
-bool AttLyricstyle::HasLyricWeight()
+bool AttLyricstyle::HasLyricWeight() const
 {
     return (m_lyricWeight != FONTWEIGHT_NONE);
 }
@@ -3541,12 +3541,12 @@ bool AttMeasureLog::WriteMeasureLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeasureLog::HasLeft()
+bool AttMeasureLog::HasLeft() const
 {
     return (m_left != BARRENDITION_NONE);
 }
 
-bool AttMeasureLog::HasRight()
+bool AttMeasureLog::HasRight() const
 {
     return (m_right != BARRENDITION_single);
 }
@@ -3592,7 +3592,7 @@ bool AttMeasurement::WriteMeasurement(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeasurement::HasUnit()
+bool AttMeasurement::HasUnit() const
 {
     return (m_unit != "");
 }
@@ -3638,7 +3638,7 @@ bool AttMeasurenumbers::WriteMeasurenumbers(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeasurenumbers::HasMnumVisible()
+bool AttMeasurenumbers::HasMnumVisible() const
 {
     return (m_mnumVisible != BOOLEAN_NONE);
 }
@@ -3704,17 +3704,17 @@ bool AttMediabounds::WriteMediabounds(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMediabounds::HasBegin()
+bool AttMediabounds::HasBegin() const
 {
     return (m_begin != "");
 }
 
-bool AttMediabounds::HasEnd()
+bool AttMediabounds::HasEnd() const
 {
     return (m_end != "");
 }
 
-bool AttMediabounds::HasBetype()
+bool AttMediabounds::HasBetype() const
 {
     return (m_betype != BETYPE_NONE);
 }
@@ -3760,7 +3760,7 @@ bool AttMedium::WriteMedium(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMedium::HasMedium()
+bool AttMedium::HasMedium() const
 {
     return (m_medium != "");
 }
@@ -3806,7 +3806,7 @@ bool AttMeiversion::WriteMeiversion(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeiversion::HasMeiversion()
+bool AttMeiversion::HasMeiversion() const
 {
     return (m_meiversion != meiversion_MEIVERSION_NONE);
 }
@@ -3862,12 +3862,12 @@ bool AttMensurLog::WriteMensurLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMensurLog::HasDot()
+bool AttMensurLog::HasDot() const
 {
     return (m_dot != BOOLEAN_NONE);
 }
 
-bool AttMensurLog::HasSign()
+bool AttMensurLog::HasSign() const
 {
     return (m_sign != MENSURATIONSIGN_NONE);
 }
@@ -3933,17 +3933,17 @@ bool AttMeterSigLog::WriteMeterSigLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeterSigLog::HasCount()
+bool AttMeterSigLog::HasCount() const
 {
     return (m_count != 0);
 }
 
-bool AttMeterSigLog::HasSym()
+bool AttMeterSigLog::HasSym() const
 {
     return (m_sym != METERSIGN_NONE);
 }
 
-bool AttMeterSigLog::HasUnit()
+bool AttMeterSigLog::HasUnit() const
 {
     return (m_unit != 0);
 }
@@ -3989,7 +3989,7 @@ bool AttMeterSigVis::WriteMeterSigVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeterSigVis::HasForm()
+bool AttMeterSigVis::HasForm() const
 {
     return (m_form != meterSigVis_FORM_NONE);
 }
@@ -4045,12 +4045,12 @@ bool AttMeterSigDefaultLog::WriteMeterSigDefaultLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeterSigDefaultLog::HasMeterCount()
+bool AttMeterSigDefaultLog::HasMeterCount() const
 {
     return (m_meterCount != 0);
 }
 
-bool AttMeterSigDefaultLog::HasMeterUnit()
+bool AttMeterSigDefaultLog::HasMeterUnit() const
 {
     return (m_meterUnit != 0);
 }
@@ -4116,17 +4116,17 @@ bool AttMeterSigDefaultVis::WriteMeterSigDefaultVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeterSigDefaultVis::HasMeterRend()
+bool AttMeterSigDefaultVis::HasMeterRend() const
 {
     return (m_meterRend != meterSigDefaultVis_METERREND_NONE);
 }
 
-bool AttMeterSigDefaultVis::HasMeterShowchange()
+bool AttMeterSigDefaultVis::HasMeterShowchange() const
 {
     return (m_meterShowchange != BOOLEAN_NONE);
 }
 
-bool AttMeterSigDefaultVis::HasMeterSym()
+bool AttMeterSigDefaultVis::HasMeterSym() const
 {
     return (m_meterSym != METERSIGN_NONE);
 }
@@ -4172,7 +4172,7 @@ bool AttMeterconformance::WriteMeterconformance(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeterconformance::HasMetcon()
+bool AttMeterconformance::HasMetcon() const
 {
     return (m_metcon != meterconformance_METCON_NONE);
 }
@@ -4228,12 +4228,12 @@ bool AttMeterconformanceBar::WriteMeterconformanceBar(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMeterconformanceBar::HasMetcon()
+bool AttMeterconformanceBar::HasMetcon() const
 {
     return (m_metcon != BOOLEAN_NONE);
 }
 
-bool AttMeterconformanceBar::HasControl()
+bool AttMeterconformanceBar::HasControl() const
 {
     return (m_control != BOOLEAN_NONE);
 }
@@ -4299,17 +4299,17 @@ bool AttMmtempo::WriteMmtempo(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMmtempo::HasMm()
+bool AttMmtempo::HasMm() const
 {
     return (m_mm != "");
 }
 
-bool AttMmtempo::HasMmUnit()
+bool AttMmtempo::HasMmUnit() const
 {
     return (m_mmUnit != DURATION_NONE);
 }
 
-bool AttMmtempo::HasMmDots()
+bool AttMmtempo::HasMmDots() const
 {
     return (m_mmDots != 0);
 }
@@ -4355,7 +4355,7 @@ bool AttMultinummeasures::WriteMultinummeasures(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttMultinummeasures::HasMultiNumber()
+bool AttMultinummeasures::HasMultiNumber() const
 {
     return (m_multiNumber != BOOLEAN_NONE);
 }
@@ -4411,12 +4411,12 @@ bool AttName::WriteName(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttName::HasNymref()
+bool AttName::HasNymref() const
 {
     return (m_nymref != "");
 }
 
-bool AttName::HasRole()
+bool AttName::HasRole() const
 {
     return (m_role != "");
 }
@@ -4472,12 +4472,12 @@ bool AttNotationstyle::WriteNotationstyle(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNotationstyle::HasMusicName()
+bool AttNotationstyle::HasMusicName() const
 {
     return (m_musicName != "");
 }
 
-bool AttNotationstyle::HasMusicSize()
+bool AttNotationstyle::HasMusicSize() const
 {
     return (m_musicSize != "");
 }
@@ -4543,17 +4543,17 @@ bool AttNoteGes::WriteNoteGes(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNoteGes::HasOctGes()
+bool AttNoteGes::HasOctGes() const
 {
     return (m_octGes != 0);
 }
 
-bool AttNoteGes::HasPnameGes()
+bool AttNoteGes::HasPnameGes() const
 {
     return (m_pnameGes != PITCHNAME_NONE);
 }
 
-bool AttNoteGes::HasPnum()
+bool AttNoteGes::HasPnum() const
 {
     return (m_pnum != 0);
 }
@@ -4659,37 +4659,37 @@ bool AttNoteheads::WriteNoteheads(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNoteheads::HasHeadColor()
+bool AttNoteheads::HasHeadColor() const
 {
     return (m_headColor != "");
 }
 
-bool AttNoteheads::HasHeadFill()
+bool AttNoteheads::HasHeadFill() const
 {
     return (m_headFill != "");
 }
 
-bool AttNoteheads::HasHeadFillcolor()
+bool AttNoteheads::HasHeadFillcolor() const
 {
     return (m_headFillcolor != "");
 }
 
-bool AttNoteheads::HasHeadMod()
+bool AttNoteheads::HasHeadMod() const
 {
     return (m_headMod != "");
 }
 
-bool AttNoteheads::HasHeadRotation()
+bool AttNoteheads::HasHeadRotation() const
 {
     return (m_headRotation != "");
 }
 
-bool AttNoteheads::HasHeadShape()
+bool AttNoteheads::HasHeadShape() const
 {
     return (m_headShape != "");
 }
 
-bool AttNoteheads::HasHeadVisible()
+bool AttNoteheads::HasHeadVisible() const
 {
     return (m_headVisible != BOOLEAN_NONE);
 }
@@ -4735,7 +4735,7 @@ bool AttOctave::WriteOctave(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOctave::HasOct()
+bool AttOctave::HasOct() const
 {
     return (m_oct != 0);
 }
@@ -4781,7 +4781,7 @@ bool AttOctavedefault::WriteOctavedefault(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOctavedefault::HasOctaveDefault()
+bool AttOctavedefault::HasOctaveDefault() const
 {
     return (m_octaveDefault != 0);
 }
@@ -4837,12 +4837,12 @@ bool AttOctavedisplacement::WriteOctavedisplacement(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOctavedisplacement::HasDis()
+bool AttOctavedisplacement::HasDis() const
 {
     return (m_dis != OCTAVE_DIS_NONE);
 }
 
-bool AttOctavedisplacement::HasDisPlace()
+bool AttOctavedisplacement::HasDisPlace() const
 {
     return (m_disPlace != PLACE_NONE);
 }
@@ -4888,7 +4888,7 @@ bool AttOnelinestaff::WriteOnelinestaff(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOnelinestaff::HasOntheline()
+bool AttOnelinestaff::HasOntheline() const
 {
     return (m_ontheline != BOOLEAN_NONE);
 }
@@ -4934,7 +4934,7 @@ bool AttOptimization::WriteOptimization(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttOptimization::HasOptimize()
+bool AttOptimization::HasOptimize() const
 {
     return (m_optimize != BOOLEAN_NONE);
 }
@@ -4980,7 +4980,7 @@ bool AttPadLog::WritePadLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPadLog::HasNum()
+bool AttPadLog::HasNum() const
 {
     return (m_num != 0);
 }
@@ -5096,42 +5096,42 @@ bool AttPages::WritePages(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPages::HasPageHeight()
+bool AttPages::HasPageHeight() const
 {
     return (m_pageHeight != "");
 }
 
-bool AttPages::HasPageWidth()
+bool AttPages::HasPageWidth() const
 {
     return (m_pageWidth != "");
 }
 
-bool AttPages::HasPageTopmar()
+bool AttPages::HasPageTopmar() const
 {
     return (m_pageTopmar != "");
 }
 
-bool AttPages::HasPageBotmar()
+bool AttPages::HasPageBotmar() const
 {
     return (m_pageBotmar != "");
 }
 
-bool AttPages::HasPageLeftmar()
+bool AttPages::HasPageLeftmar() const
 {
     return (m_pageLeftmar != "");
 }
 
-bool AttPages::HasPageRightmar()
+bool AttPages::HasPageRightmar() const
 {
     return (m_pageRightmar != "");
 }
 
-bool AttPages::HasPagePanels()
+bool AttPages::HasPagePanels() const
 {
     return (m_pagePanels != "");
 }
 
-bool AttPages::HasPageScale()
+bool AttPages::HasPageScale() const
 {
     return (m_pageScale != "");
 }
@@ -5177,7 +5177,7 @@ bool AttPbVis::WritePbVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPbVis::HasFolium()
+bool AttPbVis::HasFolium() const
 {
     return (m_folium != pbVis_FOLIUM_NONE);
 }
@@ -5223,7 +5223,7 @@ bool AttPitch::WritePitch(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPitch::HasPname()
+bool AttPitch::HasPname() const
 {
     return (m_pname != PITCHNAME_NONE);
 }
@@ -5269,7 +5269,7 @@ bool AttPlacement::WritePlacement(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPlacement::HasPlace()
+bool AttPlacement::HasPlace() const
 {
     return (m_place != STAFFREL_NONE);
 }
@@ -5325,12 +5325,12 @@ bool AttPlist::WritePlist(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPlist::HasPlist()
+bool AttPlist::HasPlist() const
 {
     return (m_plist != "");
 }
 
-bool AttPlist::HasEvaluate()
+bool AttPlist::HasEvaluate() const
 {
     return (m_evaluate != plist_EVALUATE_NONE);
 }
@@ -5426,32 +5426,32 @@ bool AttPointing::WritePointing(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttPointing::HasActuate()
+bool AttPointing::HasActuate() const
 {
     return (m_actuate != "");
 }
 
-bool AttPointing::HasRole()
+bool AttPointing::HasRole() const
 {
     return (m_role != "");
 }
 
-bool AttPointing::HasShow()
+bool AttPointing::HasShow() const
 {
     return (m_show != "");
 }
 
-bool AttPointing::HasTarget()
+bool AttPointing::HasTarget() const
 {
     return (m_target != "");
 }
 
-bool AttPointing::HasTargettype()
+bool AttPointing::HasTargettype() const
 {
     return (m_targettype != "");
 }
 
-bool AttPointing::HasTitle()
+bool AttPointing::HasTitle() const
 {
     return (m_title != "");
 }
@@ -5497,7 +5497,7 @@ bool AttQuantity::WriteQuantity(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttQuantity::HasQuantity()
+bool AttQuantity::HasQuantity() const
 {
     return (m_quantity != 0.0);
 }
@@ -5543,7 +5543,7 @@ bool AttRelativesize::WriteRelativesize(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttRelativesize::HasSize()
+bool AttRelativesize::HasSize() const
 {
     return (m_size != SIZE_NONE);
 }
@@ -5589,7 +5589,7 @@ bool AttResponsibility::WriteResponsibility(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttResponsibility::HasResp()
+bool AttResponsibility::HasResp() const
 {
     return (m_resp != "");
 }
@@ -5635,7 +5635,7 @@ bool AttSbVis::WriteSbVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSbVis::HasForm()
+bool AttSbVis::HasForm() const
 {
     return (m_form != sbVis_FORM_NONE);
 }
@@ -5681,7 +5681,7 @@ bool AttScalable::WriteScalable(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttScalable::HasScale()
+bool AttScalable::HasScale() const
 {
     return (m_scale != 0);
 }
@@ -5747,17 +5747,17 @@ bool AttScoreDefGes::WriteScoreDefGes(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttScoreDefGes::HasTunePname()
+bool AttScoreDefGes::HasTunePname() const
 {
     return (m_tunePname != PITCHNAME_NONE);
 }
 
-bool AttScoreDefGes::HasTuneHz()
+bool AttScoreDefGes::HasTuneHz() const
 {
     return (m_tuneHz != 0.0);
 }
 
-bool AttScoreDefGes::HasTuneTemper()
+bool AttScoreDefGes::HasTuneTemper() const
 {
     return (m_tuneTemper != TEMPERAMENT_NONE);
 }
@@ -5803,7 +5803,7 @@ bool AttScoreDefVis::WriteScoreDefVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttScoreDefVis::HasVuHeight()
+bool AttScoreDefVis::HasVuHeight() const
 {
     return (m_vuHeight != "");
 }
@@ -5849,7 +5849,7 @@ bool AttSectionVis::WriteSectionVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSectionVis::HasRestart()
+bool AttSectionVis::HasRestart() const
 {
     return (m_restart != BOOLEAN_NONE);
 }
@@ -5895,7 +5895,7 @@ bool AttSequence::WriteSequence(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSequence::HasSeq()
+bool AttSequence::HasSeq() const
 {
     return (m_seq != 0);
 }
@@ -5941,7 +5941,7 @@ bool AttSlashcount::WriteSlashcount(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSlashcount::HasSlash()
+bool AttSlashcount::HasSlash() const
 {
     return (m_slash != 0);
 }
@@ -5987,7 +5987,7 @@ bool AttSlurpresent::WriteSlurpresent(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSlurpresent::HasSlur()
+bool AttSlurpresent::HasSlur() const
 {
     return (m_slur != "");
 }
@@ -6033,7 +6033,7 @@ bool AttSpaceVis::WriteSpaceVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSpaceVis::HasCompressable()
+bool AttSpaceVis::HasCompressable() const
 {
     return (m_compressable != BOOLEAN_NONE);
 }
@@ -6109,22 +6109,22 @@ bool AttSpacing::WriteSpacing(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSpacing::HasSpacingPackexp()
+bool AttSpacing::HasSpacingPackexp() const
 {
     return (m_spacingPackexp != 0.0);
 }
 
-bool AttSpacing::HasSpacingPackfact()
+bool AttSpacing::HasSpacingPackfact() const
 {
     return (m_spacingPackfact != 0.0);
 }
 
-bool AttSpacing::HasSpacingStaff()
+bool AttSpacing::HasSpacingStaff() const
 {
     return (m_spacingStaff != "");
 }
 
-bool AttSpacing::HasSpacingSystem()
+bool AttSpacing::HasSpacingSystem() const
 {
     return (m_spacingSystem != "");
 }
@@ -6170,7 +6170,7 @@ bool AttStaffLog::WriteStaffLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffLog::HasDef()
+bool AttStaffLog::HasDef() const
 {
     return (m_def != "");
 }
@@ -6266,32 +6266,32 @@ bool AttStaffDefVis::WriteStaffDefVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffDefVis::HasGridShow()
+bool AttStaffDefVis::HasGridShow() const
 {
     return (m_gridShow != BOOLEAN_NONE);
 }
 
-bool AttStaffDefVis::HasLayerscheme()
+bool AttStaffDefVis::HasLayerscheme() const
 {
     return (m_layerscheme != LAYERSCHEME_NONE);
 }
 
-bool AttStaffDefVis::HasLines()
+bool AttStaffDefVis::HasLines() const
 {
     return (m_lines != 0);
 }
 
-bool AttStaffDefVis::HasLinesColor()
+bool AttStaffDefVis::HasLinesColor() const
 {
     return (m_linesColor != "");
 }
 
-bool AttStaffDefVis::HasLinesVisible()
+bool AttStaffDefVis::HasLinesVisible() const
 {
     return (m_linesVisible != BOOLEAN_NONE);
 }
 
-bool AttStaffDefVis::HasSpacing()
+bool AttStaffDefVis::HasSpacing() const
 {
     return (m_spacing != "");
 }
@@ -6337,7 +6337,7 @@ bool AttStaffGrpVis::WriteStaffGrpVis(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffGrpVis::HasBarthru()
+bool AttStaffGrpVis::HasBarthru() const
 {
     return (m_barthru != BOOLEAN_NONE);
 }
@@ -6383,7 +6383,7 @@ bool AttStaffgroupingsym::WriteStaffgroupingsym(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffgroupingsym::HasSymbol()
+bool AttStaffgroupingsym::HasSymbol() const
 {
     return (m_symbol != staffgroupingsym_SYMBOL_NONE);
 }
@@ -6429,7 +6429,7 @@ bool AttStaffident::WriteStaffident(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffident::HasStaff()
+bool AttStaffident::HasStaff() const
 {
     return (m_staff != std::vector<int>());
 }
@@ -6475,7 +6475,7 @@ bool AttStaffloc::WriteStaffloc(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffloc::HasLoc()
+bool AttStaffloc::HasLoc() const
 {
     return (m_loc != 0);
 }
@@ -6531,12 +6531,12 @@ bool AttStafflocPitched::WriteStafflocPitched(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStafflocPitched::HasPloc()
+bool AttStafflocPitched::HasPloc() const
 {
     return (m_ploc != PITCHNAME_NONE);
 }
 
-bool AttStafflocPitched::HasOloc()
+bool AttStafflocPitched::HasOloc() const
 {
     return (m_oloc != 0);
 }
@@ -6582,7 +6582,7 @@ bool AttStartendid::WriteStartendid(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStartendid::HasEndid()
+bool AttStartendid::HasEndid() const
 {
     return (m_endid != "");
 }
@@ -6628,7 +6628,7 @@ bool AttStartid::WriteStartid(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStartid::HasStartid()
+bool AttStartid::HasStartid() const
 {
     return (m_startid != "");
 }
@@ -6724,32 +6724,32 @@ bool AttStems::WriteStems(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStems::HasStemDir()
+bool AttStems::HasStemDir() const
 {
     return (m_stemDir != STEMDIRECTION_NONE);
 }
 
-bool AttStems::HasStemLen()
+bool AttStems::HasStemLen() const
 {
     return (m_stemLen != "");
 }
 
-bool AttStems::HasStemMod()
+bool AttStems::HasStemMod() const
 {
     return (m_stemMod != STEMMODIFIER_NONE);
 }
 
-bool AttStems::HasStemPos()
+bool AttStems::HasStemPos() const
 {
     return (m_stemPos != STEMPOSITION_NONE);
 }
 
-bool AttStems::HasStemX()
+bool AttStems::HasStemX() const
 {
     return (m_stemX != 0.0);
 }
 
-bool AttStems::HasStemY()
+bool AttStems::HasStemY() const
 {
     return (m_stemY != 0.0);
 }
@@ -6805,12 +6805,12 @@ bool AttSylLog::WriteSylLog(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSylLog::HasCon()
+bool AttSylLog::HasCon() const
 {
     return (m_con != sylLog_CON_NONE);
 }
 
-bool AttSylLog::HasWordpos()
+bool AttSylLog::HasWordpos() const
 {
     return (m_wordpos != sylLog_WORDPOS_NONE);
 }
@@ -6856,7 +6856,7 @@ bool AttSyltext::WriteSyltext(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSyltext::HasSyl()
+bool AttSyltext::HasSyl() const
 {
     return (m_syl != "");
 }
@@ -6932,22 +6932,22 @@ bool AttSystems::WriteSystems(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttSystems::HasSystemLeftline()
+bool AttSystems::HasSystemLeftline() const
 {
     return (m_systemLeftline != BOOLEAN_NONE);
 }
 
-bool AttSystems::HasSystemLeftmar()
+bool AttSystems::HasSystemLeftmar() const
 {
     return (m_systemLeftmar != "");
 }
 
-bool AttSystems::HasSystemRightmar()
+bool AttSystems::HasSystemRightmar() const
 {
     return (m_systemRightmar != "");
 }
 
-bool AttSystems::HasSystemTopmar()
+bool AttSystems::HasSystemTopmar() const
 {
     return (m_systemTopmar != "");
 }
@@ -7033,27 +7033,27 @@ bool AttTextstyle::WriteTextstyle(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTextstyle::HasTextFam()
+bool AttTextstyle::HasTextFam() const
 {
     return (m_textFam != "");
 }
 
-bool AttTextstyle::HasTextName()
+bool AttTextstyle::HasTextName() const
 {
     return (m_textName != "");
 }
 
-bool AttTextstyle::HasTextSize()
+bool AttTextstyle::HasTextSize() const
 {
     return (m_textSize != "");
 }
 
-bool AttTextstyle::HasTextStyle()
+bool AttTextstyle::HasTextStyle() const
 {
     return (m_textStyle != FONTSTYLE_NONE);
 }
 
-bool AttTextstyle::HasTextWeight()
+bool AttTextstyle::HasTextWeight() const
 {
     return (m_textWeight != FONTWEIGHT_NONE);
 }
@@ -7099,7 +7099,7 @@ bool AttTiepresent::WriteTiepresent(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTiepresent::HasTie()
+bool AttTiepresent::HasTie() const
 {
     return (m_tie != TIE_NONE);
 }
@@ -7145,7 +7145,7 @@ bool AttTimestampMusical::WriteTimestampMusical(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTimestampMusical::HasTstamp()
+bool AttTimestampMusical::HasTstamp() const
 {
     return (m_tstamp != -1.0);
 }
@@ -7201,12 +7201,12 @@ bool AttTimestampPerformed::WriteTimestampPerformed(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTimestampPerformed::HasTstampGes()
+bool AttTimestampPerformed::HasTstampGes() const
 {
     return (m_tstampGes != DURATION_NONE);
 }
 
-bool AttTimestampPerformed::HasTstampReal()
+bool AttTimestampPerformed::HasTstampReal() const
 {
     return (m_tstampReal != "");
 }
@@ -7252,7 +7252,7 @@ bool AttTimestamp2Musical::WriteTimestamp2Musical(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTimestamp2Musical::HasTstamp2()
+bool AttTimestamp2Musical::HasTstamp2() const
 {
     return (m_tstamp2 != std::make_pair(-1,-1.0));
 }
@@ -7308,12 +7308,12 @@ bool AttTransposition::WriteTransposition(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTransposition::HasTransDiat()
+bool AttTransposition::HasTransDiat() const
 {
     return (m_transDiat != 0.0);
 }
 
-bool AttTransposition::HasTransSemi()
+bool AttTransposition::HasTransSemi() const
 {
     return (m_transSemi != 0.0);
 }
@@ -7359,7 +7359,7 @@ bool AttTupletpresent::WriteTupletpresent(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTupletpresent::HasTuplet()
+bool AttTupletpresent::HasTuplet() const
 {
     return (m_tuplet != "");
 }
@@ -7415,12 +7415,12 @@ bool AttTyped::WriteTyped(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTyped::HasType()
+bool AttTyped::HasType() const
 {
     return (m_type != "");
 }
 
-bool AttTyped::HasSubtype()
+bool AttTyped::HasSubtype() const
 {
     return (m_subtype != "");
 }
@@ -7506,27 +7506,27 @@ bool AttTypography::WriteTypography(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttTypography::HasFontfam()
+bool AttTypography::HasFontfam() const
 {
     return (m_fontfam != "");
 }
 
-bool AttTypography::HasFontname()
+bool AttTypography::HasFontname() const
 {
     return (m_fontname != "");
 }
 
-bool AttTypography::HasFontsize()
+bool AttTypography::HasFontsize() const
 {
     return (m_fontsize != 0.0);
 }
 
-bool AttTypography::HasFontstyle()
+bool AttTypography::HasFontstyle() const
 {
     return (m_fontstyle != FONTSTYLE_NONE);
 }
 
-bool AttTypography::HasFontweight()
+bool AttTypography::HasFontweight() const
 {
     return (m_fontweight != FONTWEIGHT_NONE);
 }
@@ -7572,7 +7572,7 @@ bool AttVisibility::WriteVisibility(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisibility::HasVisible()
+bool AttVisibility::HasVisible() const
 {
     return (m_visible != BOOLEAN_NONE);
 }
@@ -7618,7 +7618,7 @@ bool AttVisualoffsetHo::WriteVisualoffsetHo(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisualoffsetHo::HasHo()
+bool AttVisualoffsetHo::HasHo() const
 {
     return (m_ho != "");
 }
@@ -7664,7 +7664,7 @@ bool AttVisualoffsetTo::WriteVisualoffsetTo(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisualoffsetTo::HasTo()
+bool AttVisualoffsetTo::HasTo() const
 {
     return (m_to != 0.0);
 }
@@ -7710,7 +7710,7 @@ bool AttVisualoffsetVo::WriteVisualoffsetVo(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisualoffsetVo::HasVo()
+bool AttVisualoffsetVo::HasVo() const
 {
     return (m_vo != "");
 }
@@ -7766,12 +7766,12 @@ bool AttVisualoffset2Ho::WriteVisualoffset2Ho(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisualoffset2Ho::HasStartho()
+bool AttVisualoffset2Ho::HasStartho() const
 {
     return (m_startho != "");
 }
 
-bool AttVisualoffset2Ho::HasEndho()
+bool AttVisualoffset2Ho::HasEndho() const
 {
     return (m_endho != "");
 }
@@ -7827,12 +7827,12 @@ bool AttVisualoffset2To::WriteVisualoffset2To(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisualoffset2To::HasStartto()
+bool AttVisualoffset2To::HasStartto() const
 {
     return (m_startto != 0.0);
 }
 
-bool AttVisualoffset2To::HasEndto()
+bool AttVisualoffset2To::HasEndto() const
 {
     return (m_endto != 0.0);
 }
@@ -7888,12 +7888,12 @@ bool AttVisualoffset2Vo::WriteVisualoffset2Vo(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttVisualoffset2Vo::HasStartvo()
+bool AttVisualoffset2Vo::HasStartvo() const
 {
     return (m_startvo != "");
 }
 
-bool AttVisualoffset2Vo::HasEndvo()
+bool AttVisualoffset2Vo::HasEndvo() const
 {
     return (m_endvo != "");
 }
@@ -7939,7 +7939,7 @@ bool AttWhitespace::WriteWhitespace(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttWhitespace::HasSpace()
+bool AttWhitespace::HasSpace() const
 {
     return (m_space != "");
 }
@@ -7985,7 +7985,7 @@ bool AttWidth::WriteWidth(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttWidth::HasWidth()
+bool AttWidth::HasWidth() const
 {
     return (m_width != "");
 }
@@ -8041,12 +8041,12 @@ bool AttXy::WriteXy(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttXy::HasX()
+bool AttXy::HasX() const
 {
     return (m_x != 0.0);
 }
 
-bool AttXy::HasY()
+bool AttXy::HasY() const
 {
     return (m_y != 0.0);
 }
@@ -8102,12 +8102,12 @@ bool AttXy2::WriteXy2(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttXy2::HasX2()
+bool AttXy2::HasX2() const
 {
     return (m_x2 != 0.0);
 }
 
-bool AttXy2::HasY2()
+bool AttXy2::HasY2() const
 {
     return (m_y2 != 0.0);
 }
@@ -9688,52 +9688,52 @@ bool Att::SetShared(Object *element, std::string attrType, std::string attrValue
     return false;
 }
 
-void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetShared(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_ACCIDLOG)) {
-        AttAccidLog *att = dynamic_cast<AttAccidLog *>(element);
+        const AttAccidLog *att = dynamic_cast<const AttAccidLog *>(element);
         assert(att);
         if (att->HasFunc()) {
             attributes->push_back(std::make_pair("func", att->AccidLogFuncToStr(att->GetFunc())));
         }
     }
     if (element->HasAttClass(ATT_ACCIDENTAL)) {
-        AttAccidental *att = dynamic_cast<AttAccidental *>(element);
+        const AttAccidental *att = dynamic_cast<const AttAccidental *>(element);
         assert(att);
         if (att->HasAccid()) {
             attributes->push_back(std::make_pair("accid", att->AccidentalExplicitToStr(att->GetAccid())));
         }
     }
     if (element->HasAttClass(ATT_ACCIDENTALPERFORMED)) {
-        AttAccidentalPerformed *att = dynamic_cast<AttAccidentalPerformed *>(element);
+        const AttAccidentalPerformed *att = dynamic_cast<const AttAccidentalPerformed *>(element);
         assert(att);
         if (att->HasAccidGes()) {
             attributes->push_back(std::make_pair("accid.ges", att->AccidentalImplicitToStr(att->GetAccidGes())));
         }
     }
     if (element->HasAttClass(ATT_ARTICULATION)) {
-        AttArticulation *att = dynamic_cast<AttArticulation *>(element);
+        const AttArticulation *att = dynamic_cast<const AttArticulation *>(element);
         assert(att);
         if (att->HasArtic()) {
             attributes->push_back(std::make_pair("artic", att->ArticulationToStr(att->GetArtic())));
         }
     }
     if (element->HasAttClass(ATT_ARTICULATIONPERFORMED)) {
-        AttArticulationPerformed *att = dynamic_cast<AttArticulationPerformed *>(element);
+        const AttArticulationPerformed *att = dynamic_cast<const AttArticulationPerformed *>(element);
         assert(att);
         if (att->HasArticGes()) {
             attributes->push_back(std::make_pair("artic.ges", att->ArticulationToStr(att->GetArticGes())));
         }
     }
     if (element->HasAttClass(ATT_AUGMENTDOTS)) {
-        AttAugmentdots *att = dynamic_cast<AttAugmentdots *>(element);
+        const AttAugmentdots *att = dynamic_cast<const AttAugmentdots *>(element);
         assert(att);
         if (att->HasDots()) {
             attributes->push_back(std::make_pair("dots", att->IntToStr(att->GetDots())));
         }
     }
     if (element->HasAttClass(ATT_AUTHORIZED)) {
-        AttAuthorized *att = dynamic_cast<AttAuthorized *>(element);
+        const AttAuthorized *att = dynamic_cast<const AttAuthorized *>(element);
         assert(att);
         if (att->HasAuthority()) {
             attributes->push_back(std::make_pair("authority", att->StrToStr(att->GetAuthority())));
@@ -9743,14 +9743,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_BARLINELOG)) {
-        AttBarLineLog *att = dynamic_cast<AttBarLineLog *>(element);
+        const AttBarLineLog *att = dynamic_cast<const AttBarLineLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->BarrenditionToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_BARPLACEMENT)) {
-        AttBarplacement *att = dynamic_cast<AttBarplacement *>(element);
+        const AttBarplacement *att = dynamic_cast<const AttBarplacement *>(element);
         assert(att);
         if (att->HasBarplace()) {
             attributes->push_back(std::make_pair("barplace", att->BarplaceToStr(att->GetBarplace())));
@@ -9760,7 +9760,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_BEAMINGVIS)) {
-        AttBeamingVis *att = dynamic_cast<AttBeamingVis *>(element);
+        const AttBeamingVis *att = dynamic_cast<const AttBeamingVis *>(element);
         assert(att);
         if (att->HasBeamColor()) {
             attributes->push_back(std::make_pair("beam.color", att->StrToStr(att->GetBeamColor())));
@@ -9773,49 +9773,49 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_BIBL)) {
-        AttBibl *att = dynamic_cast<AttBibl *>(element);
+        const AttBibl *att = dynamic_cast<const AttBibl *>(element);
         assert(att);
         if (att->HasAnalog()) {
             attributes->push_back(std::make_pair("analog", att->StrToStr(att->GetAnalog())));
         }
     }
     if (element->HasAttClass(ATT_CALENDARED)) {
-        AttCalendared *att = dynamic_cast<AttCalendared *>(element);
+        const AttCalendared *att = dynamic_cast<const AttCalendared *>(element);
         assert(att);
         if (att->HasCalendar()) {
             attributes->push_back(std::make_pair("calendar", att->StrToStr(att->GetCalendar())));
         }
     }
     if (element->HasAttClass(ATT_CANONICAL)) {
-        AttCanonical *att = dynamic_cast<AttCanonical *>(element);
+        const AttCanonical *att = dynamic_cast<const AttCanonical *>(element);
         assert(att);
         if (att->HasCodedval()) {
             attributes->push_back(std::make_pair("codedval", att->StrToStr(att->GetCodedval())));
         }
     }
     if (element->HasAttClass(ATT_CHORDVIS)) {
-        AttChordVis *att = dynamic_cast<AttChordVis *>(element);
+        const AttChordVis *att = dynamic_cast<const AttChordVis *>(element);
         assert(att);
         if (att->HasCluster()) {
             attributes->push_back(std::make_pair("cluster", att->ClusterToStr(att->GetCluster())));
         }
     }
     if (element->HasAttClass(ATT_CLASSCODEIDENT)) {
-        AttClasscodeident *att = dynamic_cast<AttClasscodeident *>(element);
+        const AttClasscodeident *att = dynamic_cast<const AttClasscodeident *>(element);
         assert(att);
         if (att->HasClasscode()) {
             attributes->push_back(std::make_pair("classcode", att->StrToStr(att->GetClasscode())));
         }
     }
     if (element->HasAttClass(ATT_CLEFLOG)) {
-        AttClefLog *att = dynamic_cast<AttClefLog *>(element);
+        const AttClefLog *att = dynamic_cast<const AttClefLog *>(element);
         assert(att);
         if (att->HasCautionary()) {
             attributes->push_back(std::make_pair("cautionary", att->BooleanToStr(att->GetCautionary())));
         }
     }
     if (element->HasAttClass(ATT_CLEFFINGLOG)) {
-        AttCleffingLog *att = dynamic_cast<AttCleffingLog *>(element);
+        const AttCleffingLog *att = dynamic_cast<const AttCleffingLog *>(element);
         assert(att);
         if (att->HasClefShape()) {
             attributes->push_back(std::make_pair("clef.shape", att->ClefshapeToStr(att->GetClefShape())));
@@ -9831,7 +9831,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_CLEFFINGVIS)) {
-        AttCleffingVis *att = dynamic_cast<AttCleffingVis *>(element);
+        const AttCleffingVis *att = dynamic_cast<const AttCleffingVis *>(element);
         assert(att);
         if (att->HasClefColor()) {
             attributes->push_back(std::make_pair("clef.color", att->StrToStr(att->GetClefColor())));
@@ -9841,35 +9841,35 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_CLEFSHAPE)) {
-        AttClefshape *att = dynamic_cast<AttClefshape *>(element);
+        const AttClefshape *att = dynamic_cast<const AttClefshape *>(element);
         assert(att);
         if (att->HasShape()) {
             attributes->push_back(std::make_pair("shape", att->ClefshapeToStr(att->GetShape())));
         }
     }
     if (element->HasAttClass(ATT_COLOR)) {
-        AttColor *att = dynamic_cast<AttColor *>(element);
+        const AttColor *att = dynamic_cast<const AttColor *>(element);
         assert(att);
         if (att->HasColor()) {
             attributes->push_back(std::make_pair("color", att->StrToStr(att->GetColor())));
         }
     }
     if (element->HasAttClass(ATT_COLORATION)) {
-        AttColoration *att = dynamic_cast<AttColoration *>(element);
+        const AttColoration *att = dynamic_cast<const AttColoration *>(element);
         assert(att);
         if (att->HasColored()) {
             attributes->push_back(std::make_pair("colored", att->BooleanToStr(att->GetColored())));
         }
     }
     if (element->HasAttClass(ATT_COMMON)) {
-        AttCommon *att = dynamic_cast<AttCommon *>(element);
+        const AttCommon *att = dynamic_cast<const AttCommon *>(element);
         assert(att);
         if (att->HasN()) {
             attributes->push_back(std::make_pair("n", att->IntToStr(att->GetN())));
         }
     }
     if (element->HasAttClass(ATT_COMMONPART)) {
-        AttCommonPart *att = dynamic_cast<AttCommonPart *>(element);
+        const AttCommonPart *att = dynamic_cast<const AttCommonPart *>(element);
         assert(att);
         if (att->HasLabel()) {
             attributes->push_back(std::make_pair("label", att->StrToStr(att->GetLabel())));
@@ -9879,7 +9879,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_COORDINATED)) {
-        AttCoordinated *att = dynamic_cast<AttCoordinated *>(element);
+        const AttCoordinated *att = dynamic_cast<const AttCoordinated *>(element);
         assert(att);
         if (att->HasUlx()) {
             attributes->push_back(std::make_pair("ulx", att->IntToStr(att->GetUlx())));
@@ -9895,7 +9895,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_CURVATURE)) {
-        AttCurvature *att = dynamic_cast<AttCurvature *>(element);
+        const AttCurvature *att = dynamic_cast<const AttCurvature *>(element);
         assert(att);
         if (att->HasBezier()) {
             attributes->push_back(std::make_pair("bezier", att->StrToStr(att->GetBezier())));
@@ -9908,7 +9908,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_CURVEREND)) {
-        AttCurverend *att = dynamic_cast<AttCurverend *>(element);
+        const AttCurverend *att = dynamic_cast<const AttCurverend *>(element);
         assert(att);
         if (att->HasLform()) {
             attributes->push_back(std::make_pair("lform", att->LineformToStr(att->GetLform())));
@@ -9918,14 +9918,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_CUSTOSLOG)) {
-        AttCustosLog *att = dynamic_cast<AttCustosLog *>(element);
+        const AttCustosLog *att = dynamic_cast<const AttCustosLog *>(element);
         assert(att);
         if (att->HasTarget()) {
             attributes->push_back(std::make_pair("target", att->StrToStr(att->GetTarget())));
         }
     }
     if (element->HasAttClass(ATT_DATABLE)) {
-        AttDatable *att = dynamic_cast<AttDatable *>(element);
+        const AttDatable *att = dynamic_cast<const AttDatable *>(element);
         assert(att);
         if (att->HasEnddate()) {
             attributes->push_back(std::make_pair("enddate", att->StrToStr(att->GetEnddate())));
@@ -9944,21 +9944,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_DATAPOINTING)) {
-        AttDatapointing *att = dynamic_cast<AttDatapointing *>(element);
+        const AttDatapointing *att = dynamic_cast<const AttDatapointing *>(element);
         assert(att);
         if (att->HasData()) {
             attributes->push_back(std::make_pair("data", att->StrToStr(att->GetData())));
         }
     }
     if (element->HasAttClass(ATT_DECLARING)) {
-        AttDeclaring *att = dynamic_cast<AttDeclaring *>(element);
+        const AttDeclaring *att = dynamic_cast<const AttDeclaring *>(element);
         assert(att);
         if (att->HasDecls()) {
             attributes->push_back(std::make_pair("decls", att->StrToStr(att->GetDecls())));
         }
     }
     if (element->HasAttClass(ATT_DISTANCES)) {
-        AttDistances *att = dynamic_cast<AttDistances *>(element);
+        const AttDistances *att = dynamic_cast<const AttDistances *>(element);
         assert(att);
         if (att->HasDynamDist()) {
             attributes->push_back(std::make_pair("dynam.dist", att->StrToStr(att->GetDynamDist())));
@@ -9971,21 +9971,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_DOTLOG)) {
-        AttDotLog *att = dynamic_cast<AttDotLog *>(element);
+        const AttDotLog *att = dynamic_cast<const AttDotLog *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->DotLogFormToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_DURATIONADDITIVE)) {
-        AttDurationAdditive *att = dynamic_cast<AttDurationAdditive *>(element);
+        const AttDurationAdditive *att = dynamic_cast<const AttDurationAdditive *>(element);
         assert(att);
         if (att->HasDur()) {
             attributes->push_back(std::make_pair("dur", att->DurationToStr(att->GetDur())));
         }
     }
     if (element->HasAttClass(ATT_DURATIONDEFAULT)) {
-        AttDurationDefault *att = dynamic_cast<AttDurationDefault *>(element);
+        const AttDurationDefault *att = dynamic_cast<const AttDurationDefault *>(element);
         assert(att);
         if (att->HasDurDefault()) {
             attributes->push_back(std::make_pair("dur.default", att->DurationToStr(att->GetDurDefault())));
@@ -9998,21 +9998,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_DURATIONMUSICAL)) {
-        AttDurationMusical *att = dynamic_cast<AttDurationMusical *>(element);
+        const AttDurationMusical *att = dynamic_cast<const AttDurationMusical *>(element);
         assert(att);
         if (att->HasDur()) {
             attributes->push_back(std::make_pair("dur", att->DurationToStr(att->GetDur())));
         }
     }
     if (element->HasAttClass(ATT_DURATIONPERFORMED)) {
-        AttDurationPerformed *att = dynamic_cast<AttDurationPerformed *>(element);
+        const AttDurationPerformed *att = dynamic_cast<const AttDurationPerformed *>(element);
         assert(att);
         if (att->HasDurGes()) {
             attributes->push_back(std::make_pair("dur.ges", att->DurationToStr(att->GetDurGes())));
         }
     }
     if (element->HasAttClass(ATT_DURATIONRATIO)) {
-        AttDurationRatio *att = dynamic_cast<AttDurationRatio *>(element);
+        const AttDurationRatio *att = dynamic_cast<const AttDurationRatio *>(element);
         assert(att);
         if (att->HasNum()) {
             attributes->push_back(std::make_pair("num", att->IntToStr(att->GetNum())));
@@ -10022,98 +10022,98 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_ENCLOSINGCHARS)) {
-        AttEnclosingchars *att = dynamic_cast<AttEnclosingchars *>(element);
+        const AttEnclosingchars *att = dynamic_cast<const AttEnclosingchars *>(element);
         assert(att);
         if (att->HasEnclose()) {
             attributes->push_back(std::make_pair("enclose", att->EnclosureToStr(att->GetEnclose())));
         }
     }
     if (element->HasAttClass(ATT_ENDINGS)) {
-        AttEndings *att = dynamic_cast<AttEndings *>(element);
+        const AttEndings *att = dynamic_cast<const AttEndings *>(element);
         assert(att);
         if (att->HasEndingRend()) {
             attributes->push_back(std::make_pair("ending.rend", att->EndingsEndingrendToStr(att->GetEndingRend())));
         }
     }
     if (element->HasAttClass(ATT_EXTENDER)) {
-        AttExtender *att = dynamic_cast<AttExtender *>(element);
+        const AttExtender *att = dynamic_cast<const AttExtender *>(element);
         assert(att);
         if (att->HasExtender()) {
             attributes->push_back(std::make_pair("extender", att->BooleanToStr(att->GetExtender())));
         }
     }
     if (element->HasAttClass(ATT_FERMATAPRESENT)) {
-        AttFermatapresent *att = dynamic_cast<AttFermatapresent *>(element);
+        const AttFermatapresent *att = dynamic_cast<const AttFermatapresent *>(element);
         assert(att);
         if (att->HasFermata()) {
             attributes->push_back(std::make_pair("fermata", att->PlaceToStr(att->GetFermata())));
         }
     }
     if (element->HasAttClass(ATT_FILING)) {
-        AttFiling *att = dynamic_cast<AttFiling *>(element);
+        const AttFiling *att = dynamic_cast<const AttFiling *>(element);
         assert(att);
         if (att->HasNonfiling()) {
             attributes->push_back(std::make_pair("nonfiling", att->IntToStr(att->GetNonfiling())));
         }
     }
     if (element->HasAttClass(ATT_GRPSYMLOG)) {
-        AttGrpSymLog *att = dynamic_cast<AttGrpSymLog *>(element);
+        const AttGrpSymLog *att = dynamic_cast<const AttGrpSymLog *>(element);
         assert(att);
         if (att->HasLevel()) {
             attributes->push_back(std::make_pair("level", att->IntToStr(att->GetLevel())));
         }
     }
     if (element->HasAttClass(ATT_HANDIDENT)) {
-        AttHandident *att = dynamic_cast<AttHandident *>(element);
+        const AttHandident *att = dynamic_cast<const AttHandident *>(element);
         assert(att);
         if (att->HasHand()) {
             attributes->push_back(std::make_pair("hand", att->StrToStr(att->GetHand())));
         }
     }
     if (element->HasAttClass(ATT_HEIGHT)) {
-        AttHeight *att = dynamic_cast<AttHeight *>(element);
+        const AttHeight *att = dynamic_cast<const AttHeight *>(element);
         assert(att);
         if (att->HasHeight()) {
             attributes->push_back(std::make_pair("height", att->StrToStr(att->GetHeight())));
         }
     }
     if (element->HasAttClass(ATT_HORIZONTALALIGN)) {
-        AttHorizontalalign *att = dynamic_cast<AttHorizontalalign *>(element);
+        const AttHorizontalalign *att = dynamic_cast<const AttHorizontalalign *>(element);
         assert(att);
         if (att->HasHalign()) {
             attributes->push_back(std::make_pair("halign", att->HorizontalalignmentToStr(att->GetHalign())));
         }
     }
     if (element->HasAttClass(ATT_INSTRUMENTIDENT)) {
-        AttInstrumentident *att = dynamic_cast<AttInstrumentident *>(element);
+        const AttInstrumentident *att = dynamic_cast<const AttInstrumentident *>(element);
         assert(att);
         if (att->HasInstr()) {
             attributes->push_back(std::make_pair("instr", att->StrToStr(att->GetInstr())));
         }
     }
     if (element->HasAttClass(ATT_INTERNETMEDIA)) {
-        AttInternetmedia *att = dynamic_cast<AttInternetmedia *>(element);
+        const AttInternetmedia *att = dynamic_cast<const AttInternetmedia *>(element);
         assert(att);
         if (att->HasMimetype()) {
             attributes->push_back(std::make_pair("mimetype", att->StrToStr(att->GetMimetype())));
         }
     }
     if (element->HasAttClass(ATT_JOINED)) {
-        AttJoined *att = dynamic_cast<AttJoined *>(element);
+        const AttJoined *att = dynamic_cast<const AttJoined *>(element);
         assert(att);
         if (att->HasJoin()) {
             attributes->push_back(std::make_pair("join", att->StrToStr(att->GetJoin())));
         }
     }
     if (element->HasAttClass(ATT_KEYSIGLOG)) {
-        AttKeySigLog *att = dynamic_cast<AttKeySigLog *>(element);
+        const AttKeySigLog *att = dynamic_cast<const AttKeySigLog *>(element);
         assert(att);
         if (att->HasMode()) {
             attributes->push_back(std::make_pair("mode", att->ModeToStr(att->GetMode())));
         }
     }
     if (element->HasAttClass(ATT_KEYSIGDEFAULTLOG)) {
-        AttKeySigDefaultLog *att = dynamic_cast<AttKeySigDefaultLog *>(element);
+        const AttKeySigDefaultLog *att = dynamic_cast<const AttKeySigDefaultLog *>(element);
         assert(att);
         if (att->HasKeyAccid()) {
             attributes->push_back(std::make_pair("key.accid", att->AccidentalImplicitToStr(att->GetKeyAccid())));
@@ -10132,7 +10132,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_KEYSIGDEFAULTVIS)) {
-        AttKeySigDefaultVis *att = dynamic_cast<AttKeySigDefaultVis *>(element);
+        const AttKeySigDefaultVis *att = dynamic_cast<const AttKeySigDefaultVis *>(element);
         assert(att);
         if (att->HasKeySigShow()) {
             attributes->push_back(std::make_pair("key.sig.show", att->BooleanToStr(att->GetKeySigShow())));
@@ -10142,14 +10142,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_LABELSADDL)) {
-        AttLabelsAddl *att = dynamic_cast<AttLabelsAddl *>(element);
+        const AttLabelsAddl *att = dynamic_cast<const AttLabelsAddl *>(element);
         assert(att);
         if (att->HasLabelAbbr()) {
             attributes->push_back(std::make_pair("label.abbr", att->StrToStr(att->GetLabelAbbr())));
         }
     }
     if (element->HasAttClass(ATT_LANG)) {
-        AttLang *att = dynamic_cast<AttLang *>(element);
+        const AttLang *att = dynamic_cast<const AttLang *>(element);
         assert(att);
         if (att->HasLang()) {
             attributes->push_back(std::make_pair("xml:lang", att->StrToStr(att->GetLang())));
@@ -10159,21 +10159,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_LAYERLOG)) {
-        AttLayerLog *att = dynamic_cast<AttLayerLog *>(element);
+        const AttLayerLog *att = dynamic_cast<const AttLayerLog *>(element);
         assert(att);
         if (att->HasDef()) {
             attributes->push_back(std::make_pair("def", att->StrToStr(att->GetDef())));
         }
     }
     if (element->HasAttClass(ATT_LAYERIDENT)) {
-        AttLayerident *att = dynamic_cast<AttLayerident *>(element);
+        const AttLayerident *att = dynamic_cast<const AttLayerident *>(element);
         assert(att);
         if (att->HasLayer()) {
             attributes->push_back(std::make_pair("layer", att->IntToStr(att->GetLayer())));
         }
     }
     if (element->HasAttClass(ATT_LINEVIS)) {
-        AttLineVis *att = dynamic_cast<AttLineVis *>(element);
+        const AttLineVis *att = dynamic_cast<const AttLineVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->LineformToStr(att->GetForm())));
@@ -10195,14 +10195,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_LINELOC)) {
-        AttLineloc *att = dynamic_cast<AttLineloc *>(element);
+        const AttLineloc *att = dynamic_cast<const AttLineloc *>(element);
         assert(att);
         if (att->HasLine()) {
             attributes->push_back(std::make_pair("line", att->IntToStr(att->GetLine())));
         }
     }
     if (element->HasAttClass(ATT_LINEREND)) {
-        AttLinerend *att = dynamic_cast<AttLinerend *>(element);
+        const AttLinerend *att = dynamic_cast<const AttLinerend *>(element);
         assert(att);
         if (att->HasLendsym()) {
             attributes->push_back(std::make_pair("lendsym", att->LinestartendsymbolToStr(att->GetLendsym())));
@@ -10218,7 +10218,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_LINERENDBASE)) {
-        AttLinerendBase *att = dynamic_cast<AttLinerendBase *>(element);
+        const AttLinerendBase *att = dynamic_cast<const AttLinerendBase *>(element);
         assert(att);
         if (att->HasLform()) {
             attributes->push_back(std::make_pair("lform", att->LineformToStr(att->GetLform())));
@@ -10228,7 +10228,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_LYRICSTYLE)) {
-        AttLyricstyle *att = dynamic_cast<AttLyricstyle *>(element);
+        const AttLyricstyle *att = dynamic_cast<const AttLyricstyle *>(element);
         assert(att);
         if (att->HasLyricAlign()) {
             attributes->push_back(std::make_pair("lyric.align", att->StrToStr(att->GetLyricAlign())));
@@ -10250,7 +10250,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MEASURELOG)) {
-        AttMeasureLog *att = dynamic_cast<AttMeasureLog *>(element);
+        const AttMeasureLog *att = dynamic_cast<const AttMeasureLog *>(element);
         assert(att);
         if (att->HasLeft()) {
             attributes->push_back(std::make_pair("left", att->BarrenditionToStr(att->GetLeft())));
@@ -10260,21 +10260,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MEASUREMENT)) {
-        AttMeasurement *att = dynamic_cast<AttMeasurement *>(element);
+        const AttMeasurement *att = dynamic_cast<const AttMeasurement *>(element);
         assert(att);
         if (att->HasUnit()) {
             attributes->push_back(std::make_pair("unit", att->StrToStr(att->GetUnit())));
         }
     }
     if (element->HasAttClass(ATT_MEASURENUMBERS)) {
-        AttMeasurenumbers *att = dynamic_cast<AttMeasurenumbers *>(element);
+        const AttMeasurenumbers *att = dynamic_cast<const AttMeasurenumbers *>(element);
         assert(att);
         if (att->HasMnumVisible()) {
             attributes->push_back(std::make_pair("mnum.visible", att->BooleanToStr(att->GetMnumVisible())));
         }
     }
     if (element->HasAttClass(ATT_MEDIABOUNDS)) {
-        AttMediabounds *att = dynamic_cast<AttMediabounds *>(element);
+        const AttMediabounds *att = dynamic_cast<const AttMediabounds *>(element);
         assert(att);
         if (att->HasBegin()) {
             attributes->push_back(std::make_pair("begin", att->StrToStr(att->GetBegin())));
@@ -10287,21 +10287,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MEDIUM)) {
-        AttMedium *att = dynamic_cast<AttMedium *>(element);
+        const AttMedium *att = dynamic_cast<const AttMedium *>(element);
         assert(att);
         if (att->HasMedium()) {
             attributes->push_back(std::make_pair("medium", att->StrToStr(att->GetMedium())));
         }
     }
     if (element->HasAttClass(ATT_MEIVERSION)) {
-        AttMeiversion *att = dynamic_cast<AttMeiversion *>(element);
+        const AttMeiversion *att = dynamic_cast<const AttMeiversion *>(element);
         assert(att);
         if (att->HasMeiversion()) {
             attributes->push_back(std::make_pair("meiversion", att->MeiversionMeiversionToStr(att->GetMeiversion())));
         }
     }
     if (element->HasAttClass(ATT_MENSURLOG)) {
-        AttMensurLog *att = dynamic_cast<AttMensurLog *>(element);
+        const AttMensurLog *att = dynamic_cast<const AttMensurLog *>(element);
         assert(att);
         if (att->HasDot()) {
             attributes->push_back(std::make_pair("dot", att->BooleanToStr(att->GetDot())));
@@ -10311,7 +10311,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_METERSIGLOG)) {
-        AttMeterSigLog *att = dynamic_cast<AttMeterSigLog *>(element);
+        const AttMeterSigLog *att = dynamic_cast<const AttMeterSigLog *>(element);
         assert(att);
         if (att->HasCount()) {
             attributes->push_back(std::make_pair("count", att->IntToStr(att->GetCount())));
@@ -10324,14 +10324,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_METERSIGVIS)) {
-        AttMeterSigVis *att = dynamic_cast<AttMeterSigVis *>(element);
+        const AttMeterSigVis *att = dynamic_cast<const AttMeterSigVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->MeterSigVisFormToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_METERSIGDEFAULTLOG)) {
-        AttMeterSigDefaultLog *att = dynamic_cast<AttMeterSigDefaultLog *>(element);
+        const AttMeterSigDefaultLog *att = dynamic_cast<const AttMeterSigDefaultLog *>(element);
         assert(att);
         if (att->HasMeterCount()) {
             attributes->push_back(std::make_pair("meter.count", att->IntToStr(att->GetMeterCount())));
@@ -10341,7 +10341,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_METERSIGDEFAULTVIS)) {
-        AttMeterSigDefaultVis *att = dynamic_cast<AttMeterSigDefaultVis *>(element);
+        const AttMeterSigDefaultVis *att = dynamic_cast<const AttMeterSigDefaultVis *>(element);
         assert(att);
         if (att->HasMeterRend()) {
             attributes->push_back(std::make_pair("meter.rend", att->MeterSigDefaultVisMeterrendToStr(att->GetMeterRend())));
@@ -10354,14 +10354,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_METERCONFORMANCE)) {
-        AttMeterconformance *att = dynamic_cast<AttMeterconformance *>(element);
+        const AttMeterconformance *att = dynamic_cast<const AttMeterconformance *>(element);
         assert(att);
         if (att->HasMetcon()) {
             attributes->push_back(std::make_pair("metcon", att->MeterconformanceMetconToStr(att->GetMetcon())));
         }
     }
     if (element->HasAttClass(ATT_METERCONFORMANCEBAR)) {
-        AttMeterconformanceBar *att = dynamic_cast<AttMeterconformanceBar *>(element);
+        const AttMeterconformanceBar *att = dynamic_cast<const AttMeterconformanceBar *>(element);
         assert(att);
         if (att->HasMetcon()) {
             attributes->push_back(std::make_pair("metcon", att->BooleanToStr(att->GetMetcon())));
@@ -10371,7 +10371,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MMTEMPO)) {
-        AttMmtempo *att = dynamic_cast<AttMmtempo *>(element);
+        const AttMmtempo *att = dynamic_cast<const AttMmtempo *>(element);
         assert(att);
         if (att->HasMm()) {
             attributes->push_back(std::make_pair("mm", att->StrToStr(att->GetMm())));
@@ -10384,14 +10384,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_MULTINUMMEASURES)) {
-        AttMultinummeasures *att = dynamic_cast<AttMultinummeasures *>(element);
+        const AttMultinummeasures *att = dynamic_cast<const AttMultinummeasures *>(element);
         assert(att);
         if (att->HasMultiNumber()) {
             attributes->push_back(std::make_pair("multi.number", att->BooleanToStr(att->GetMultiNumber())));
         }
     }
     if (element->HasAttClass(ATT_NAME)) {
-        AttName *att = dynamic_cast<AttName *>(element);
+        const AttName *att = dynamic_cast<const AttName *>(element);
         assert(att);
         if (att->HasNymref()) {
             attributes->push_back(std::make_pair("nymref", att->StrToStr(att->GetNymref())));
@@ -10401,7 +10401,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_NOTATIONSTYLE)) {
-        AttNotationstyle *att = dynamic_cast<AttNotationstyle *>(element);
+        const AttNotationstyle *att = dynamic_cast<const AttNotationstyle *>(element);
         assert(att);
         if (att->HasMusicName()) {
             attributes->push_back(std::make_pair("music.name", att->StrToStr(att->GetMusicName())));
@@ -10411,7 +10411,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_NOTEGES)) {
-        AttNoteGes *att = dynamic_cast<AttNoteGes *>(element);
+        const AttNoteGes *att = dynamic_cast<const AttNoteGes *>(element);
         assert(att);
         if (att->HasOctGes()) {
             attributes->push_back(std::make_pair("oct.ges", att->IntToStr(att->GetOctGes())));
@@ -10424,7 +10424,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_NOTEHEADS)) {
-        AttNoteheads *att = dynamic_cast<AttNoteheads *>(element);
+        const AttNoteheads *att = dynamic_cast<const AttNoteheads *>(element);
         assert(att);
         if (att->HasHeadColor()) {
             attributes->push_back(std::make_pair("head.color", att->StrToStr(att->GetHeadColor())));
@@ -10449,21 +10449,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_OCTAVE)) {
-        AttOctave *att = dynamic_cast<AttOctave *>(element);
+        const AttOctave *att = dynamic_cast<const AttOctave *>(element);
         assert(att);
         if (att->HasOct()) {
             attributes->push_back(std::make_pair("oct", att->IntToStr(att->GetOct())));
         }
     }
     if (element->HasAttClass(ATT_OCTAVEDEFAULT)) {
-        AttOctavedefault *att = dynamic_cast<AttOctavedefault *>(element);
+        const AttOctavedefault *att = dynamic_cast<const AttOctavedefault *>(element);
         assert(att);
         if (att->HasOctaveDefault()) {
             attributes->push_back(std::make_pair("octave.default", att->IntToStr(att->GetOctaveDefault())));
         }
     }
     if (element->HasAttClass(ATT_OCTAVEDISPLACEMENT)) {
-        AttOctavedisplacement *att = dynamic_cast<AttOctavedisplacement *>(element);
+        const AttOctavedisplacement *att = dynamic_cast<const AttOctavedisplacement *>(element);
         assert(att);
         if (att->HasDis()) {
             attributes->push_back(std::make_pair("dis", att->OctaveDisToStr(att->GetDis())));
@@ -10473,28 +10473,28 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_ONELINESTAFF)) {
-        AttOnelinestaff *att = dynamic_cast<AttOnelinestaff *>(element);
+        const AttOnelinestaff *att = dynamic_cast<const AttOnelinestaff *>(element);
         assert(att);
         if (att->HasOntheline()) {
             attributes->push_back(std::make_pair("ontheline", att->BooleanToStr(att->GetOntheline())));
         }
     }
     if (element->HasAttClass(ATT_OPTIMIZATION)) {
-        AttOptimization *att = dynamic_cast<AttOptimization *>(element);
+        const AttOptimization *att = dynamic_cast<const AttOptimization *>(element);
         assert(att);
         if (att->HasOptimize()) {
             attributes->push_back(std::make_pair("optimize", att->BooleanToStr(att->GetOptimize())));
         }
     }
     if (element->HasAttClass(ATT_PADLOG)) {
-        AttPadLog *att = dynamic_cast<AttPadLog *>(element);
+        const AttPadLog *att = dynamic_cast<const AttPadLog *>(element);
         assert(att);
         if (att->HasNum()) {
             attributes->push_back(std::make_pair("num", att->IntToStr(att->GetNum())));
         }
     }
     if (element->HasAttClass(ATT_PAGES)) {
-        AttPages *att = dynamic_cast<AttPages *>(element);
+        const AttPages *att = dynamic_cast<const AttPages *>(element);
         assert(att);
         if (att->HasPageHeight()) {
             attributes->push_back(std::make_pair("page.height", att->StrToStr(att->GetPageHeight())));
@@ -10522,28 +10522,28 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_PBVIS)) {
-        AttPbVis *att = dynamic_cast<AttPbVis *>(element);
+        const AttPbVis *att = dynamic_cast<const AttPbVis *>(element);
         assert(att);
         if (att->HasFolium()) {
             attributes->push_back(std::make_pair("folium", att->PbVisFoliumToStr(att->GetFolium())));
         }
     }
     if (element->HasAttClass(ATT_PITCH)) {
-        AttPitch *att = dynamic_cast<AttPitch *>(element);
+        const AttPitch *att = dynamic_cast<const AttPitch *>(element);
         assert(att);
         if (att->HasPname()) {
             attributes->push_back(std::make_pair("pname", att->PitchnameToStr(att->GetPname())));
         }
     }
     if (element->HasAttClass(ATT_PLACEMENT)) {
-        AttPlacement *att = dynamic_cast<AttPlacement *>(element);
+        const AttPlacement *att = dynamic_cast<const AttPlacement *>(element);
         assert(att);
         if (att->HasPlace()) {
             attributes->push_back(std::make_pair("place", att->StaffrelToStr(att->GetPlace())));
         }
     }
     if (element->HasAttClass(ATT_PLIST)) {
-        AttPlist *att = dynamic_cast<AttPlist *>(element);
+        const AttPlist *att = dynamic_cast<const AttPlist *>(element);
         assert(att);
         if (att->HasPlist()) {
             attributes->push_back(std::make_pair("plist", att->StrToStr(att->GetPlist())));
@@ -10553,7 +10553,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_POINTING)) {
-        AttPointing *att = dynamic_cast<AttPointing *>(element);
+        const AttPointing *att = dynamic_cast<const AttPointing *>(element);
         assert(att);
         if (att->HasActuate()) {
             attributes->push_back(std::make_pair("xlink:actuate", att->StrToStr(att->GetActuate())));
@@ -10575,42 +10575,42 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_QUANTITY)) {
-        AttQuantity *att = dynamic_cast<AttQuantity *>(element);
+        const AttQuantity *att = dynamic_cast<const AttQuantity *>(element);
         assert(att);
         if (att->HasQuantity()) {
             attributes->push_back(std::make_pair("quantity", att->DblToStr(att->GetQuantity())));
         }
     }
     if (element->HasAttClass(ATT_RELATIVESIZE)) {
-        AttRelativesize *att = dynamic_cast<AttRelativesize *>(element);
+        const AttRelativesize *att = dynamic_cast<const AttRelativesize *>(element);
         assert(att);
         if (att->HasSize()) {
             attributes->push_back(std::make_pair("size", att->SizeToStr(att->GetSize())));
         }
     }
     if (element->HasAttClass(ATT_RESPONSIBILITY)) {
-        AttResponsibility *att = dynamic_cast<AttResponsibility *>(element);
+        const AttResponsibility *att = dynamic_cast<const AttResponsibility *>(element);
         assert(att);
         if (att->HasResp()) {
             attributes->push_back(std::make_pair("resp", att->StrToStr(att->GetResp())));
         }
     }
     if (element->HasAttClass(ATT_SBVIS)) {
-        AttSbVis *att = dynamic_cast<AttSbVis *>(element);
+        const AttSbVis *att = dynamic_cast<const AttSbVis *>(element);
         assert(att);
         if (att->HasForm()) {
             attributes->push_back(std::make_pair("form", att->SbVisFormToStr(att->GetForm())));
         }
     }
     if (element->HasAttClass(ATT_SCALABLE)) {
-        AttScalable *att = dynamic_cast<AttScalable *>(element);
+        const AttScalable *att = dynamic_cast<const AttScalable *>(element);
         assert(att);
         if (att->HasScale()) {
             attributes->push_back(std::make_pair("scale", att->IntToStr(att->GetScale())));
         }
     }
     if (element->HasAttClass(ATT_SCOREDEFGES)) {
-        AttScoreDefGes *att = dynamic_cast<AttScoreDefGes *>(element);
+        const AttScoreDefGes *att = dynamic_cast<const AttScoreDefGes *>(element);
         assert(att);
         if (att->HasTunePname()) {
             attributes->push_back(std::make_pair("tune.pname", att->PitchnameToStr(att->GetTunePname())));
@@ -10623,49 +10623,49 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_SCOREDEFVIS)) {
-        AttScoreDefVis *att = dynamic_cast<AttScoreDefVis *>(element);
+        const AttScoreDefVis *att = dynamic_cast<const AttScoreDefVis *>(element);
         assert(att);
         if (att->HasVuHeight()) {
             attributes->push_back(std::make_pair("vu.height", att->StrToStr(att->GetVuHeight())));
         }
     }
     if (element->HasAttClass(ATT_SECTIONVIS)) {
-        AttSectionVis *att = dynamic_cast<AttSectionVis *>(element);
+        const AttSectionVis *att = dynamic_cast<const AttSectionVis *>(element);
         assert(att);
         if (att->HasRestart()) {
             attributes->push_back(std::make_pair("restart", att->BooleanToStr(att->GetRestart())));
         }
     }
     if (element->HasAttClass(ATT_SEQUENCE)) {
-        AttSequence *att = dynamic_cast<AttSequence *>(element);
+        const AttSequence *att = dynamic_cast<const AttSequence *>(element);
         assert(att);
         if (att->HasSeq()) {
             attributes->push_back(std::make_pair("seq", att->IntToStr(att->GetSeq())));
         }
     }
     if (element->HasAttClass(ATT_SLASHCOUNT)) {
-        AttSlashcount *att = dynamic_cast<AttSlashcount *>(element);
+        const AttSlashcount *att = dynamic_cast<const AttSlashcount *>(element);
         assert(att);
         if (att->HasSlash()) {
             attributes->push_back(std::make_pair("slash", att->IntToStr(att->GetSlash())));
         }
     }
     if (element->HasAttClass(ATT_SLURPRESENT)) {
-        AttSlurpresent *att = dynamic_cast<AttSlurpresent *>(element);
+        const AttSlurpresent *att = dynamic_cast<const AttSlurpresent *>(element);
         assert(att);
         if (att->HasSlur()) {
             attributes->push_back(std::make_pair("slur", att->StrToStr(att->GetSlur())));
         }
     }
     if (element->HasAttClass(ATT_SPACEVIS)) {
-        AttSpaceVis *att = dynamic_cast<AttSpaceVis *>(element);
+        const AttSpaceVis *att = dynamic_cast<const AttSpaceVis *>(element);
         assert(att);
         if (att->HasCompressable()) {
             attributes->push_back(std::make_pair("compressable", att->BooleanToStr(att->GetCompressable())));
         }
     }
     if (element->HasAttClass(ATT_SPACING)) {
-        AttSpacing *att = dynamic_cast<AttSpacing *>(element);
+        const AttSpacing *att = dynamic_cast<const AttSpacing *>(element);
         assert(att);
         if (att->HasSpacingPackexp()) {
             attributes->push_back(std::make_pair("spacing.packexp", att->DblToStr(att->GetSpacingPackexp())));
@@ -10681,14 +10681,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_STAFFLOG)) {
-        AttStaffLog *att = dynamic_cast<AttStaffLog *>(element);
+        const AttStaffLog *att = dynamic_cast<const AttStaffLog *>(element);
         assert(att);
         if (att->HasDef()) {
             attributes->push_back(std::make_pair("def", att->StrToStr(att->GetDef())));
         }
     }
     if (element->HasAttClass(ATT_STAFFDEFVIS)) {
-        AttStaffDefVis *att = dynamic_cast<AttStaffDefVis *>(element);
+        const AttStaffDefVis *att = dynamic_cast<const AttStaffDefVis *>(element);
         assert(att);
         if (att->HasGridShow()) {
             attributes->push_back(std::make_pair("grid.show", att->BooleanToStr(att->GetGridShow())));
@@ -10710,35 +10710,35 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_STAFFGRPVIS)) {
-        AttStaffGrpVis *att = dynamic_cast<AttStaffGrpVis *>(element);
+        const AttStaffGrpVis *att = dynamic_cast<const AttStaffGrpVis *>(element);
         assert(att);
         if (att->HasBarthru()) {
             attributes->push_back(std::make_pair("barthru", att->BooleanToStr(att->GetBarthru())));
         }
     }
     if (element->HasAttClass(ATT_STAFFGROUPINGSYM)) {
-        AttStaffgroupingsym *att = dynamic_cast<AttStaffgroupingsym *>(element);
+        const AttStaffgroupingsym *att = dynamic_cast<const AttStaffgroupingsym *>(element);
         assert(att);
         if (att->HasSymbol()) {
             attributes->push_back(std::make_pair("symbol", att->StaffgroupingsymSymbolToStr(att->GetSymbol())));
         }
     }
     if (element->HasAttClass(ATT_STAFFIDENT)) {
-        AttStaffident *att = dynamic_cast<AttStaffident *>(element);
+        const AttStaffident *att = dynamic_cast<const AttStaffident *>(element);
         assert(att);
         if (att->HasStaff()) {
             attributes->push_back(std::make_pair("staff", att->XsdPosintlistToStr(att->GetStaff())));
         }
     }
     if (element->HasAttClass(ATT_STAFFLOC)) {
-        AttStaffloc *att = dynamic_cast<AttStaffloc *>(element);
+        const AttStaffloc *att = dynamic_cast<const AttStaffloc *>(element);
         assert(att);
         if (att->HasLoc()) {
             attributes->push_back(std::make_pair("loc", att->IntToStr(att->GetLoc())));
         }
     }
     if (element->HasAttClass(ATT_STAFFLOCPITCHED)) {
-        AttStafflocPitched *att = dynamic_cast<AttStafflocPitched *>(element);
+        const AttStafflocPitched *att = dynamic_cast<const AttStafflocPitched *>(element);
         assert(att);
         if (att->HasPloc()) {
             attributes->push_back(std::make_pair("ploc", att->PitchnameToStr(att->GetPloc())));
@@ -10748,21 +10748,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_STARTENDID)) {
-        AttStartendid *att = dynamic_cast<AttStartendid *>(element);
+        const AttStartendid *att = dynamic_cast<const AttStartendid *>(element);
         assert(att);
         if (att->HasEndid()) {
             attributes->push_back(std::make_pair("endid", att->StrToStr(att->GetEndid())));
         }
     }
     if (element->HasAttClass(ATT_STARTID)) {
-        AttStartid *att = dynamic_cast<AttStartid *>(element);
+        const AttStartid *att = dynamic_cast<const AttStartid *>(element);
         assert(att);
         if (att->HasStartid()) {
             attributes->push_back(std::make_pair("startid", att->StrToStr(att->GetStartid())));
         }
     }
     if (element->HasAttClass(ATT_STEMS)) {
-        AttStems *att = dynamic_cast<AttStems *>(element);
+        const AttStems *att = dynamic_cast<const AttStems *>(element);
         assert(att);
         if (att->HasStemDir()) {
             attributes->push_back(std::make_pair("stem.dir", att->StemdirectionToStr(att->GetStemDir())));
@@ -10784,7 +10784,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_SYLLOG)) {
-        AttSylLog *att = dynamic_cast<AttSylLog *>(element);
+        const AttSylLog *att = dynamic_cast<const AttSylLog *>(element);
         assert(att);
         if (att->HasCon()) {
             attributes->push_back(std::make_pair("con", att->SylLogConToStr(att->GetCon())));
@@ -10794,14 +10794,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_SYLTEXT)) {
-        AttSyltext *att = dynamic_cast<AttSyltext *>(element);
+        const AttSyltext *att = dynamic_cast<const AttSyltext *>(element);
         assert(att);
         if (att->HasSyl()) {
             attributes->push_back(std::make_pair("syl", att->StrToStr(att->GetSyl())));
         }
     }
     if (element->HasAttClass(ATT_SYSTEMS)) {
-        AttSystems *att = dynamic_cast<AttSystems *>(element);
+        const AttSystems *att = dynamic_cast<const AttSystems *>(element);
         assert(att);
         if (att->HasSystemLeftline()) {
             attributes->push_back(std::make_pair("system.leftline", att->BooleanToStr(att->GetSystemLeftline())));
@@ -10817,7 +10817,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_TEXTSTYLE)) {
-        AttTextstyle *att = dynamic_cast<AttTextstyle *>(element);
+        const AttTextstyle *att = dynamic_cast<const AttTextstyle *>(element);
         assert(att);
         if (att->HasTextFam()) {
             attributes->push_back(std::make_pair("text.fam", att->StrToStr(att->GetTextFam())));
@@ -10836,21 +10836,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_TIEPRESENT)) {
-        AttTiepresent *att = dynamic_cast<AttTiepresent *>(element);
+        const AttTiepresent *att = dynamic_cast<const AttTiepresent *>(element);
         assert(att);
         if (att->HasTie()) {
             attributes->push_back(std::make_pair("tie", att->TieToStr(att->GetTie())));
         }
     }
     if (element->HasAttClass(ATT_TIMESTAMPMUSICAL)) {
-        AttTimestampMusical *att = dynamic_cast<AttTimestampMusical *>(element);
+        const AttTimestampMusical *att = dynamic_cast<const AttTimestampMusical *>(element);
         assert(att);
         if (att->HasTstamp()) {
             attributes->push_back(std::make_pair("tstamp", att->DblToStr(att->GetTstamp())));
         }
     }
     if (element->HasAttClass(ATT_TIMESTAMPPERFORMED)) {
-        AttTimestampPerformed *att = dynamic_cast<AttTimestampPerformed *>(element);
+        const AttTimestampPerformed *att = dynamic_cast<const AttTimestampPerformed *>(element);
         assert(att);
         if (att->HasTstampGes()) {
             attributes->push_back(std::make_pair("tstamp.ges", att->DurationToStr(att->GetTstampGes())));
@@ -10860,14 +10860,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_TIMESTAMP2MUSICAL)) {
-        AttTimestamp2Musical *att = dynamic_cast<AttTimestamp2Musical *>(element);
+        const AttTimestamp2Musical *att = dynamic_cast<const AttTimestamp2Musical *>(element);
         assert(att);
         if (att->HasTstamp2()) {
             attributes->push_back(std::make_pair("tstamp2", att->MeasurebeatToStr(att->GetTstamp2())));
         }
     }
     if (element->HasAttClass(ATT_TRANSPOSITION)) {
-        AttTransposition *att = dynamic_cast<AttTransposition *>(element);
+        const AttTransposition *att = dynamic_cast<const AttTransposition *>(element);
         assert(att);
         if (att->HasTransDiat()) {
             attributes->push_back(std::make_pair("trans.diat", att->DblToStr(att->GetTransDiat())));
@@ -10877,14 +10877,14 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_TUPLETPRESENT)) {
-        AttTupletpresent *att = dynamic_cast<AttTupletpresent *>(element);
+        const AttTupletpresent *att = dynamic_cast<const AttTupletpresent *>(element);
         assert(att);
         if (att->HasTuplet()) {
             attributes->push_back(std::make_pair("tuplet", att->StrToStr(att->GetTuplet())));
         }
     }
     if (element->HasAttClass(ATT_TYPED)) {
-        AttTyped *att = dynamic_cast<AttTyped *>(element);
+        const AttTyped *att = dynamic_cast<const AttTyped *>(element);
         assert(att);
         if (att->HasType()) {
             attributes->push_back(std::make_pair("type", att->StrToStr(att->GetType())));
@@ -10894,7 +10894,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_TYPOGRAPHY)) {
-        AttTypography *att = dynamic_cast<AttTypography *>(element);
+        const AttTypography *att = dynamic_cast<const AttTypography *>(element);
         assert(att);
         if (att->HasFontfam()) {
             attributes->push_back(std::make_pair("fontfam", att->StrToStr(att->GetFontfam())));
@@ -10913,35 +10913,35 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_VISIBILITY)) {
-        AttVisibility *att = dynamic_cast<AttVisibility *>(element);
+        const AttVisibility *att = dynamic_cast<const AttVisibility *>(element);
         assert(att);
         if (att->HasVisible()) {
             attributes->push_back(std::make_pair("visible", att->BooleanToStr(att->GetVisible())));
         }
     }
     if (element->HasAttClass(ATT_VISUALOFFSETHO)) {
-        AttVisualoffsetHo *att = dynamic_cast<AttVisualoffsetHo *>(element);
+        const AttVisualoffsetHo *att = dynamic_cast<const AttVisualoffsetHo *>(element);
         assert(att);
         if (att->HasHo()) {
             attributes->push_back(std::make_pair("ho", att->StrToStr(att->GetHo())));
         }
     }
     if (element->HasAttClass(ATT_VISUALOFFSETTO)) {
-        AttVisualoffsetTo *att = dynamic_cast<AttVisualoffsetTo *>(element);
+        const AttVisualoffsetTo *att = dynamic_cast<const AttVisualoffsetTo *>(element);
         assert(att);
         if (att->HasTo()) {
             attributes->push_back(std::make_pair("to", att->DblToStr(att->GetTo())));
         }
     }
     if (element->HasAttClass(ATT_VISUALOFFSETVO)) {
-        AttVisualoffsetVo *att = dynamic_cast<AttVisualoffsetVo *>(element);
+        const AttVisualoffsetVo *att = dynamic_cast<const AttVisualoffsetVo *>(element);
         assert(att);
         if (att->HasVo()) {
             attributes->push_back(std::make_pair("vo", att->StrToStr(att->GetVo())));
         }
     }
     if (element->HasAttClass(ATT_VISUALOFFSET2HO)) {
-        AttVisualoffset2Ho *att = dynamic_cast<AttVisualoffset2Ho *>(element);
+        const AttVisualoffset2Ho *att = dynamic_cast<const AttVisualoffset2Ho *>(element);
         assert(att);
         if (att->HasStartho()) {
             attributes->push_back(std::make_pair("startho", att->StrToStr(att->GetStartho())));
@@ -10951,7 +10951,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_VISUALOFFSET2TO)) {
-        AttVisualoffset2To *att = dynamic_cast<AttVisualoffset2To *>(element);
+        const AttVisualoffset2To *att = dynamic_cast<const AttVisualoffset2To *>(element);
         assert(att);
         if (att->HasStartto()) {
             attributes->push_back(std::make_pair("startto", att->DblToStr(att->GetStartto())));
@@ -10961,7 +10961,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_VISUALOFFSET2VO)) {
-        AttVisualoffset2Vo *att = dynamic_cast<AttVisualoffset2Vo *>(element);
+        const AttVisualoffset2Vo *att = dynamic_cast<const AttVisualoffset2Vo *>(element);
         assert(att);
         if (att->HasStartvo()) {
             attributes->push_back(std::make_pair("startvo", att->StrToStr(att->GetStartvo())));
@@ -10971,21 +10971,21 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_WHITESPACE)) {
-        AttWhitespace *att = dynamic_cast<AttWhitespace *>(element);
+        const AttWhitespace *att = dynamic_cast<const AttWhitespace *>(element);
         assert(att);
         if (att->HasSpace()) {
             attributes->push_back(std::make_pair("xml:space", att->StrToStr(att->GetSpace())));
         }
     }
     if (element->HasAttClass(ATT_WIDTH)) {
-        AttWidth *att = dynamic_cast<AttWidth *>(element);
+        const AttWidth *att = dynamic_cast<const AttWidth *>(element);
         assert(att);
         if (att->HasWidth()) {
             attributes->push_back(std::make_pair("width", att->StrToStr(att->GetWidth())));
         }
     }
     if (element->HasAttClass(ATT_XY)) {
-        AttXy *att = dynamic_cast<AttXy *>(element);
+        const AttXy *att = dynamic_cast<const AttXy *>(element);
         assert(att);
         if (att->HasX()) {
             attributes->push_back(std::make_pair("x", att->DblToStr(att->GetX())));
@@ -10995,7 +10995,7 @@ void Att::GetShared(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_XY2)) {
-        AttXy2 *att = dynamic_cast<AttXy2 *>(element);
+        const AttXy2 *att = dynamic_cast<const AttXy2 *>(element);
         assert(att);
         if (att->HasX2()) {
             attributes->push_back(std::make_pair("x2", att->DblToStr(att->GetX2())));
diff --git a/libmei/atts_shared.h b/libmei/atts_shared.h
index bf2ce87ff71..1db63f64411 100644
--- a/libmei/atts_shared.h
+++ b/libmei/atts_shared.h
@@ -51,7 +51,7 @@ class AttAccidLog : public Att {
     ///@{
     void SetFunc(accidLog_FUNC func_) { m_func = func_; };
     accidLog_FUNC GetFunc() const { return m_func; };
-    bool HasFunc();
+    bool HasFunc() const;
     ///@}
 
 private:
@@ -87,7 +87,7 @@ class AttAccidental : public Att {
     ///@{
     void SetAccid(data_ACCIDENTAL_EXPLICIT accid_) { m_accid = accid_; };
     data_ACCIDENTAL_EXPLICIT GetAccid() const { return m_accid; };
-    bool HasAccid();
+    bool HasAccid() const;
     ///@}
 
 private:
@@ -123,7 +123,7 @@ class AttAccidentalPerformed : public Att {
     ///@{
     void SetAccidGes(data_ACCIDENTAL_IMPLICIT accidGes_) { m_accidGes = accidGes_; };
     data_ACCIDENTAL_IMPLICIT GetAccidGes() const { return m_accidGes; };
-    bool HasAccidGes();
+    bool HasAccidGes() const;
     ///@}
 
 private:
@@ -159,7 +159,7 @@ class AttArticulation : public Att {
     ///@{
     void SetArtic(data_ARTICULATION artic_) { m_artic = artic_; };
     data_ARTICULATION GetArtic() const { return m_artic; };
-    bool HasArtic();
+    bool HasArtic() const;
     ///@}
 
 private:
@@ -201,7 +201,7 @@ class AttArticulationPerformed : public Att {
     ///@{
     void SetArticGes(data_ARTICULATION articGes_) { m_articGes = articGes_; };
     data_ARTICULATION GetArticGes() const { return m_articGes; };
-    bool HasArticGes();
+    bool HasArticGes() const;
     ///@}
 
 private:
@@ -237,7 +237,7 @@ class AttAugmentdots : public Att {
     ///@{
     void SetDots(int dots_) { m_dots = dots_; };
     int GetDots() const { return m_dots; };
-    bool HasDots();
+    bool HasDots() const;
     ///@}
 
 private:
@@ -273,11 +273,11 @@ class AttAuthorized : public Att {
     ///@{
     void SetAuthority(std::string authority_) { m_authority = authority_; };
     std::string GetAuthority() const { return m_authority; };
-    bool HasAuthority();
+    bool HasAuthority() const;
     //
     void SetAuthURI(std::string authURI_) { m_authURI = authURI_; };
     std::string GetAuthURI() const { return m_authURI; };
-    bool HasAuthURI();
+    bool HasAuthURI() const;
     ///@}
 
 private:
@@ -321,7 +321,7 @@ class AttBarLineLog : public Att {
     ///@{
     void SetForm(data_BARRENDITION form_) { m_form = form_; };
     data_BARRENDITION GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -357,11 +357,11 @@ class AttBarplacement : public Att {
     ///@{
     void SetBarplace(data_BARPLACE barplace_) { m_barplace = barplace_; };
     data_BARPLACE GetBarplace() const { return m_barplace; };
-    bool HasBarplace();
+    bool HasBarplace() const;
     //
     void SetTaktplace(int taktplace_) { m_taktplace = taktplace_; };
     int GetTaktplace() const { return m_taktplace; };
-    bool HasTaktplace();
+    bool HasTaktplace() const;
     ///@}
 
 private:
@@ -408,15 +408,15 @@ class AttBeamingVis : public Att {
     ///@{
     void SetBeamColor(std::string beamColor_) { m_beamColor = beamColor_; };
     std::string GetBeamColor() const { return m_beamColor; };
-    bool HasBeamColor();
+    bool HasBeamColor() const;
     //
     void SetBeamRend(beamingVis_BEAMREND beamRend_) { m_beamRend = beamRend_; };
     beamingVis_BEAMREND GetBeamRend() const { return m_beamRend; };
-    bool HasBeamRend();
+    bool HasBeamRend() const;
     //
     void SetBeamSlope(double beamSlope_) { m_beamSlope = beamSlope_; };
     double GetBeamSlope() const { return m_beamSlope; };
-    bool HasBeamSlope();
+    bool HasBeamSlope() const;
     ///@}
 
 private:
@@ -456,7 +456,7 @@ class AttBibl : public Att {
     ///@{
     void SetAnalog(std::string analog_) { m_analog = analog_; };
     std::string GetAnalog() const { return m_analog; };
-    bool HasAnalog();
+    bool HasAnalog() const;
     ///@}
 
 private:
@@ -495,7 +495,7 @@ class AttCalendared : public Att {
     ///@{
     void SetCalendar(std::string calendar_) { m_calendar = calendar_; };
     std::string GetCalendar() const { return m_calendar; };
-    bool HasCalendar();
+    bool HasCalendar() const;
     ///@}
 
 private:
@@ -534,7 +534,7 @@ class AttCanonical : public Att {
     ///@{
     void SetCodedval(std::string codedval_) { m_codedval = codedval_; };
     std::string GetCodedval() const { return m_codedval; };
-    bool HasCodedval();
+    bool HasCodedval() const;
     ///@}
 
 private:
@@ -574,7 +574,7 @@ class AttChordVis : public Att {
     ///@{
     void SetCluster(data_CLUSTER cluster_) { m_cluster = cluster_; };
     data_CLUSTER GetCluster() const { return m_cluster; };
-    bool HasCluster();
+    bool HasCluster() const;
     ///@}
 
 private:
@@ -615,7 +615,7 @@ class AttClasscodeident : public Att {
     ///@{
     void SetClasscode(std::string classcode_) { m_classcode = classcode_; };
     std::string GetClasscode() const { return m_classcode; };
-    bool HasClasscode();
+    bool HasClasscode() const;
     ///@}
 
 private:
@@ -655,7 +655,7 @@ class AttClefLog : public Att {
     ///@{
     void SetCautionary(data_BOOLEAN cautionary_) { m_cautionary = cautionary_; };
     data_BOOLEAN GetCautionary() const { return m_cautionary; };
-    bool HasCautionary();
+    bool HasCautionary() const;
     ///@}
 
 private:
@@ -694,19 +694,19 @@ class AttCleffingLog : public Att {
     ///@{
     void SetClefShape(data_CLEFSHAPE clefShape_) { m_clefShape = clefShape_; };
     data_CLEFSHAPE GetClefShape() const { return m_clefShape; };
-    bool HasClefShape();
+    bool HasClefShape() const;
     //
     void SetClefLine(char clefLine_) { m_clefLine = clefLine_; };
     char GetClefLine() const { return m_clefLine; };
-    bool HasClefLine();
+    bool HasClefLine() const;
     //
     void SetClefDis(data_OCTAVE_DIS clefDis_) { m_clefDis = clefDis_; };
     data_OCTAVE_DIS GetClefDis() const { return m_clefDis; };
-    bool HasClefDis();
+    bool HasClefDis() const;
     //
     void SetClefDisPlace(data_PLACE clefDisPlace_) { m_clefDisPlace = clefDisPlace_; };
     data_PLACE GetClefDisPlace() const { return m_clefDisPlace; };
-    bool HasClefDisPlace();
+    bool HasClefDisPlace() const;
     ///@}
 
 private:
@@ -752,11 +752,11 @@ class AttCleffingVis : public Att {
     ///@{
     void SetClefColor(std::string clefColor_) { m_clefColor = clefColor_; };
     std::string GetClefColor() const { return m_clefColor; };
-    bool HasClefColor();
+    bool HasClefColor() const;
     //
     void SetClefVisible(data_BOOLEAN clefVisible_) { m_clefVisible = clefVisible_; };
     data_BOOLEAN GetClefVisible() const { return m_clefVisible; };
-    bool HasClefVisible();
+    bool HasClefVisible() const;
     ///@}
 
 private:
@@ -794,7 +794,7 @@ class AttClefshape : public Att {
     ///@{
     void SetShape(data_CLEFSHAPE shape_) { m_shape = shape_; };
     data_CLEFSHAPE GetShape() const { return m_shape; };
-    bool HasShape();
+    bool HasShape() const;
     ///@}
 
 private:
@@ -830,7 +830,7 @@ class AttColor : public Att {
     ///@{
     void SetColor(std::string color_) { m_color = color_; };
     std::string GetColor() const { return m_color; };
-    bool HasColor();
+    bool HasColor() const;
     ///@}
 
 private:
@@ -869,7 +869,7 @@ class AttColoration : public Att {
     ///@{
     void SetColored(data_BOOLEAN colored_) { m_colored = colored_; };
     data_BOOLEAN GetColored() const { return m_colored; };
-    bool HasColored();
+    bool HasColored() const;
     ///@}
 
 private:
@@ -912,7 +912,7 @@ class AttCommon : public Att {
     ///@{
     void SetN(int n_) { m_n = n_; };
     int GetN() const { return m_n; };
-    bool HasN();
+    bool HasN() const;
     ///@}
 
 private:
@@ -948,11 +948,11 @@ class AttCommonPart : public Att {
     ///@{
     void SetLabel(std::string label_) { m_label = label_; };
     std::string GetLabel() const { return m_label; };
-    bool HasLabel();
+    bool HasLabel() const;
     //
     void SetBase(std::string base_) { m_base = base_; };
     std::string GetBase() const { return m_base; };
-    bool HasBase();
+    bool HasBase() const;
     ///@}
 
 private:
@@ -993,19 +993,19 @@ class AttCoordinated : public Att {
     ///@{
     void SetUlx(int ulx_) { m_ulx = ulx_; };
     int GetUlx() const { return m_ulx; };
-    bool HasUlx();
+    bool HasUlx() const;
     //
     void SetUly(int uly_) { m_uly = uly_; };
     int GetUly() const { return m_uly; };
-    bool HasUly();
+    bool HasUly() const;
     //
     void SetLrx(int lrx_) { m_lrx = lrx_; };
     int GetLrx() const { return m_lrx; };
-    bool HasLrx();
+    bool HasLrx() const;
     //
     void SetLry(int lry_) { m_lry = lry_; };
     int GetLry() const { return m_lry; };
-    bool HasLry();
+    bool HasLry() const;
     ///@}
 
 private:
@@ -1047,15 +1047,15 @@ class AttCurvature : public Att {
     ///@{
     void SetBezier(std::string bezier_) { m_bezier = bezier_; };
     std::string GetBezier() const { return m_bezier; };
-    bool HasBezier();
+    bool HasBezier() const;
     //
     void SetBulge(double bulge_) { m_bulge = bulge_; };
     double GetBulge() const { return m_bulge; };
-    bool HasBulge();
+    bool HasBulge() const;
     //
     void SetCurvedir(curvature_CURVEDIR curvedir_) { m_curvedir = curvedir_; };
     curvature_CURVEDIR GetCurvedir() const { return m_curvedir; };
-    bool HasCurvedir();
+    bool HasCurvedir() const;
     ///@}
 
 private:
@@ -1106,11 +1106,11 @@ class AttCurverend : public Att {
     ///@{
     void SetLform(data_LINEFORM lform_) { m_lform = lform_; };
     data_LINEFORM GetLform() const { return m_lform; };
-    bool HasLform();
+    bool HasLform() const;
     //
     void SetLwidth(std::string lwidth_) { m_lwidth = lwidth_; };
     std::string GetLwidth() const { return m_lwidth; };
-    bool HasLwidth();
+    bool HasLwidth() const;
     ///@}
 
 private:
@@ -1148,7 +1148,7 @@ class AttCustosLog : public Att {
     ///@{
     void SetTarget(std::string target_) { m_target = target_; };
     std::string GetTarget() const { return m_target; };
-    bool HasTarget();
+    bool HasTarget() const;
     ///@}
 
 private:
@@ -1187,23 +1187,23 @@ class AttDatable : public Att {
     ///@{
     void SetEnddate(std::string enddate_) { m_enddate = enddate_; };
     std::string GetEnddate() const { return m_enddate; };
-    bool HasEnddate();
+    bool HasEnddate() const;
     //
     void SetIsodate(std::string isodate_) { m_isodate = isodate_; };
     std::string GetIsodate() const { return m_isodate; };
-    bool HasIsodate();
+    bool HasIsodate() const;
     //
     void SetNotafter(std::string notafter_) { m_notafter = notafter_; };
     std::string GetNotafter() const { return m_notafter; };
-    bool HasNotafter();
+    bool HasNotafter() const;
     //
     void SetNotbefore(std::string notbefore_) { m_notbefore = notbefore_; };
     std::string GetNotbefore() const { return m_notbefore; };
-    bool HasNotbefore();
+    bool HasNotbefore() const;
     //
     void SetStartdate(std::string startdate_) { m_startdate = startdate_; };
     std::string GetStartdate() const { return m_startdate; };
-    bool HasStartdate();
+    bool HasStartdate() const;
     ///@}
 
 private:
@@ -1247,7 +1247,7 @@ class AttDatapointing : public Att {
     ///@{
     void SetData(std::string data_) { m_data = data_; };
     std::string GetData() const { return m_data; };
-    bool HasData();
+    bool HasData() const;
     ///@}
 
 private:
@@ -1283,7 +1283,7 @@ class AttDeclaring : public Att {
     ///@{
     void SetDecls(std::string decls_) { m_decls = decls_; };
     std::string GetDecls() const { return m_decls; };
-    bool HasDecls();
+    bool HasDecls() const;
     ///@}
 
 private:
@@ -1322,15 +1322,15 @@ class AttDistances : public Att {
     ///@{
     void SetDynamDist(std::string dynamDist_) { m_dynamDist = dynamDist_; };
     std::string GetDynamDist() const { return m_dynamDist; };
-    bool HasDynamDist();
+    bool HasDynamDist() const;
     //
     void SetHarmDist(std::string harmDist_) { m_harmDist = harmDist_; };
     std::string GetHarmDist() const { return m_harmDist; };
-    bool HasHarmDist();
+    bool HasHarmDist() const;
     //
     void SetTextDist(std::string textDist_) { m_textDist = textDist_; };
     std::string GetTextDist() const { return m_textDist; };
-    bool HasTextDist();
+    bool HasTextDist() const;
     ///@}
 
 private:
@@ -1373,7 +1373,7 @@ class AttDotLog : public Att {
     ///@{
     void SetForm(dotLog_FORM form_) { m_form = form_; };
     dotLog_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -1409,7 +1409,7 @@ class AttDurationAdditive : public Att {
     ///@{
     void SetDur(data_DURATION dur_) { m_dur = dur_; };
     data_DURATION GetDur() const { return m_dur; };
-    bool HasDur();
+    bool HasDur() const;
     ///@}
 
 private:
@@ -1451,15 +1451,15 @@ class AttDurationDefault : public Att {
     ///@{
     void SetDurDefault(data_DURATION durDefault_) { m_durDefault = durDefault_; };
     data_DURATION GetDurDefault() const { return m_durDefault; };
-    bool HasDurDefault();
+    bool HasDurDefault() const;
     //
     void SetNumDefault(int numDefault_) { m_numDefault = numDefault_; };
     int GetNumDefault() const { return m_numDefault; };
-    bool HasNumDefault();
+    bool HasNumDefault() const;
     //
     void SetNumbaseDefault(int numbaseDefault_) { m_numbaseDefault = numbaseDefault_; };
     int GetNumbaseDefault() const { return m_numbaseDefault; };
-    bool HasNumbaseDefault();
+    bool HasNumbaseDefault() const;
     ///@}
 
 private:
@@ -1509,7 +1509,7 @@ class AttDurationMusical : public Att {
     ///@{
     void SetDur(data_DURATION dur_) { m_dur = dur_; };
     data_DURATION GetDur() const { return m_dur; };
-    bool HasDur();
+    bool HasDur() const;
     ///@}
 
 private:
@@ -1551,7 +1551,7 @@ class AttDurationPerformed : public Att {
     ///@{
     void SetDurGes(data_DURATION durGes_) { m_durGes = durGes_; };
     data_DURATION GetDurGes() const { return m_durGes; };
-    bool HasDurGes();
+    bool HasDurGes() const;
     ///@}
 
 private:
@@ -1592,11 +1592,11 @@ class AttDurationRatio : public Att {
     ///@{
     void SetNum(int num_) { m_num = num_; };
     int GetNum() const { return m_num; };
-    bool HasNum();
+    bool HasNum() const;
     //
     void SetNumbase(int numbase_) { m_numbase = numbase_; };
     int GetNumbase() const { return m_numbase; };
-    bool HasNumbase();
+    bool HasNumbase() const;
     ///@}
 
 private:
@@ -1640,7 +1640,7 @@ class AttEnclosingchars : public Att {
     ///@{
     void SetEnclose(data_ENCLOSURE enclose_) { m_enclose = enclose_; };
     data_ENCLOSURE GetEnclose() const { return m_enclose; };
-    bool HasEnclose();
+    bool HasEnclose() const;
     ///@}
 
 private:
@@ -1681,7 +1681,7 @@ class AttEndings : public Att {
     ///@{
     void SetEndingRend(endings_ENDINGREND endingRend_) { m_endingRend = endingRend_; };
     endings_ENDINGREND GetEndingRend() const { return m_endingRend; };
-    bool HasEndingRend();
+    bool HasEndingRend() const;
     ///@}
 
 private:
@@ -1717,7 +1717,7 @@ class AttExtender : public Att {
     ///@{
     void SetExtender(data_BOOLEAN extender_) { m_extender = extender_; };
     data_BOOLEAN GetExtender() const { return m_extender; };
-    bool HasExtender();
+    bool HasExtender() const;
     ///@}
 
 private:
@@ -1753,7 +1753,7 @@ class AttFermatapresent : public Att {
     ///@{
     void SetFermata(data_PLACE fermata_) { m_fermata = fermata_; };
     data_PLACE GetFermata() const { return m_fermata; };
-    bool HasFermata();
+    bool HasFermata() const;
     ///@}
 
 private:
@@ -1793,7 +1793,7 @@ class AttFiling : public Att {
     ///@{
     void SetNonfiling(int nonfiling_) { m_nonfiling = nonfiling_; };
     int GetNonfiling() const { return m_nonfiling; };
-    bool HasNonfiling();
+    bool HasNonfiling() const;
     ///@}
 
 private:
@@ -1832,7 +1832,7 @@ class AttGrpSymLog : public Att {
     ///@{
     void SetLevel(int level_) { m_level = level_; };
     int GetLevel() const { return m_level; };
-    bool HasLevel();
+    bool HasLevel() const;
     ///@}
 
 private:
@@ -1868,7 +1868,7 @@ class AttHandident : public Att {
     ///@{
     void SetHand(std::string hand_) { m_hand = hand_; };
     std::string GetHand() const { return m_hand; };
-    bool HasHand();
+    bool HasHand() const;
     ///@}
 
 private:
@@ -1907,7 +1907,7 @@ class AttHeight : public Att {
     ///@{
     void SetHeight(std::string height_) { m_height = height_; };
     std::string GetHeight() const { return m_height; };
-    bool HasHeight();
+    bool HasHeight() const;
     ///@}
 
 private:
@@ -1943,7 +1943,7 @@ class AttHorizontalalign : public Att {
     ///@{
     void SetHalign(data_HORIZONTALALIGNMENT halign_) { m_halign = halign_; };
     data_HORIZONTALALIGNMENT GetHalign() const { return m_halign; };
-    bool HasHalign();
+    bool HasHalign() const;
     ///@}
 
 private:
@@ -1979,7 +1979,7 @@ class AttInstrumentident : public Att {
     ///@{
     void SetInstr(std::string instr_) { m_instr = instr_; };
     std::string GetInstr() const { return m_instr; };
-    bool HasInstr();
+    bool HasInstr() const;
     ///@}
 
 private:
@@ -2018,7 +2018,7 @@ class AttInternetmedia : public Att {
     ///@{
     void SetMimetype(std::string mimetype_) { m_mimetype = mimetype_; };
     std::string GetMimetype() const { return m_mimetype; };
-    bool HasMimetype();
+    bool HasMimetype() const;
     ///@}
 
 private:
@@ -2058,7 +2058,7 @@ class AttJoined : public Att {
     ///@{
     void SetJoin(std::string join_) { m_join = join_; };
     std::string GetJoin() const { return m_join; };
-    bool HasJoin();
+    bool HasJoin() const;
     ///@}
 
 private:
@@ -2101,7 +2101,7 @@ class AttKeySigLog : public Att {
     ///@{
     void SetMode(data_MODE mode_) { m_mode = mode_; };
     data_MODE GetMode() const { return m_mode; };
-    bool HasMode();
+    bool HasMode() const;
     ///@}
 
 private:
@@ -2137,23 +2137,23 @@ class AttKeySigDefaultLog : public Att {
     ///@{
     void SetKeyAccid(data_ACCIDENTAL_IMPLICIT keyAccid_) { m_keyAccid = keyAccid_; };
     data_ACCIDENTAL_IMPLICIT GetKeyAccid() const { return m_keyAccid; };
-    bool HasKeyAccid();
+    bool HasKeyAccid() const;
     //
     void SetKeyMode(data_MODE keyMode_) { m_keyMode = keyMode_; };
     data_MODE GetKeyMode() const { return m_keyMode; };
-    bool HasKeyMode();
+    bool HasKeyMode() const;
     //
     void SetKeyPname(data_PITCHNAME keyPname_) { m_keyPname = keyPname_; };
     data_PITCHNAME GetKeyPname() const { return m_keyPname; };
-    bool HasKeyPname();
+    bool HasKeyPname() const;
     //
     void SetKeySig(data_KEYSIGNATURE keySig_) { m_keySig = keySig_; };
     data_KEYSIGNATURE GetKeySig() const { return m_keySig; };
-    bool HasKeySig();
+    bool HasKeySig() const;
     //
     void SetKeySigMixed(std::string keySigMixed_) { m_keySigMixed = keySigMixed_; };
     std::string GetKeySigMixed() const { return m_keySigMixed; };
-    bool HasKeySigMixed();
+    bool HasKeySigMixed() const;
     ///@}
 
 private:
@@ -2213,11 +2213,11 @@ class AttKeySigDefaultVis : public Att {
     ///@{
     void SetKeySigShow(data_BOOLEAN keySigShow_) { m_keySigShow = keySigShow_; };
     data_BOOLEAN GetKeySigShow() const { return m_keySigShow; };
-    bool HasKeySigShow();
+    bool HasKeySigShow() const;
     //
     void SetKeySigShowchange(data_BOOLEAN keySigShowchange_) { m_keySigShowchange = keySigShowchange_; };
     data_BOOLEAN GetKeySigShowchange() const { return m_keySigShowchange; };
-    bool HasKeySigShowchange();
+    bool HasKeySigShowchange() const;
     ///@}
 
 private:
@@ -2255,7 +2255,7 @@ class AttLabelsAddl : public Att {
     ///@{
     void SetLabelAbbr(std::string labelAbbr_) { m_labelAbbr = labelAbbr_; };
     std::string GetLabelAbbr() const { return m_labelAbbr; };
-    bool HasLabelAbbr();
+    bool HasLabelAbbr() const;
     ///@}
 
 private:
@@ -2294,11 +2294,11 @@ class AttLang : public Att {
     ///@{
     void SetLang(std::string lang_) { m_lang = lang_; };
     std::string GetLang() const { return m_lang; };
-    bool HasLang();
+    bool HasLang() const;
     //
     void SetTranslit(std::string translit_) { m_translit = translit_; };
     std::string GetTranslit() const { return m_translit; };
-    bool HasTranslit();
+    bool HasTranslit() const;
     ///@}
 
 private:
@@ -2336,7 +2336,7 @@ class AttLayerLog : public Att {
     ///@{
     void SetDef(std::string def_) { m_def = def_; };
     std::string GetDef() const { return m_def; };
-    bool HasDef();
+    bool HasDef() const;
     ///@}
 
 private:
@@ -2372,7 +2372,7 @@ class AttLayerident : public Att {
     ///@{
     void SetLayer(int layer_) { m_layer = layer_; };
     int GetLayer() const { return m_layer; };
-    bool HasLayer();
+    bool HasLayer() const;
     ///@}
 
 private:
@@ -2408,27 +2408,27 @@ class AttLineVis : public Att {
     ///@{
     void SetForm(data_LINEFORM form_) { m_form = form_; };
     data_LINEFORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     //
     void SetWidth(std::string width_) { m_width = width_; };
     std::string GetWidth() const { return m_width; };
-    bool HasWidth();
+    bool HasWidth() const;
     //
     void SetEndsym(data_LINESTARTENDSYMBOL endsym_) { m_endsym = endsym_; };
     data_LINESTARTENDSYMBOL GetEndsym() const { return m_endsym; };
-    bool HasEndsym();
+    bool HasEndsym() const;
     //
     void SetEndsymsize(std::string endsymsize_) { m_endsymsize = endsymsize_; };
     std::string GetEndsymsize() const { return m_endsymsize; };
-    bool HasEndsymsize();
+    bool HasEndsymsize() const;
     //
     void SetStartsym(data_LINESTARTENDSYMBOL startsym_) { m_startsym = startsym_; };
     data_LINESTARTENDSYMBOL GetStartsym() const { return m_startsym; };
-    bool HasStartsym();
+    bool HasStartsym() const;
     //
     void SetStartsymsize(std::string startsymsize_) { m_startsymsize = startsymsize_; };
     std::string GetStartsymsize() const { return m_startsymsize; };
-    bool HasStartsymsize();
+    bool HasStartsymsize() const;
     ///@}
 
 private:
@@ -2474,7 +2474,7 @@ class AttLineloc : public Att {
     ///@{
     void SetLine(char line_) { m_line = line_; };
     char GetLine() const { return m_line; };
-    bool HasLine();
+    bool HasLine() const;
     ///@}
 
 private:
@@ -2514,19 +2514,19 @@ class AttLinerend : public Att {
     ///@{
     void SetLendsym(data_LINESTARTENDSYMBOL lendsym_) { m_lendsym = lendsym_; };
     data_LINESTARTENDSYMBOL GetLendsym() const { return m_lendsym; };
-    bool HasLendsym();
+    bool HasLendsym() const;
     //
     void SetLendsymsize(std::string lendsymsize_) { m_lendsymsize = lendsymsize_; };
     std::string GetLendsymsize() const { return m_lendsymsize; };
-    bool HasLendsymsize();
+    bool HasLendsymsize() const;
     //
     void SetLstartsym(data_LINESTARTENDSYMBOL lstartsym_) { m_lstartsym = lstartsym_; };
     data_LINESTARTENDSYMBOL GetLstartsym() const { return m_lstartsym; };
-    bool HasLstartsym();
+    bool HasLstartsym() const;
     //
     void SetLstartsymsize(std::string lstartsymsize_) { m_lstartsymsize = lstartsymsize_; };
     std::string GetLstartsymsize() const { return m_lstartsymsize; };
-    bool HasLstartsymsize();
+    bool HasLstartsymsize() const;
     ///@}
 
 private:
@@ -2568,11 +2568,11 @@ class AttLinerendBase : public Att {
     ///@{
     void SetLform(data_LINEFORM lform_) { m_lform = lform_; };
     data_LINEFORM GetLform() const { return m_lform; };
-    bool HasLform();
+    bool HasLform() const;
     //
     void SetLwidth(std::string lwidth_) { m_lwidth = lwidth_; };
     std::string GetLwidth() const { return m_lwidth; };
-    bool HasLwidth();
+    bool HasLwidth() const;
     ///@}
 
 private:
@@ -2610,27 +2610,27 @@ class AttLyricstyle : public Att {
     ///@{
     void SetLyricAlign(std::string lyricAlign_) { m_lyricAlign = lyricAlign_; };
     std::string GetLyricAlign() const { return m_lyricAlign; };
-    bool HasLyricAlign();
+    bool HasLyricAlign() const;
     //
     void SetLyricFam(std::string lyricFam_) { m_lyricFam = lyricFam_; };
     std::string GetLyricFam() const { return m_lyricFam; };
-    bool HasLyricFam();
+    bool HasLyricFam() const;
     //
     void SetLyricName(std::string lyricName_) { m_lyricName = lyricName_; };
     std::string GetLyricName() const { return m_lyricName; };
-    bool HasLyricName();
+    bool HasLyricName() const;
     //
     void SetLyricSize(std::string lyricSize_) { m_lyricSize = lyricSize_; };
     std::string GetLyricSize() const { return m_lyricSize; };
-    bool HasLyricSize();
+    bool HasLyricSize() const;
     //
     void SetLyricStyle(data_FONTSTYLE lyricStyle_) { m_lyricStyle = lyricStyle_; };
     data_FONTSTYLE GetLyricStyle() const { return m_lyricStyle; };
-    bool HasLyricStyle();
+    bool HasLyricStyle() const;
     //
     void SetLyricWeight(data_FONTWEIGHT lyricWeight_) { m_lyricWeight = lyricWeight_; };
     data_FONTWEIGHT GetLyricWeight() const { return m_lyricWeight; };
-    bool HasLyricWeight();
+    bool HasLyricWeight() const;
     ///@}
 
 private:
@@ -2676,11 +2676,11 @@ class AttMeasureLog : public Att {
     ///@{
     void SetLeft(data_BARRENDITION left_) { m_left = left_; };
     data_BARRENDITION GetLeft() const { return m_left; };
-    bool HasLeft();
+    bool HasLeft() const;
     //
     void SetRight(data_BARRENDITION right_) { m_right = right_; };
     data_BARRENDITION GetRight() const { return m_right; };
-    bool HasRight();
+    bool HasRight() const;
     ///@}
 
 private:
@@ -2722,7 +2722,7 @@ class AttMeasurement : public Att {
     ///@{
     void SetUnit(std::string unit_) { m_unit = unit_; };
     std::string GetUnit() const { return m_unit; };
-    bool HasUnit();
+    bool HasUnit() const;
     ///@}
 
 private:
@@ -2758,7 +2758,7 @@ class AttMeasurenumbers : public Att {
     ///@{
     void SetMnumVisible(data_BOOLEAN mnumVisible_) { m_mnumVisible = mnumVisible_; };
     data_BOOLEAN GetMnumVisible() const { return m_mnumVisible; };
-    bool HasMnumVisible();
+    bool HasMnumVisible() const;
     ///@}
 
 private:
@@ -2794,15 +2794,15 @@ class AttMediabounds : public Att {
     ///@{
     void SetBegin(std::string begin_) { m_begin = begin_; };
     std::string GetBegin() const { return m_begin; };
-    bool HasBegin();
+    bool HasBegin() const;
     //
     void SetEnd(std::string end_) { m_end = end_; };
     std::string GetEnd() const { return m_end; };
-    bool HasEnd();
+    bool HasEnd() const;
     //
     void SetBetype(data_BETYPE betype_) { m_betype = betype_; };
     data_BETYPE GetBetype() const { return m_betype; };
-    bool HasBetype();
+    bool HasBetype() const;
     ///@}
 
 private:
@@ -2855,7 +2855,7 @@ class AttMedium : public Att {
     ///@{
     void SetMedium(std::string medium_) { m_medium = medium_; };
     std::string GetMedium() const { return m_medium; };
-    bool HasMedium();
+    bool HasMedium() const;
     ///@}
 
 private:
@@ -2891,7 +2891,7 @@ class AttMeiversion : public Att {
     ///@{
     void SetMeiversion(meiversion_MEIVERSION meiversion_) { m_meiversion = meiversion_; };
     meiversion_MEIVERSION GetMeiversion() const { return m_meiversion; };
-    bool HasMeiversion();
+    bool HasMeiversion() const;
     ///@}
 
 private:
@@ -2927,11 +2927,11 @@ class AttMensurLog : public Att {
     ///@{
     void SetDot(data_BOOLEAN dot_) { m_dot = dot_; };
     data_BOOLEAN GetDot() const { return m_dot; };
-    bool HasDot();
+    bool HasDot() const;
     //
     void SetSign(data_MENSURATIONSIGN sign_) { m_sign = sign_; };
     data_MENSURATIONSIGN GetSign() const { return m_sign; };
-    bool HasSign();
+    bool HasSign() const;
     ///@}
 
 private:
@@ -2969,15 +2969,15 @@ class AttMeterSigLog : public Att {
     ///@{
     void SetCount(int count_) { m_count = count_; };
     int GetCount() const { return m_count; };
-    bool HasCount();
+    bool HasCount() const;
     //
     void SetSym(data_METERSIGN sym_) { m_sym = sym_; };
     data_METERSIGN GetSym() const { return m_sym; };
-    bool HasSym();
+    bool HasSym() const;
     //
     void SetUnit(int unit_) { m_unit = unit_; };
     int GetUnit() const { return m_unit; };
-    bool HasUnit();
+    bool HasUnit() const;
     ///@}
 
 private:
@@ -3025,7 +3025,7 @@ class AttMeterSigVis : public Att {
     ///@{
     void SetForm(meterSigVis_FORM form_) { m_form = form_; };
     meterSigVis_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -3061,11 +3061,11 @@ class AttMeterSigDefaultLog : public Att {
     ///@{
     void SetMeterCount(int meterCount_) { m_meterCount = meterCount_; };
     int GetMeterCount() const { return m_meterCount; };
-    bool HasMeterCount();
+    bool HasMeterCount() const;
     //
     void SetMeterUnit(int meterUnit_) { m_meterUnit = meterUnit_; };
     int GetMeterUnit() const { return m_meterUnit; };
-    bool HasMeterUnit();
+    bool HasMeterUnit() const;
     ///@}
 
 private:
@@ -3111,15 +3111,15 @@ class AttMeterSigDefaultVis : public Att {
     ///@{
     void SetMeterRend(meterSigDefaultVis_METERREND meterRend_) { m_meterRend = meterRend_; };
     meterSigDefaultVis_METERREND GetMeterRend() const { return m_meterRend; };
-    bool HasMeterRend();
+    bool HasMeterRend() const;
     //
     void SetMeterShowchange(data_BOOLEAN meterShowchange_) { m_meterShowchange = meterShowchange_; };
     data_BOOLEAN GetMeterShowchange() const { return m_meterShowchange; };
-    bool HasMeterShowchange();
+    bool HasMeterShowchange() const;
     //
     void SetMeterSym(data_METERSIGN meterSym_) { m_meterSym = meterSym_; };
     data_METERSIGN GetMeterSym() const { return m_meterSym; };
-    bool HasMeterSym();
+    bool HasMeterSym() const;
     ///@}
 
 private:
@@ -3165,7 +3165,7 @@ class AttMeterconformance : public Att {
     ///@{
     void SetMetcon(meterconformance_METCON metcon_) { m_metcon = metcon_; };
     meterconformance_METCON GetMetcon() const { return m_metcon; };
-    bool HasMetcon();
+    bool HasMetcon() const;
     ///@}
 
 private:
@@ -3204,11 +3204,11 @@ class AttMeterconformanceBar : public Att {
     ///@{
     void SetMetcon(data_BOOLEAN metcon_) { m_metcon = metcon_; };
     data_BOOLEAN GetMetcon() const { return m_metcon; };
-    bool HasMetcon();
+    bool HasMetcon() const;
     //
     void SetControl(data_BOOLEAN control_) { m_control = control_; };
     data_BOOLEAN GetControl() const { return m_control; };
-    bool HasControl();
+    bool HasControl() const;
     ///@}
 
 private:
@@ -3255,15 +3255,15 @@ class AttMmtempo : public Att {
     ///@{
     void SetMm(std::string mm_) { m_mm = mm_; };
     std::string GetMm() const { return m_mm; };
-    bool HasMm();
+    bool HasMm() const;
     //
     void SetMmUnit(data_DURATION mmUnit_) { m_mmUnit = mmUnit_; };
     data_DURATION GetMmUnit() const { return m_mmUnit; };
-    bool HasMmUnit();
+    bool HasMmUnit() const;
     //
     void SetMmDots(int mmDots_) { m_mmDots = mmDots_; };
     int GetMmDots() const { return m_mmDots; };
-    bool HasMmDots();
+    bool HasMmDots() const;
     ///@}
 
 private:
@@ -3307,7 +3307,7 @@ class AttMultinummeasures : public Att {
     ///@{
     void SetMultiNumber(data_BOOLEAN multiNumber_) { m_multiNumber = multiNumber_; };
     data_BOOLEAN GetMultiNumber() const { return m_multiNumber; };
-    bool HasMultiNumber();
+    bool HasMultiNumber() const;
     ///@}
 
 private:
@@ -3346,11 +3346,11 @@ class AttName : public Att {
     ///@{
     void SetNymref(std::string nymref_) { m_nymref = nymref_; };
     std::string GetNymref() const { return m_nymref; };
-    bool HasNymref();
+    bool HasNymref() const;
     //
     void SetRole(std::string role_) { m_role = role_; };
     std::string GetRole() const { return m_role; };
-    bool HasRole();
+    bool HasRole() const;
     ///@}
 
 private:
@@ -3395,11 +3395,11 @@ class AttNotationstyle : public Att {
     ///@{
     void SetMusicName(std::string musicName_) { m_musicName = musicName_; };
     std::string GetMusicName() const { return m_musicName; };
-    bool HasMusicName();
+    bool HasMusicName() const;
     //
     void SetMusicSize(std::string musicSize_) { m_musicSize = musicSize_; };
     std::string GetMusicSize() const { return m_musicSize; };
-    bool HasMusicSize();
+    bool HasMusicSize() const;
     ///@}
 
 private:
@@ -3437,15 +3437,15 @@ class AttNoteGes : public Att {
     ///@{
     void SetOctGes(char octGes_) { m_octGes = octGes_; };
     char GetOctGes() const { return m_octGes; };
-    bool HasOctGes();
+    bool HasOctGes() const;
     //
     void SetPnameGes(data_PITCHNAME pnameGes_) { m_pnameGes = pnameGes_; };
     data_PITCHNAME GetPnameGes() const { return m_pnameGes; };
-    bool HasPnameGes();
+    bool HasPnameGes() const;
     //
     void SetPnum(int pnum_) { m_pnum = pnum_; };
     int GetPnum() const { return m_pnum; };
-    bool HasPnum();
+    bool HasPnum() const;
     ///@}
 
 private:
@@ -3485,31 +3485,31 @@ class AttNoteheads : public Att {
     ///@{
     void SetHeadColor(std::string headColor_) { m_headColor = headColor_; };
     std::string GetHeadColor() const { return m_headColor; };
-    bool HasHeadColor();
+    bool HasHeadColor() const;
     //
     void SetHeadFill(std::string headFill_) { m_headFill = headFill_; };
     std::string GetHeadFill() const { return m_headFill; };
-    bool HasHeadFill();
+    bool HasHeadFill() const;
     //
     void SetHeadFillcolor(std::string headFillcolor_) { m_headFillcolor = headFillcolor_; };
     std::string GetHeadFillcolor() const { return m_headFillcolor; };
-    bool HasHeadFillcolor();
+    bool HasHeadFillcolor() const;
     //
     void SetHeadMod(std::string headMod_) { m_headMod = headMod_; };
     std::string GetHeadMod() const { return m_headMod; };
-    bool HasHeadMod();
+    bool HasHeadMod() const;
     //
     void SetHeadRotation(std::string headRotation_) { m_headRotation = headRotation_; };
     std::string GetHeadRotation() const { return m_headRotation; };
-    bool HasHeadRotation();
+    bool HasHeadRotation() const;
     //
     void SetHeadShape(std::string headShape_) { m_headShape = headShape_; };
     std::string GetHeadShape() const { return m_headShape; };
-    bool HasHeadShape();
+    bool HasHeadShape() const;
     //
     void SetHeadVisible(data_BOOLEAN headVisible_) { m_headVisible = headVisible_; };
     data_BOOLEAN GetHeadVisible() const { return m_headVisible; };
-    bool HasHeadVisible();
+    bool HasHeadVisible() const;
     ///@}
 
 private:
@@ -3564,7 +3564,7 @@ class AttOctave : public Att {
     ///@{
     void SetOct(char oct_) { m_oct = oct_; };
     char GetOct() const { return m_oct; };
-    bool HasOct();
+    bool HasOct() const;
     ///@}
 
 private:
@@ -3600,7 +3600,7 @@ class AttOctavedefault : public Att {
     ///@{
     void SetOctaveDefault(char octaveDefault_) { m_octaveDefault = octaveDefault_; };
     char GetOctaveDefault() const { return m_octaveDefault; };
-    bool HasOctaveDefault();
+    bool HasOctaveDefault() const;
     ///@}
 
 private:
@@ -3640,11 +3640,11 @@ class AttOctavedisplacement : public Att {
     ///@{
     void SetDis(data_OCTAVE_DIS dis_) { m_dis = dis_; };
     data_OCTAVE_DIS GetDis() const { return m_dis; };
-    bool HasDis();
+    bool HasDis() const;
     //
     void SetDisPlace(data_PLACE disPlace_) { m_disPlace = disPlace_; };
     data_PLACE GetDisPlace() const { return m_disPlace; };
-    bool HasDisPlace();
+    bool HasDisPlace() const;
     ///@}
 
 private:
@@ -3682,7 +3682,7 @@ class AttOnelinestaff : public Att {
     ///@{
     void SetOntheline(data_BOOLEAN ontheline_) { m_ontheline = ontheline_; };
     data_BOOLEAN GetOntheline() const { return m_ontheline; };
-    bool HasOntheline();
+    bool HasOntheline() const;
     ///@}
 
 private:
@@ -3722,7 +3722,7 @@ class AttOptimization : public Att {
     ///@{
     void SetOptimize(data_BOOLEAN optimize_) { m_optimize = optimize_; };
     data_BOOLEAN GetOptimize() const { return m_optimize; };
-    bool HasOptimize();
+    bool HasOptimize() const;
     ///@}
 
 private:
@@ -3761,7 +3761,7 @@ class AttPadLog : public Att {
     ///@{
     void SetNum(int num_) { m_num = num_; };
     int GetNum() const { return m_num; };
-    bool HasNum();
+    bool HasNum() const;
     ///@}
 
 private:
@@ -3800,35 +3800,35 @@ class AttPages : public Att {
     ///@{
     void SetPageHeight(std::string pageHeight_) { m_pageHeight = pageHeight_; };
     std::string GetPageHeight() const { return m_pageHeight; };
-    bool HasPageHeight();
+    bool HasPageHeight() const;
     //
     void SetPageWidth(std::string pageWidth_) { m_pageWidth = pageWidth_; };
     std::string GetPageWidth() const { return m_pageWidth; };
-    bool HasPageWidth();
+    bool HasPageWidth() const;
     //
     void SetPageTopmar(std::string pageTopmar_) { m_pageTopmar = pageTopmar_; };
     std::string GetPageTopmar() const { return m_pageTopmar; };
-    bool HasPageTopmar();
+    bool HasPageTopmar() const;
     //
     void SetPageBotmar(std::string pageBotmar_) { m_pageBotmar = pageBotmar_; };
     std::string GetPageBotmar() const { return m_pageBotmar; };
-    bool HasPageBotmar();
+    bool HasPageBotmar() const;
     //
     void SetPageLeftmar(std::string pageLeftmar_) { m_pageLeftmar = pageLeftmar_; };
     std::string GetPageLeftmar() const { return m_pageLeftmar; };
-    bool HasPageLeftmar();
+    bool HasPageLeftmar() const;
     //
     void SetPageRightmar(std::string pageRightmar_) { m_pageRightmar = pageRightmar_; };
     std::string GetPageRightmar() const { return m_pageRightmar; };
-    bool HasPageRightmar();
+    bool HasPageRightmar() const;
     //
     void SetPagePanels(std::string pagePanels_) { m_pagePanels = pagePanels_; };
     std::string GetPagePanels() const { return m_pagePanels; };
-    bool HasPagePanels();
+    bool HasPagePanels() const;
     //
     void SetPageScale(std::string pageScale_) { m_pageScale = pageScale_; };
     std::string GetPageScale() const { return m_pageScale; };
-    bool HasPageScale();
+    bool HasPageScale() const;
     ///@}
 
 private:
@@ -3884,7 +3884,7 @@ class AttPbVis : public Att {
     ///@{
     void SetFolium(pbVis_FOLIUM folium_) { m_folium = folium_; };
     pbVis_FOLIUM GetFolium() const { return m_folium; };
-    bool HasFolium();
+    bool HasFolium() const;
     ///@}
 
 private:
@@ -3923,7 +3923,7 @@ class AttPitch : public Att {
     ///@{
     void SetPname(data_PITCHNAME pname_) { m_pname = pname_; };
     data_PITCHNAME GetPname() const { return m_pname; };
-    bool HasPname();
+    bool HasPname() const;
     ///@}
 
 private:
@@ -3959,7 +3959,7 @@ class AttPlacement : public Att {
     ///@{
     void SetPlace(data_STAFFREL place_) { m_place = place_; };
     data_STAFFREL GetPlace() const { return m_place; };
-    bool HasPlace();
+    bool HasPlace() const;
     ///@}
 
 private:
@@ -3998,11 +3998,11 @@ class AttPlist : public Att {
     ///@{
     void SetPlist(std::string plist_) { m_plist = plist_; };
     std::string GetPlist() const { return m_plist; };
-    bool HasPlist();
+    bool HasPlist() const;
     //
     void SetEvaluate(plist_EVALUATE evaluate_) { m_evaluate = evaluate_; };
     plist_EVALUATE GetEvaluate() const { return m_evaluate; };
-    bool HasEvaluate();
+    bool HasEvaluate() const;
     ///@}
 
 private:
@@ -4043,27 +4043,27 @@ class AttPointing : public Att {
     ///@{
     void SetActuate(std::string actuate_) { m_actuate = actuate_; };
     std::string GetActuate() const { return m_actuate; };
-    bool HasActuate();
+    bool HasActuate() const;
     //
     void SetRole(std::string role_) { m_role = role_; };
     std::string GetRole() const { return m_role; };
-    bool HasRole();
+    bool HasRole() const;
     //
     void SetShow(std::string show_) { m_show = show_; };
     std::string GetShow() const { return m_show; };
-    bool HasShow();
+    bool HasShow() const;
     //
     void SetTarget(std::string target_) { m_target = target_; };
     std::string GetTarget() const { return m_target; };
-    bool HasTarget();
+    bool HasTarget() const;
     //
     void SetTargettype(std::string targettype_) { m_targettype = targettype_; };
     std::string GetTargettype() const { return m_targettype; };
-    bool HasTargettype();
+    bool HasTargettype() const;
     //
     void SetTitle(std::string title_) { m_title = title_; };
     std::string GetTitle() const { return m_title; };
-    bool HasTitle();
+    bool HasTitle() const;
     ///@}
 
 private:
@@ -4119,7 +4119,7 @@ class AttQuantity : public Att {
     ///@{
     void SetQuantity(double quantity_) { m_quantity = quantity_; };
     double GetQuantity() const { return m_quantity; };
-    bool HasQuantity();
+    bool HasQuantity() const;
     ///@}
 
 private:
@@ -4158,7 +4158,7 @@ class AttRelativesize : public Att {
     ///@{
     void SetSize(data_SIZE size_) { m_size = size_; };
     data_SIZE GetSize() const { return m_size; };
-    bool HasSize();
+    bool HasSize() const;
     ///@}
 
 private:
@@ -4194,7 +4194,7 @@ class AttResponsibility : public Att {
     ///@{
     void SetResp(std::string resp_) { m_resp = resp_; };
     std::string GetResp() const { return m_resp; };
-    bool HasResp();
+    bool HasResp() const;
     ///@}
 
 private:
@@ -4234,7 +4234,7 @@ class AttSbVis : public Att {
     ///@{
     void SetForm(sbVis_FORM form_) { m_form = form_; };
     sbVis_FORM GetForm() const { return m_form; };
-    bool HasForm();
+    bool HasForm() const;
     ///@}
 
 private:
@@ -4270,7 +4270,7 @@ class AttScalable : public Att {
     ///@{
     void SetScale(int scale_) { m_scale = scale_; };
     int GetScale() const { return m_scale; };
-    bool HasScale();
+    bool HasScale() const;
     ///@}
 
 private:
@@ -4306,15 +4306,15 @@ class AttScoreDefGes : public Att {
     ///@{
     void SetTunePname(data_PITCHNAME tunePname_) { m_tunePname = tunePname_; };
     data_PITCHNAME GetTunePname() const { return m_tunePname; };
-    bool HasTunePname();
+    bool HasTunePname() const;
     //
     void SetTuneHz(double tuneHz_) { m_tuneHz = tuneHz_; };
     double GetTuneHz() const { return m_tuneHz; };
-    bool HasTuneHz();
+    bool HasTuneHz() const;
     //
     void SetTuneTemper(data_TEMPERAMENT tuneTemper_) { m_tuneTemper = tuneTemper_; };
     data_TEMPERAMENT GetTuneTemper() const { return m_tuneTemper; };
-    bool HasTuneTemper();
+    bool HasTuneTemper() const;
     ///@}
 
 private:
@@ -4354,7 +4354,7 @@ class AttScoreDefVis : public Att {
     ///@{
     void SetVuHeight(std::string vuHeight_) { m_vuHeight = vuHeight_; };
     std::string GetVuHeight() const { return m_vuHeight; };
-    bool HasVuHeight();
+    bool HasVuHeight() const;
     ///@}
 
 private:
@@ -4394,7 +4394,7 @@ class AttSectionVis : public Att {
     ///@{
     void SetRestart(data_BOOLEAN restart_) { m_restart = restart_; };
     data_BOOLEAN GetRestart() const { return m_restart; };
-    bool HasRestart();
+    bool HasRestart() const;
     ///@}
 
 private:
@@ -4430,7 +4430,7 @@ class AttSequence : public Att {
     ///@{
     void SetSeq(int seq_) { m_seq = seq_; };
     int GetSeq() const { return m_seq; };
-    bool HasSeq();
+    bool HasSeq() const;
     ///@}
 
 private:
@@ -4469,7 +4469,7 @@ class AttSlashcount : public Att {
     ///@{
     void SetSlash(char slash_) { m_slash = slash_; };
     char GetSlash() const { return m_slash; };
-    bool HasSlash();
+    bool HasSlash() const;
     ///@}
 
 private:
@@ -4505,7 +4505,7 @@ class AttSlurpresent : public Att {
     ///@{
     void SetSlur(std::string slur_) { m_slur = slur_; };
     std::string GetSlur() const { return m_slur; };
-    bool HasSlur();
+    bool HasSlur() const;
     ///@}
 
 private:
@@ -4545,7 +4545,7 @@ class AttSpaceVis : public Att {
     ///@{
     void SetCompressable(data_BOOLEAN compressable_) { m_compressable = compressable_; };
     data_BOOLEAN GetCompressable() const { return m_compressable; };
-    bool HasCompressable();
+    bool HasCompressable() const;
     ///@}
 
 private:
@@ -4584,19 +4584,19 @@ class AttSpacing : public Att {
     ///@{
     void SetSpacingPackexp(double spacingPackexp_) { m_spacingPackexp = spacingPackexp_; };
     double GetSpacingPackexp() const { return m_spacingPackexp; };
-    bool HasSpacingPackexp();
+    bool HasSpacingPackexp() const;
     //
     void SetSpacingPackfact(double spacingPackfact_) { m_spacingPackfact = spacingPackfact_; };
     double GetSpacingPackfact() const { return m_spacingPackfact; };
-    bool HasSpacingPackfact();
+    bool HasSpacingPackfact() const;
     //
     void SetSpacingStaff(std::string spacingStaff_) { m_spacingStaff = spacingStaff_; };
     std::string GetSpacingStaff() const { return m_spacingStaff; };
-    bool HasSpacingStaff();
+    bool HasSpacingStaff() const;
     //
     void SetSpacingSystem(std::string spacingSystem_) { m_spacingSystem = spacingSystem_; };
     std::string GetSpacingSystem() const { return m_spacingSystem; };
-    bool HasSpacingSystem();
+    bool HasSpacingSystem() const;
     ///@}
 
 private:
@@ -4647,7 +4647,7 @@ class AttStaffLog : public Att {
     ///@{
     void SetDef(std::string def_) { m_def = def_; };
     std::string GetDef() const { return m_def; };
-    bool HasDef();
+    bool HasDef() const;
     ///@}
 
 private:
@@ -4683,27 +4683,27 @@ class AttStaffDefVis : public Att {
     ///@{
     void SetGridShow(data_BOOLEAN gridShow_) { m_gridShow = gridShow_; };
     data_BOOLEAN GetGridShow() const { return m_gridShow; };
-    bool HasGridShow();
+    bool HasGridShow() const;
     //
     void SetLayerscheme(data_LAYERSCHEME layerscheme_) { m_layerscheme = layerscheme_; };
     data_LAYERSCHEME GetLayerscheme() const { return m_layerscheme; };
-    bool HasLayerscheme();
+    bool HasLayerscheme() const;
     //
     void SetLines(int lines_) { m_lines = lines_; };
     int GetLines() const { return m_lines; };
-    bool HasLines();
+    bool HasLines() const;
     //
     void SetLinesColor(std::string linesColor_) { m_linesColor = linesColor_; };
     std::string GetLinesColor() const { return m_linesColor; };
-    bool HasLinesColor();
+    bool HasLinesColor() const;
     //
     void SetLinesVisible(data_BOOLEAN linesVisible_) { m_linesVisible = linesVisible_; };
     data_BOOLEAN GetLinesVisible() const { return m_linesVisible; };
-    bool HasLinesVisible();
+    bool HasLinesVisible() const;
     //
     void SetSpacing(std::string spacing_) { m_spacing = spacing_; };
     std::string GetSpacing() const { return m_spacing; };
-    bool HasSpacing();
+    bool HasSpacing() const;
     ///@}
 
 private:
@@ -4761,7 +4761,7 @@ class AttStaffGrpVis : public Att {
     ///@{
     void SetBarthru(data_BOOLEAN barthru_) { m_barthru = barthru_; };
     data_BOOLEAN GetBarthru() const { return m_barthru; };
-    bool HasBarthru();
+    bool HasBarthru() const;
     ///@}
 
 private:
@@ -4800,7 +4800,7 @@ class AttStaffgroupingsym : public Att {
     ///@{
     void SetSymbol(staffgroupingsym_SYMBOL symbol_) { m_symbol = symbol_; };
     staffgroupingsym_SYMBOL GetSymbol() const { return m_symbol; };
-    bool HasSymbol();
+    bool HasSymbol() const;
     ///@}
 
 private:
@@ -4836,7 +4836,7 @@ class AttStaffident : public Att {
     ///@{
     void SetStaff(xsd_posIntList staff_) { m_staff = staff_; };
     xsd_posIntList GetStaff() const { return m_staff; };
-    bool HasStaff();
+    bool HasStaff() const;
     ///@}
 
 private:
@@ -4876,7 +4876,7 @@ class AttStaffloc : public Att {
     ///@{
     void SetLoc(int loc_) { m_loc = loc_; };
     int GetLoc() const { return m_loc; };
-    bool HasLoc();
+    bool HasLoc() const;
     ///@}
 
 private:
@@ -4912,11 +4912,11 @@ class AttStafflocPitched : public Att {
     ///@{
     void SetPloc(data_PITCHNAME ploc_) { m_ploc = ploc_; };
     data_PITCHNAME GetPloc() const { return m_ploc; };
-    bool HasPloc();
+    bool HasPloc() const;
     //
     void SetOloc(char oloc_) { m_oloc = oloc_; };
     char GetOloc() const { return m_oloc; };
-    bool HasOloc();
+    bool HasOloc() const;
     ///@}
 
 private:
@@ -4954,7 +4954,7 @@ class AttStartendid : public Att {
     ///@{
     void SetEndid(std::string endid_) { m_endid = endid_; };
     std::string GetEndid() const { return m_endid; };
-    bool HasEndid();
+    bool HasEndid() const;
     ///@}
 
 private:
@@ -4993,7 +4993,7 @@ class AttStartid : public Att {
     ///@{
     void SetStartid(std::string startid_) { m_startid = startid_; };
     std::string GetStartid() const { return m_startid; };
-    bool HasStartid();
+    bool HasStartid() const;
     ///@}
 
 private:
@@ -5032,27 +5032,27 @@ class AttStems : public Att {
     ///@{
     void SetStemDir(data_STEMDIRECTION stemDir_) { m_stemDir = stemDir_; };
     data_STEMDIRECTION GetStemDir() const { return m_stemDir; };
-    bool HasStemDir();
+    bool HasStemDir() const;
     //
     void SetStemLen(std::string stemLen_) { m_stemLen = stemLen_; };
     std::string GetStemLen() const { return m_stemLen; };
-    bool HasStemLen();
+    bool HasStemLen() const;
     //
     void SetStemMod(data_STEMMODIFIER stemMod_) { m_stemMod = stemMod_; };
     data_STEMMODIFIER GetStemMod() const { return m_stemMod; };
-    bool HasStemMod();
+    bool HasStemMod() const;
     //
     void SetStemPos(data_STEMPOSITION stemPos_) { m_stemPos = stemPos_; };
     data_STEMPOSITION GetStemPos() const { return m_stemPos; };
-    bool HasStemPos();
+    bool HasStemPos() const;
     //
     void SetStemX(double stemX_) { m_stemX = stemX_; };
     double GetStemX() const { return m_stemX; };
-    bool HasStemX();
+    bool HasStemX() const;
     //
     void SetStemY(double stemY_) { m_stemY = stemY_; };
     double GetStemY() const { return m_stemY; };
-    bool HasStemY();
+    bool HasStemY() const;
     ///@}
 
 private:
@@ -5101,11 +5101,11 @@ class AttSylLog : public Att {
     ///@{
     void SetCon(sylLog_CON con_) { m_con = con_; };
     sylLog_CON GetCon() const { return m_con; };
-    bool HasCon();
+    bool HasCon() const;
     //
     void SetWordpos(sylLog_WORDPOS wordpos_) { m_wordpos = wordpos_; };
     sylLog_WORDPOS GetWordpos() const { return m_wordpos; };
-    bool HasWordpos();
+    bool HasWordpos() const;
     ///@}
 
 private:
@@ -5146,7 +5146,7 @@ class AttSyltext : public Att {
     ///@{
     void SetSyl(std::string syl_) { m_syl = syl_; };
     std::string GetSyl() const { return m_syl; };
-    bool HasSyl();
+    bool HasSyl() const;
     ///@}
 
 private:
@@ -5182,19 +5182,19 @@ class AttSystems : public Att {
     ///@{
     void SetSystemLeftline(data_BOOLEAN systemLeftline_) { m_systemLeftline = systemLeftline_; };
     data_BOOLEAN GetSystemLeftline() const { return m_systemLeftline; };
-    bool HasSystemLeftline();
+    bool HasSystemLeftline() const;
     //
     void SetSystemLeftmar(std::string systemLeftmar_) { m_systemLeftmar = systemLeftmar_; };
     std::string GetSystemLeftmar() const { return m_systemLeftmar; };
-    bool HasSystemLeftmar();
+    bool HasSystemLeftmar() const;
     //
     void SetSystemRightmar(std::string systemRightmar_) { m_systemRightmar = systemRightmar_; };
     std::string GetSystemRightmar() const { return m_systemRightmar; };
-    bool HasSystemRightmar();
+    bool HasSystemRightmar() const;
     //
     void SetSystemTopmar(std::string systemTopmar_) { m_systemTopmar = systemTopmar_; };
     std::string GetSystemTopmar() const { return m_systemTopmar; };
-    bool HasSystemTopmar();
+    bool HasSystemTopmar() const;
     ///@}
 
 private:
@@ -5249,23 +5249,23 @@ class AttTextstyle : public Att {
     ///@{
     void SetTextFam(std::string textFam_) { m_textFam = textFam_; };
     std::string GetTextFam() const { return m_textFam; };
-    bool HasTextFam();
+    bool HasTextFam() const;
     //
     void SetTextName(std::string textName_) { m_textName = textName_; };
     std::string GetTextName() const { return m_textName; };
-    bool HasTextName();
+    bool HasTextName() const;
     //
     void SetTextSize(std::string textSize_) { m_textSize = textSize_; };
     std::string GetTextSize() const { return m_textSize; };
-    bool HasTextSize();
+    bool HasTextSize() const;
     //
     void SetTextStyle(data_FONTSTYLE textStyle_) { m_textStyle = textStyle_; };
     data_FONTSTYLE GetTextStyle() const { return m_textStyle; };
-    bool HasTextStyle();
+    bool HasTextStyle() const;
     //
     void SetTextWeight(data_FONTWEIGHT textWeight_) { m_textWeight = textWeight_; };
     data_FONTWEIGHT GetTextWeight() const { return m_textWeight; };
-    bool HasTextWeight();
+    bool HasTextWeight() const;
     ///@}
 
 private:
@@ -5324,7 +5324,7 @@ class AttTiepresent : public Att {
     ///@{
     void SetTie(data_TIE tie_) { m_tie = tie_; };
     data_TIE GetTie() const { return m_tie; };
-    bool HasTie();
+    bool HasTie() const;
     ///@}
 
 private:
@@ -5364,7 +5364,7 @@ class AttTimestampMusical : public Att {
     ///@{
     void SetTstamp(double tstamp_) { m_tstamp = tstamp_; };
     double GetTstamp() const { return m_tstamp; };
-    bool HasTstamp();
+    bool HasTstamp() const;
     ///@}
 
 private:
@@ -5403,11 +5403,11 @@ class AttTimestampPerformed : public Att {
     ///@{
     void SetTstampGes(data_DURATION tstampGes_) { m_tstampGes = tstampGes_; };
     data_DURATION GetTstampGes() const { return m_tstampGes; };
-    bool HasTstampGes();
+    bool HasTstampGes() const;
     //
     void SetTstampReal(std::string tstampReal_) { m_tstampReal = tstampReal_; };
     std::string GetTstampReal() const { return m_tstampReal; };
-    bool HasTstampReal();
+    bool HasTstampReal() const;
     ///@}
 
 private:
@@ -5449,7 +5449,7 @@ class AttTimestamp2Musical : public Att {
     ///@{
     void SetTstamp2(data_MEASUREBEAT tstamp2_) { m_tstamp2 = tstamp2_; };
     data_MEASUREBEAT GetTstamp2() const { return m_tstamp2; };
-    bool HasTstamp2();
+    bool HasTstamp2() const;
     ///@}
 
 private:
@@ -5488,11 +5488,11 @@ class AttTransposition : public Att {
     ///@{
     void SetTransDiat(double transDiat_) { m_transDiat = transDiat_; };
     double GetTransDiat() const { return m_transDiat; };
-    bool HasTransDiat();
+    bool HasTransDiat() const;
     //
     void SetTransSemi(double transSemi_) { m_transSemi = transSemi_; };
     double GetTransSemi() const { return m_transSemi; };
-    bool HasTransSemi();
+    bool HasTransSemi() const;
     ///@}
 
 private:
@@ -5536,7 +5536,7 @@ class AttTupletpresent : public Att {
     ///@{
     void SetTuplet(std::string tuplet_) { m_tuplet = tuplet_; };
     std::string GetTuplet() const { return m_tuplet; };
-    bool HasTuplet();
+    bool HasTuplet() const;
     ///@}
 
 private:
@@ -5576,11 +5576,11 @@ class AttTyped : public Att {
     ///@{
     void SetType(std::string type_) { m_type = type_; };
     std::string GetType() const { return m_type; };
-    bool HasType();
+    bool HasType() const;
     //
     void SetSubtype(std::string subtype_) { m_subtype = subtype_; };
     std::string GetSubtype() const { return m_subtype; };
-    bool HasSubtype();
+    bool HasSubtype() const;
     ///@}
 
 private:
@@ -5624,23 +5624,23 @@ class AttTypography : public Att {
     ///@{
     void SetFontfam(std::string fontfam_) { m_fontfam = fontfam_; };
     std::string GetFontfam() const { return m_fontfam; };
-    bool HasFontfam();
+    bool HasFontfam() const;
     //
     void SetFontname(std::string fontname_) { m_fontname = fontname_; };
     std::string GetFontname() const { return m_fontname; };
-    bool HasFontname();
+    bool HasFontname() const;
     //
     void SetFontsize(double fontsize_) { m_fontsize = fontsize_; };
     double GetFontsize() const { return m_fontsize; };
-    bool HasFontsize();
+    bool HasFontsize() const;
     //
     void SetFontstyle(data_FONTSTYLE fontstyle_) { m_fontstyle = fontstyle_; };
     data_FONTSTYLE GetFontstyle() const { return m_fontstyle; };
-    bool HasFontstyle();
+    bool HasFontstyle() const;
     //
     void SetFontweight(data_FONTWEIGHT fontweight_) { m_fontweight = fontweight_; };
     data_FONTWEIGHT GetFontweight() const { return m_fontweight; };
-    bool HasFontweight();
+    bool HasFontweight() const;
     ///@}
 
 private:
@@ -5684,7 +5684,7 @@ class AttVisibility : public Att {
     ///@{
     void SetVisible(data_BOOLEAN visible_) { m_visible = visible_; };
     data_BOOLEAN GetVisible() const { return m_visible; };
-    bool HasVisible();
+    bool HasVisible() const;
     ///@}
 
 private:
@@ -5723,7 +5723,7 @@ class AttVisualoffsetHo : public Att {
     ///@{
     void SetHo(std::string ho_) { m_ho = ho_; };
     std::string GetHo() const { return m_ho; };
-    bool HasHo();
+    bool HasHo() const;
     ///@}
 
 private:
@@ -5763,7 +5763,7 @@ class AttVisualoffsetTo : public Att {
     ///@{
     void SetTo(double to_) { m_to = to_; };
     double GetTo() const { return m_to; };
-    bool HasTo();
+    bool HasTo() const;
     ///@}
 
 private:
@@ -5802,7 +5802,7 @@ class AttVisualoffsetVo : public Att {
     ///@{
     void SetVo(std::string vo_) { m_vo = vo_; };
     std::string GetVo() const { return m_vo; };
-    bool HasVo();
+    bool HasVo() const;
     ///@}
 
 private:
@@ -5842,11 +5842,11 @@ class AttVisualoffset2Ho : public Att {
     ///@{
     void SetStartho(std::string startho_) { m_startho = startho_; };
     std::string GetStartho() const { return m_startho; };
-    bool HasStartho();
+    bool HasStartho() const;
     //
     void SetEndho(std::string endho_) { m_endho = endho_; };
     std::string GetEndho() const { return m_endho; };
-    bool HasEndho();
+    bool HasEndho() const;
     ///@}
 
 private:
@@ -5890,11 +5890,11 @@ class AttVisualoffset2To : public Att {
     ///@{
     void SetStartto(double startto_) { m_startto = startto_; };
     double GetStartto() const { return m_startto; };
-    bool HasStartto();
+    bool HasStartto() const;
     //
     void SetEndto(double endto_) { m_endto = endto_; };
     double GetEndto() const { return m_endto; };
-    bool HasEndto();
+    bool HasEndto() const;
     ///@}
 
 private:
@@ -5938,11 +5938,11 @@ class AttVisualoffset2Vo : public Att {
     ///@{
     void SetStartvo(std::string startvo_) { m_startvo = startvo_; };
     std::string GetStartvo() const { return m_startvo; };
-    bool HasStartvo();
+    bool HasStartvo() const;
     //
     void SetEndvo(std::string endvo_) { m_endvo = endvo_; };
     std::string GetEndvo() const { return m_endvo; };
-    bool HasEndvo();
+    bool HasEndvo() const;
     ///@}
 
 private:
@@ -5986,7 +5986,7 @@ class AttWhitespace : public Att {
     ///@{
     void SetSpace(std::string space_) { m_space = space_; };
     std::string GetSpace() const { return m_space; };
-    bool HasSpace();
+    bool HasSpace() const;
     ///@}
 
 private:
@@ -6022,7 +6022,7 @@ class AttWidth : public Att {
     ///@{
     void SetWidth(std::string width_) { m_width = width_; };
     std::string GetWidth() const { return m_width; };
-    bool HasWidth();
+    bool HasWidth() const;
     ///@}
 
 private:
@@ -6058,11 +6058,11 @@ class AttXy : public Att {
     ///@{
     void SetX(double x_) { m_x = x_; };
     double GetX() const { return m_x; };
-    bool HasX();
+    bool HasX() const;
     //
     void SetY(double y_) { m_y = y_; };
     double GetY() const { return m_y; };
-    bool HasY();
+    bool HasY() const;
     ///@}
 
 private:
@@ -6108,11 +6108,11 @@ class AttXy2 : public Att {
     ///@{
     void SetX2(double x2_) { m_x2 = x2_; };
     double GetX2() const { return m_x2; };
-    bool HasX2();
+    bool HasX2() const;
     //
     void SetY2(double y2_) { m_y2 = y2_; };
     double GetY2() const { return m_y2; };
-    bool HasY2();
+    bool HasY2() const;
     ///@}
 
 private:
diff --git a/libmei/atts_tablature.cpp b/libmei/atts_tablature.cpp
index ff1457643aa..090cb5d65ad 100644
--- a/libmei/atts_tablature.cpp
+++ b/libmei/atts_tablature.cpp
@@ -75,12 +75,12 @@ bool AttNoteGesTablature::WriteNoteGesTablature(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttNoteGesTablature::HasTabFret()
+bool AttNoteGesTablature::HasTabFret() const
 {
     return (m_tabFret != FRETNUMBER_NONE);
 }
 
-bool AttNoteGesTablature::HasTabString()
+bool AttNoteGesTablature::HasTabString() const
 {
     return (m_tabString != STRINGNUMBER_NONE);
 }
@@ -126,7 +126,7 @@ bool AttStaffDefGesTablature::WriteStaffDefGesTablature(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttStaffDefGesTablature::HasTabStrings()
+bool AttStaffDefGesTablature::HasTabStrings() const
 {
     return (m_tabStrings != "");
 }
@@ -159,10 +159,10 @@ bool Att::SetTablature(Object *element, std::string attrType, std::string attrVa
     return false;
 }
 
-void Att::GetTablature(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetTablature(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_NOTEGESTABLATURE)) {
-        AttNoteGesTablature *att = dynamic_cast<AttNoteGesTablature *>(element);
+        const AttNoteGesTablature *att = dynamic_cast<const AttNoteGesTablature *>(element);
         assert(att);
         if (att->HasTabFret()) {
             attributes->push_back(std::make_pair("tab.fret", att->FretnumberToStr(att->GetTabFret())));
@@ -172,7 +172,7 @@ void Att::GetTablature(Object *element, ArrayOfStrAttr *attributes)
         }
     }
     if (element->HasAttClass(ATT_STAFFDEFGESTABLATURE)) {
-        AttStaffDefGesTablature *att = dynamic_cast<AttStaffDefGesTablature *>(element);
+        const AttStaffDefGesTablature *att = dynamic_cast<const AttStaffDefGesTablature *>(element);
         assert(att);
         if (att->HasTabStrings()) {
             attributes->push_back(std::make_pair("tab.strings", att->StrToStr(att->GetTabStrings())));
diff --git a/libmei/atts_tablature.h b/libmei/atts_tablature.h
index ab6d623b3d7..69a49553777 100644
--- a/libmei/atts_tablature.h
+++ b/libmei/atts_tablature.h
@@ -51,11 +51,11 @@ class AttNoteGesTablature : public Att {
     ///@{
     void SetTabFret(data_FRETNUMBER tabFret_) { m_tabFret = tabFret_; };
     data_FRETNUMBER GetTabFret() const { return m_tabFret; };
-    bool HasTabFret();
+    bool HasTabFret() const;
     //
     void SetTabString(data_STRINGNUMBER tabString_) { m_tabString = tabString_; };
     data_STRINGNUMBER GetTabString() const { return m_tabString; };
-    bool HasTabString();
+    bool HasTabString() const;
     ///@}
 
 private:
@@ -93,7 +93,7 @@ class AttStaffDefGesTablature : public Att {
     ///@{
     void SetTabStrings(std::string tabStrings_) { m_tabStrings = tabStrings_; };
     std::string GetTabStrings() const { return m_tabStrings; };
-    bool HasTabStrings();
+    bool HasTabStrings() const;
     ///@}
 
 private:
diff --git a/libmei/atts_usersymbols.cpp b/libmei/atts_usersymbols.cpp
index 80a607398c5..183412cb131 100644
--- a/libmei/atts_usersymbols.cpp
+++ b/libmei/atts_usersymbols.cpp
@@ -65,7 +65,7 @@ bool AttAltsym::WriteAltsym(pugi::xml_node element)
     return wroteAttribute;
 }
 
-bool AttAltsym::HasAltsym()
+bool AttAltsym::HasAltsym() const
 {
     return (m_altsym != "");
 }
@@ -86,10 +86,10 @@ bool Att::SetUsersymbols(Object *element, std::string attrType, std::string attr
     return false;
 }
 
-void Att::GetUsersymbols(Object *element, ArrayOfStrAttr *attributes)
+void Att::GetUsersymbols(const Object *element, ArrayOfStrAttr *attributes)
 {
     if (element->HasAttClass(ATT_ALTSYM)) {
-        AttAltsym *att = dynamic_cast<AttAltsym *>(element);
+        const AttAltsym *att = dynamic_cast<const AttAltsym *>(element);
         assert(att);
         if (att->HasAltsym()) {
             attributes->push_back(std::make_pair("altsym", att->StrToStr(att->GetAltsym())));
diff --git a/libmei/atts_usersymbols.h b/libmei/atts_usersymbols.h
index 25369554363..3fee42adb40 100644
--- a/libmei/atts_usersymbols.h
+++ b/libmei/atts_usersymbols.h
@@ -51,7 +51,7 @@ class AttAltsym : public Att {
     ///@{
     void SetAltsym(std::string altsym_) { m_altsym = altsym_; };
     std::string GetAltsym() const { return m_altsym; };
-    bool HasAltsym();
+    bool HasAltsym() const;
     ///@}
 
 private:
diff --git a/src/aligner.cpp b/src/aligner.cpp
index 757d0bdb4d0..8ff7c76802b 100644
--- a/src/aligner.cpp
+++ b/src/aligner.cpp
@@ -74,7 +74,7 @@ StaffAlignment *SystemAligner::GetStaffAlignment(int idx, Staff *staff)
     return alignment;
 }
 
-StaffAlignment *SystemAligner::GetStaffAlignmentForStaffN(int staffN)
+StaffAlignment *SystemAligner::GetStaffAlignmentForStaffN(int staffN) const
 {
     StaffAlignment *alignment = NULL;
     int i;
diff --git a/src/att.cpp b/src/att.cpp
index b23074f4ee8..2e4cc8430f5 100644
--- a/src/att.cpp
+++ b/src/att.cpp
@@ -31,37 +31,37 @@ Att::~Att()
 {
 }
 
-std::string Att::StrToStr(std::string str)
+std::string Att::StrToStr(std::string str) const
 {
     return str;
 }
 
 // Basic converters for writing
 
-std::string Att::DblToStr(double data)
+std::string Att::DblToStr(double data) const
 {
     return StringFormat("%f", data);
 }
 
-std::string Att::IntToStr(int data)
+std::string Att::IntToStr(int data) const
 {
     return StringFormat("%d", data);
 }
 
 // Basic converters for reading
 
-double Att::StrToDbl(std::string value)
+double Att::StrToDbl(std::string value) const
 {
     return atof(value.c_str());
 }
-int Att::StrToInt(std::string value)
+int Att::StrToInt(std::string value) const
 {
     return atoi(value.c_str());
 }
 
 // Converters for writing and reading
 
-std::string Att::BeatrptRendToStr(data_BEATRPT_REND data)
+std::string Att::BeatrptRendToStr(data_BEATRPT_REND data) const
 {
     std::string value;
     switch (data) {
@@ -80,7 +80,7 @@ std::string Att::BeatrptRendToStr(data_BEATRPT_REND data)
     return value;
 }
 
-data_BEATRPT_REND Att::StrToBeatrptRend(std::string value)
+data_BEATRPT_REND Att::StrToBeatrptRend(std::string value) const
 {
     if (value == "4") return BEATRPT_REND_4;
     if (value == "8") return BEATRPT_REND_8;
@@ -93,7 +93,7 @@ data_BEATRPT_REND Att::StrToBeatrptRend(std::string value)
     return BEATRPT_REND_NONE;
 }
 
-std::string Att::DurationToStr(data_DURATION data)
+std::string Att::DurationToStr(data_DURATION data) const
 {
     std::string value;
     switch (data) {
@@ -124,7 +124,7 @@ std::string Att::DurationToStr(data_DURATION data)
     return value;
 }
 
-data_DURATION Att::StrToDuration(std::string value)
+data_DURATION Att::StrToDuration(std::string value) const
 {
     if (value == "maxima") return DURATION_maxima;
     if (value == "longa") return DURATION_longa;
@@ -154,7 +154,7 @@ data_DURATION Att::StrToDuration(std::string value)
     return DURATION_NONE;
 }
 
-std::string Att::KeysignatureToStr(data_KEYSIGNATURE data)
+std::string Att::KeysignatureToStr(data_KEYSIGNATURE data) const
 {
     std::string value;
     switch (data) {
@@ -182,7 +182,7 @@ std::string Att::KeysignatureToStr(data_KEYSIGNATURE data)
     return value;
 }
 
-data_KEYSIGNATURE Att::StrToKeysignature(std::string value)
+data_KEYSIGNATURE Att::StrToKeysignature(std::string value) const
 {
     if (value == "7f") return KEYSIGNATURE_7f;
     if (value == "6f") return KEYSIGNATURE_6f;
@@ -204,12 +204,12 @@ data_KEYSIGNATURE Att::StrToKeysignature(std::string value)
     return KEYSIGNATURE_NONE;
 }
 
-std::string Att::MeasurebeatToStr(data_MEASUREBEAT data)
+std::string Att::MeasurebeatToStr(data_MEASUREBEAT data) const
 {
     return StringFormat("%dm+%.1f", data.first, data.second);
 }
 
-data_MEASUREBEAT Att::StrToMeasurebeat(std::string value)
+data_MEASUREBEAT Att::StrToMeasurebeat(std::string value) const
 {
     for (size_t i = 0; i < value.length(); i++) {
         if (iswspace(value[i])) {
@@ -231,7 +231,7 @@ data_MEASUREBEAT Att::StrToMeasurebeat(std::string value)
     return std::make_pair(measure, timePoint);
 }
 
-std::string Att::ModusmaiorToStr(data_MODUSMAIOR data)
+std::string Att::ModusmaiorToStr(data_MODUSMAIOR data) const
 {
     std::string value;
     switch (data) {
@@ -245,7 +245,7 @@ std::string Att::ModusmaiorToStr(data_MODUSMAIOR data)
     return value;
 }
 
-data_MODUSMAIOR Att::StrToModusmaior(std::string value)
+data_MODUSMAIOR Att::StrToModusmaior(std::string value) const
 {
     if (value == "2") return MODUSMAIOR_2;
     if (value == "3") return MODUSMAIOR_3;
@@ -253,7 +253,7 @@ data_MODUSMAIOR Att::StrToModusmaior(std::string value)
     return MODUSMAIOR_NONE;
 }
 
-std::string Att::ModusminorToStr(data_MODUSMINOR data)
+std::string Att::ModusminorToStr(data_MODUSMINOR data) const
 {
     std::string value;
     switch (data) {
@@ -267,7 +267,7 @@ std::string Att::ModusminorToStr(data_MODUSMINOR data)
     return value;
 }
 
-data_MODUSMINOR Att::StrToModusminor(std::string value)
+data_MODUSMINOR Att::StrToModusminor(std::string value) const
 {
     if (value == "2") return MODUSMINOR_2;
     if (value == "3") return MODUSMINOR_3;
@@ -275,7 +275,7 @@ data_MODUSMINOR Att::StrToModusminor(std::string value)
     return MODUSMINOR_NONE;
 }
 
-std::string Att::PitchnameToStr(data_PITCHNAME data)
+std::string Att::PitchnameToStr(data_PITCHNAME data) const
 {
     std::string value;
     switch (data) {
@@ -294,7 +294,7 @@ std::string Att::PitchnameToStr(data_PITCHNAME data)
     return value;
 }
 
-data_PITCHNAME Att::StrToPitchname(std::string value)
+data_PITCHNAME Att::StrToPitchname(std::string value) const
 {
     if (value == "c") return PITCHNAME_c;
     if (value == "d") return PITCHNAME_d;
@@ -307,7 +307,7 @@ data_PITCHNAME Att::StrToPitchname(std::string value)
     return PITCHNAME_NONE;
 }
 
-std::string Att::OctaveDisToStr(data_OCTAVE_DIS data)
+std::string Att::OctaveDisToStr(data_OCTAVE_DIS data) const
 {
     std::string value;
     switch (data) {
@@ -322,7 +322,7 @@ std::string Att::OctaveDisToStr(data_OCTAVE_DIS data)
     return value;
 }
 
-data_OCTAVE_DIS Att::StrToOctaveDis(std::string value)
+data_OCTAVE_DIS Att::StrToOctaveDis(std::string value) const
 {
     if (value == "8") return OCTAVE_DIS_8;
     if (value == "15") return OCTAVE_DIS_15;
@@ -331,7 +331,7 @@ data_OCTAVE_DIS Att::StrToOctaveDis(std::string value)
     return OCTAVE_DIS_NONE;
 }
 
-std::string Att::OrientationToStr(data_ORIENTATION data)
+std::string Att::OrientationToStr(data_ORIENTATION data) const
 {
     std::string value;
     switch (data) {
@@ -346,7 +346,7 @@ std::string Att::OrientationToStr(data_ORIENTATION data)
     return value;
 }
 
-data_ORIENTATION Att::StrToOrientation(std::string value)
+data_ORIENTATION Att::StrToOrientation(std::string value) const
 {
     if (value == "reversed") return ORIENTATION_reversed;
     if (value == "90CW") return ORIENTATION_90CW;
@@ -355,7 +355,7 @@ data_ORIENTATION Att::StrToOrientation(std::string value)
     return ORIENTATION_NONE;
 }
 
-std::string Att::ProlatioToStr(data_PROLATIO data)
+std::string Att::ProlatioToStr(data_PROLATIO data) const
 {
     std::string value;
     switch (data) {
@@ -369,7 +369,7 @@ std::string Att::ProlatioToStr(data_PROLATIO data)
     return value;
 }
 
-data_PROLATIO Att::StrToProlatio(std::string value)
+data_PROLATIO Att::StrToProlatio(std::string value) const
 {
     if (value == "2") return PROLATIO_2;
     if (value == "3") return PROLATIO_3;
@@ -377,7 +377,7 @@ data_PROLATIO Att::StrToProlatio(std::string value)
     return PROLATIO_NONE;
 }
 
-std::string Att::StemdirectionToStr(data_STEMDIRECTION data)
+std::string Att::StemdirectionToStr(data_STEMDIRECTION data) const
 {
     std::string value;
     switch (data) {
@@ -391,7 +391,7 @@ std::string Att::StemdirectionToStr(data_STEMDIRECTION data)
     return value;
 }
 
-data_STEMDIRECTION Att::StrToStemdirection(std::string value)
+data_STEMDIRECTION Att::StrToStemdirection(std::string value) const
 {
     if (value == "up") return STEMDIRECTION_up;
     if (value == "down") return STEMDIRECTION_down;
@@ -399,7 +399,7 @@ data_STEMDIRECTION Att::StrToStemdirection(std::string value)
     return STEMDIRECTION_NONE;
 }
 
-std::string Att::TempusToStr(data_TEMPUS data)
+std::string Att::TempusToStr(data_TEMPUS data) const
 {
     std::string value;
     switch (data) {
@@ -413,7 +413,7 @@ std::string Att::TempusToStr(data_TEMPUS data)
     return value;
 }
 
-data_TEMPUS Att::StrToTempus(std::string value)
+data_TEMPUS Att::StrToTempus(std::string value) const
 {
     if (value == "2") return TEMPUS_2;
     if (value == "3") return TEMPUS_3;
@@ -421,7 +421,7 @@ data_TEMPUS Att::StrToTempus(std::string value)
     return TEMPUS_NONE;
 }
 
-std::string Att::TieToStr(data_TIE data)
+std::string Att::TieToStr(data_TIE data) const
 {
     std::string value;
     switch (data) {
@@ -436,7 +436,7 @@ std::string Att::TieToStr(data_TIE data)
     return value;
 }
 
-data_TIE Att::StrToTie(std::string value)
+data_TIE Att::StrToTie(std::string value) const
 {
     if (value == "i") return TIE_i;
     if (value == "m") return TIE_m;
@@ -445,7 +445,7 @@ data_TIE Att::StrToTie(std::string value)
     return TIE_NONE;
 }
 
-std::string Att::XsdPosintlistToStr(xsd_posIntList data)
+std::string Att::XsdPosintlistToStr(xsd_posIntList data) const
 {
     std::ostringstream ss;
     for (size_t i = 0; i < data.size(); ++i) {
@@ -455,7 +455,7 @@ std::string Att::XsdPosintlistToStr(xsd_posIntList data)
     return ss.str();
 }
 
-xsd_posIntList Att::StrToXsdPosintlist(std::string value)
+xsd_posIntList Att::StrToXsdPosintlist(std::string value) const
 {
     xsd_posIntList list;
     std::istringstream iss(value);
diff --git a/src/barline.cpp b/src/barline.cpp
index c46459e660a..0fbf246e363 100644
--- a/src/barline.cpp
+++ b/src/barline.cpp
@@ -30,7 +30,7 @@ void BarLine::Reset()
     ResetBarLineLog();
 }
 
-bool BarLine::HasRepetitionDots()
+bool BarLine::HasRepetitionDots() const
 {
     if (GetForm() == BARRENDITION_rptstart || GetForm() == BARRENDITION_rptend || GetForm() == BARRENDITION_rptboth) {
         return true;
diff --git a/src/chord.cpp b/src/chord.cpp
index f938b8828c0..47dbb00d067 100644
--- a/src/chord.cpp
+++ b/src/chord.cpp
@@ -62,7 +62,7 @@ void Chord::Reset()
     ClearClusters();
 }
 
-void Chord::ClearClusters()
+void Chord::ClearClusters() const
 {
     std::list<ChordCluster *>::iterator iter;
     for (iter = m_clusters.begin(); iter != m_clusters.end(); ++iter) {
diff --git a/src/clef.cpp b/src/clef.cpp
index 38084d86ca0..35ba1f0dda9 100644
--- a/src/clef.cpp
+++ b/src/clef.cpp
@@ -19,7 +19,7 @@ Clef::Clef() : LayerElement("clef-"), AttClefshape(), AttLineloc(), AttOctavedis
     Init();
 }
 
-Clef::Clef(ScoreDefInterface *clefAttr) : LayerElement("clef-")
+Clef::Clef(const ScoreDefInterface *clefAttr) : LayerElement("clef-")
 {
     Init();
 
@@ -50,12 +50,12 @@ void Clef::Reset()
     ResetOctavedisplacement();
 }
 
-int Clef::GetClefId()
+int Clef::GetClefId() const
 {
     return GetDisPlace() << 24 | GetDis() << 16 | GetShape() << 8 | GetLine();
 }
 
-int Clef::GetClefOffset()
+int Clef::GetClefOffset() const
 {
     int clefCode = GetClefId();
     int offset = 0; // case 5: UT 1e ligne par default, valable pour PERC
diff --git a/src/doc.cpp b/src/doc.cpp
index 5e9c85715db..d431cbe24d8 100644
--- a/src/doc.cpp
+++ b/src/doc.cpp
@@ -497,17 +497,17 @@ void Doc::UnCastOff()
     this->SetCurrentScoreDef(true);
 }
 
-bool Doc::HasPage(int pageIdx)
+bool Doc::HasPage(int pageIdx) const
 {
     return ((pageIdx >= 0) && (pageIdx < GetChildCount()));
 }
 
-int Doc::GetPageCount()
+int Doc::GetPageCount() const
 {
     return GetChildCount();
 }
 
-int Doc::GetGlyphHeight(wchar_t smuflCode, int staffSize, bool graceSize)
+int Doc::GetGlyphHeight(wchar_t smuflCode, int staffSize, bool graceSize) const
 {
     int x, y, w, h;
     Glyph *glyph;
@@ -520,7 +520,7 @@ int Doc::GetGlyphHeight(wchar_t smuflCode, int staffSize, bool graceSize)
     return h;
 }
 
-int Doc::GetGlyphWidth(wchar_t smuflCode, int staffSize, bool graceSize)
+int Doc::GetGlyphWidth(wchar_t smuflCode, int staffSize, bool graceSize) const
 {
     int x, y, w, h;
     Glyph *glyph;
@@ -533,7 +533,7 @@ int Doc::GetGlyphWidth(wchar_t smuflCode, int staffSize, bool graceSize)
     return w;
 }
 
-int Doc::GetGlyphDescender(wchar_t smuflCode, int staffSize, bool graceSize)
+int Doc::GetGlyphDescender(wchar_t smuflCode, int staffSize, bool graceSize) const
 {
     int x, y, w, h;
     Glyph *glyph;
@@ -546,47 +546,47 @@ int Doc::GetGlyphDescender(wchar_t smuflCode, int staffSize, bool graceSize)
     return y;
 }
 
-int Doc::GetDrawingUnit(int staffSize)
+int Doc::GetDrawingUnit(int staffSize) const
 {
     return m_drawingUnit * staffSize / 100;
 }
 
-int Doc::GetDrawingDoubleUnit(int staffSize)
+int Doc::GetDrawingDoubleUnit(int staffSize) const
 {
     return m_drawingDoubleUnit * staffSize / 100;
 }
 
-int Doc::GetDrawingStaffSize(int staffSize)
+int Doc::GetDrawingStaffSize(int staffSize) const
 {
     return m_drawingStaffSize * staffSize / 100;
 }
 
-int Doc::GetDrawingOctaveSize(int staffSize)
+int Doc::GetDrawingOctaveSize(int staffSize) const
 {
     return m_drawingOctaveSize * staffSize / 100;
 }
 
-int Doc::GetDrawingBrevisWidth(int staffSize)
+int Doc::GetDrawingBrevisWidth(int staffSize) const
 {
     return m_drawingBrevisWidth * staffSize / 100;
 }
 
-int Doc::GetDrawingBarLineWidth(int staffSize)
+int Doc::GetDrawingBarLineWidth(int staffSize) const
 {
     return m_style->m_barLineWidth * staffSize / 100;
 }
 
-int Doc::GetDrawingStaffLineWidth(int staffSize)
+int Doc::GetDrawingStaffLineWidth(int staffSize) const
 {
     return m_style->m_staffLineWidth * staffSize / 100;
 }
 
-int Doc::GetDrawingStemWidth(int staffSize)
+int Doc::GetDrawingStemWidth(int staffSize) const
 {
     return m_style->m_stemWidth * staffSize / 100;
 }
 
-int Doc::GetDrawingDynamHeight(int staffSize, bool withMargin)
+int Doc::GetDrawingDynamHeight(int staffSize, bool withMargin) const
 {
     int height = GetGlyphHeight(SMUFL_E522_dynamicForte, staffSize, false);
     // This should be styled
@@ -594,7 +594,7 @@ int Doc::GetDrawingDynamHeight(int staffSize, bool withMargin)
     return height;
 }
 
-int Doc::GetDrawingHairpinSize(int staffSize, bool withMargin)
+int Doc::GetDrawingHairpinSize(int staffSize, bool withMargin) const
 {
     int size = m_style->m_hairpinSize * GetDrawingUnit(staffSize) / DEFINITON_FACTOR;
     // This should be styled
@@ -602,28 +602,28 @@ int Doc::GetDrawingHairpinSize(int staffSize, bool withMargin)
     return size;
 }
 
-int Doc::GetDrawingBeamWidth(int staffSize, bool graceSize)
+int Doc::GetDrawingBeamWidth(int staffSize, bool graceSize) const
 {
     int value = m_drawingBeamWidth * staffSize / 100;
     if (graceSize) value = value * this->m_style->m_graceNum / this->m_style->m_graceDen;
     return value;
 }
 
-int Doc::GetDrawingBeamWhiteWidth(int staffSize, bool graceSize)
+int Doc::GetDrawingBeamWhiteWidth(int staffSize, bool graceSize) const
 {
     int value = m_drawingBeamWhiteWidth * staffSize / 100;
     if (graceSize) value = value * this->m_style->m_graceNum / this->m_style->m_graceDen;
     return value;
 }
 
-int Doc::GetDrawingLedgerLineLength(int staffSize, bool graceSize)
+int Doc::GetDrawingLedgerLineLength(int staffSize, bool graceSize) const
 {
     int value = m_drawingLedgerLine * staffSize / 100;
     if (graceSize) value = value * this->m_style->m_graceNum / this->m_style->m_graceDen;
     return value;
 }
 
-int Doc::GetGraceSize(int value)
+int Doc::GetGraceSize(int value) const
 {
     return value * this->m_style->m_graceNum / this->m_style->m_graceDen;
 }
@@ -642,7 +642,7 @@ FontInfo *Doc::GetDrawingLyricFont(int staffSize)
     return &m_drawingLyricFont;
 }
 
-char Doc::GetLeftMargin(const ClassId classId)
+char Doc::GetLeftMargin(const ClassId classId) const
 {
 
     if (classId == ACCID) return m_style->m_leftMarginAccid;
@@ -663,7 +663,7 @@ char Doc::GetLeftMargin(const ClassId classId)
     return m_style->m_leftMarginDefault;
 }
 
-char Doc::GetRightMargin(const ClassId classId)
+char Doc::GetRightMargin(const ClassId classId) const
 {
     if (classId == ACCID) return m_style->m_rightMarginAccid;
     if (classId == BARLINE) return m_style->m_rightMarginBarLine;
@@ -683,7 +683,7 @@ char Doc::GetRightMargin(const ClassId classId)
     return m_style->m_rightMarginDefault;
 }
 
-char Doc::GetLeftPosition()
+char Doc::GetLeftPosition() const
 {
     return m_style->m_leftPosition;
 }
@@ -813,14 +813,14 @@ int Doc::CalcMusicFontSize()
     return m_style->m_unit * 8;
 }
 
-int Doc::GetAdjustedDrawingPageHeight()
+int Doc::GetAdjustedDrawingPageHeight() const
 {
     assert(m_drawingPage);
     int contentHeight = m_drawingPage->GetContentHeight();
     return (contentHeight + m_drawingPageTopMar * 2) / DEFINITON_FACTOR;
 }
 
-int Doc::GetAdjustedDrawingPageWidth()
+int Doc::GetAdjustedDrawingPageWidth() const
 {
     assert(m_drawingPage);
     int contentWidth = m_drawingPage->GetContentWidth();
diff --git a/src/durationinterface.cpp b/src/durationinterface.cpp
index 7af313ee940..656567d495f 100644
--- a/src/durationinterface.cpp
+++ b/src/durationinterface.cpp
@@ -139,7 +139,7 @@ bool DurationInterface::IsLastInBeam(LayerElement *noteOrRest)
     return false;
 }
 
-int DurationInterface::GetActualDur()
+int DurationInterface::GetActualDur() const
 {
     // maxima (-1) is a mensural only value
     if (this->GetDur() == DURATION_maxima) return DUR_MX;
diff --git a/src/dynam.cpp b/src/dynam.cpp
index 2b9d76ad224..2c1ae2c4237 100644
--- a/src/dynam.cpp
+++ b/src/dynam.cpp
@@ -66,7 +66,7 @@ bool Dynam::IsSymbolOnly()
     return false;
 }
 
-std::wstring Dynam::GetSymbolStr()
+std::wstring Dynam::GetSymbolStr() const
 {
     std::wstring dynam;
     if (m_symbolStr == L"p")
diff --git a/src/iopae.cpp b/src/iopae.cpp
index 40d2627b9ca..5906f313ba5 100644
--- a/src/iopae.cpp
+++ b/src/iopae.cpp
@@ -1099,7 +1099,7 @@ void PaeInput::convertMeasure(pae::Measure *measure)
 
     // Set barLine
     // FIXME use flags for proper barLine identification
-    BarLine *bline = m_measure->GetRightBarLine();
+    BarLine *const bline = m_measure->GetRightBarLine();
     bline->SetForm(measure->barLine);
 }
 
diff --git a/src/keysig.cpp b/src/keysig.cpp
index 0473696a321..b607d7863ff 100644
--- a/src/keysig.cpp
+++ b/src/keysig.cpp
@@ -71,7 +71,7 @@ KeySig::KeySig(int alterationNumber, data_ACCIDENTAL_EXPLICIT alterationType)
     m_alterationType = alterationType;
 }
 
-KeySig::KeySig(ScoreDefInterface *keySigAttr) : LayerElement("ksig-"), AttAccidental(), AttPitch()
+KeySig::KeySig(const ScoreDefInterface *keySigAttr) : LayerElement("ksig-"), AttAccidental(), AttPitch()
 {
     Init();
 
diff --git a/src/layerelement.cpp b/src/layerelement.cpp
index cd0a4182625..9408fa0d996 100644
--- a/src/layerelement.cpp
+++ b/src/layerelement.cpp
@@ -52,12 +52,12 @@ namespace vrv {
 // LayerElement
 //----------------------------------------------------------------------------
 
-LayerElement::LayerElement() :  Object("le-")
+LayerElement::LayerElement() : Object("le-")
 {
     Reset();
 }
 
-LayerElement::LayerElement(std::string classid) :  Object(classid)
+LayerElement::LayerElement(std::string classid) : Object(classid)
 {
     Reset();
 }
@@ -90,10 +90,10 @@ LayerElement &LayerElement::operator=(const LayerElement &element)
     return *this;
 }
 
-bool LayerElement::IsGraceNote()
+bool LayerElement::IsGraceNote() const
 {
     if (this->Is() != NOTE) return false;
-    Note *note = dynamic_cast<Note *>(this);
+    Note const *note = dynamic_cast<Note const *>(this);
     assert(note);
     return (note && note->HasGrace());
 }
@@ -166,7 +166,7 @@ int LayerElement::GetDrawingBottom(Doc *doc, int staffSize)
 bool LayerElement::IsCueSize()
 {
     if (this->Is() == NOTE) {
-        Note *note = dynamic_cast<Note *>(this);
+        const Note *note = dynamic_cast<const Note *>(this);
         assert(note);
         return (note->HasGrace());
     }
@@ -232,7 +232,7 @@ double LayerElement::GetAlignmentDuration(Mensur *mensur, MeterSig *meterSig, bo
     }
 }
 
-int LayerElement::GetXRel()
+int LayerElement::GetXRel() const
 {
     if (m_alignment) {
         return m_alignment->GetXRel();
diff --git a/src/measure.cpp b/src/measure.cpp
index dfd5ee2d300..9e396d3b1d5 100644
--- a/src/measure.cpp
+++ b/src/measure.cpp
@@ -99,7 +99,7 @@ void Measure::AddStaff(Staff *staff)
     }
 }
 
-int Measure::GetXRel()
+int Measure::GetXRel() const
 {
     if (m_measureAligner.GetLeftAlignment()) {
         return m_measureAligner.GetLeftAlignment()->GetXRel();
@@ -107,7 +107,7 @@ int Measure::GetXRel()
     return 0;
 }
 
-int Measure::GetLeftBarLineX()
+int Measure::GetLeftBarLineX() const
 {
     if (m_measureAligner.GetLeftAlignment()) {
         return m_measureAligner.GetLeftAlignment()->GetXRel();
@@ -115,7 +115,7 @@ int Measure::GetLeftBarLineX()
     return 0;
 }
 
-int Measure::GetRightBarLineX()
+int Measure::GetRightBarLineX() const
 {
     if (m_measureAligner.GetRightAlignment()) {
         return m_measureAligner.GetRightAlignment()->GetXRel();
@@ -123,7 +123,7 @@ int Measure::GetRightBarLineX()
     return 0;
 }
 
-int Measure::GetWidth()
+int Measure::GetWidth() const
 {
     if (m_measureAligner.GetRightAlignment()) {
         return GetRightBarLineX() + m_measureAligner.GetRightAlignment()->GetMaxWidth();
diff --git a/src/mensur.cpp b/src/mensur.cpp
index 4b2544529fd..3d7de5c9ed8 100644
--- a/src/mensur.cpp
+++ b/src/mensur.cpp
@@ -23,7 +23,7 @@ Mensur::Mensur()
     Init();
 }
 
-Mensur::Mensur(ScoreDefInterface *mensurAttr) : LayerElement("mensur-")
+Mensur::Mensur(const ScoreDefInterface *mensurAttr) : LayerElement("mensur-")
 {
     Init();
 
diff --git a/src/metersig.cpp b/src/metersig.cpp
index 72af8c40636..61ca8f8e24f 100644
--- a/src/metersig.cpp
+++ b/src/metersig.cpp
@@ -19,7 +19,7 @@ MeterSig::MeterSig() : LayerElement("msig-"), AttMeterSigLog()
     Init();
 }
 
-MeterSig::MeterSig(ScoreDefInterface *meterSigAttr) : LayerElement("msig-"), AttMeterSigLog()
+MeterSig::MeterSig(const ScoreDefInterface *meterSigAttr) : LayerElement("msig-"), AttMeterSigLog()
 {
     Init();
 
diff --git a/src/note.cpp b/src/note.cpp
index 7e9893b8018..34edd01df4c 100644
--- a/src/note.cpp
+++ b/src/note.cpp
@@ -161,7 +161,7 @@ int Note::GetDrawingDur()
     }
 }
 
-bool Note::IsClusterExtreme()
+bool Note::IsClusterExtreme() const
 {
     ChordCluster *cluster = this->m_cluster;
     if (this == cluster->at(0)) return true;
diff --git a/src/object.cpp b/src/object.cpp
index 9d0d118c324..72693b01f68 100644
--- a/src/object.cpp
+++ b/src/object.cpp
@@ -181,7 +181,7 @@ Object::Object(std::string classid) : BoundingBox()
     Init(classid);
 }
 
-Object *Object::Clone()
+Object *Object::Clone() const
 {
     // This should never happen because the method should be overridden
     assert(false);
@@ -245,7 +245,7 @@ void Object::Init(std::string classid)
     Reset();
 }
 
-ClassId Object::Is()
+ClassId Object::Is() const
 {
     // we should always have the method overridden
     assert(false);
@@ -298,12 +298,12 @@ void Object::ClearChildren()
     m_children.clear();
 }
 
-int Object::GetChildCount(const ClassId classId)
+int Object::GetChildCount(const ClassId classId) const
 {
     return (int)count_if(m_children.begin(), m_children.end(), ObjectComparison(classId));
 }
 
-int Object::GetAttributes(ArrayOfStrAttr *attributes)
+int Object::GetAttributes(ArrayOfStrAttr *attributes) const
 {
     assert(attributes);
     attributes->clear();
@@ -316,7 +316,7 @@ int Object::GetAttributes(ArrayOfStrAttr *attributes)
     return (int)attributes->size();
 }
 
-bool Object::HasAttribute(std::string attribute, std::string value)
+bool Object::HasAttribute(std::string attribute, std::string value) const
 {
     ArrayOfStrAttr attributes;
     this->GetAttributes(&attributes);
@@ -342,7 +342,7 @@ Object *Object::GetNext()
     return (m_iteratorCurrent == m_iteratorEnd) ? NULL : *m_iteratorCurrent;
 }
 
-Object *Object::GetLast()
+Object *Object::GetLast() const
 {
     if (m_children.empty()) return NULL;
     return m_children.back();
@@ -429,7 +429,7 @@ Object *Object::FindChildExtremeByAttComparison(AttComparison *attComparison, in
     return element;
 }
 
-Object *Object::GetChild(int idx)
+Object *Object::GetChild(int idx) const
 {
     if ((idx < 0) || (idx >= (int)m_children.size())) {
         return NULL;
@@ -697,7 +697,7 @@ Object *ObjectListInterface::GetListFirstBackward(Object *startFrom, const Class
     return (rit == m_list.rend()) ? NULL : *rit;
 }
 
-Object *ObjectListInterface::GetListPrevious(const Object *listElement)
+Object *ObjectListInterface::GetListPrevious(Object *listElement)
 {
     ListOfObjects::iterator iter;
     int i;
@@ -714,7 +714,7 @@ Object *ObjectListInterface::GetListPrevious(const Object *listElement)
     return NULL;
 }
 
-Object *ObjectListInterface::GetListNext(const Object *listElement)
+Object *ObjectListInterface::GetListNext(Object *listElement)
 {
     ListOfObjects::reverse_iterator iter;
     int i;
diff --git a/src/page.cpp b/src/page.cpp
index 54ffe763708..8df3e2cf816 100644
--- a/src/page.cpp
+++ b/src/page.cpp
@@ -58,7 +58,7 @@ void Page::AddSystem(System *system)
     Modify();
 }
 
-int Page::GetStaffPosOnPage(Staff *staff)
+int Page::GetStaffPosOnPage(Staff *staff) const
 {
     /*
     int position = -1;
@@ -318,7 +318,7 @@ void Page::JustifyHorizontally()
     this->Process(&justifyX, &params);
 }
 
-int Page::GetContentHeight()
+int Page::GetContentHeight() const
 {
     Doc *doc = dynamic_cast<Doc *>(m_parent);
     assert(doc);
@@ -332,7 +332,7 @@ int Page::GetContentHeight()
     return doc->m_drawingPageHeight - doc->m_drawingPageTopMar - last->m_drawingYRel + last->GetHeight();
 }
 
-int Page::GetContentWidth()
+int Page::GetContentWidth() const
 {
     Doc *doc = dynamic_cast<Doc *>(m_parent);
     assert(doc);
diff --git a/src/rpt.cpp b/src/rpt.cpp
index a0eda312c9a..1017a932805 100644
--- a/src/rpt.cpp
+++ b/src/rpt.cpp
@@ -40,7 +40,7 @@ void BeatRpt::Reset()
     ResetBeatRptVis();
 }
 
-double BeatRpt::GetBeatRptAlignmentDuration(int meterUnit)
+double BeatRpt::GetBeatRptAlignmentDuration(int meterUnit) const
 {
     return DUR_MAX / meterUnit;
 }
diff --git a/src/scoredef.cpp b/src/scoredef.cpp
index d853d8beb23..8028a6b1305 100644
--- a/src/scoredef.cpp
+++ b/src/scoredef.cpp
@@ -43,31 +43,31 @@ void ScoreDefElement::Reset()
     ScoreDefInterface::Reset();
 }
 
-bool ScoreDefElement::HasClefInfo()
+bool ScoreDefElement::HasClefInfo() const
 {
     if (this->HasClefAttrInfo()) return true;
     return (this->HasClefElementInfo());
 }
 
-bool ScoreDefElement::HasKeySigInfo()
+bool ScoreDefElement::HasKeySigInfo() const
 {
     if (this->HasKeySigAttrInfo()) return true;
     return (this->HasKeySigElementInfo());
 }
 
-bool ScoreDefElement::HasMensurInfo()
+bool ScoreDefElement::HasMensurInfo() const
 {
     if (this->HasMensurAttrInfo()) return true;
     return (this->HasMensurElementInfo());
 }
 
-bool ScoreDefElement::HasMeterSigInfo()
+bool ScoreDefElement::HasMeterSigInfo() const
 {
     if (this->HasMeterSigAttrInfo()) return true;
     return (this->HasMeterSigElementInfo());
 }
 
-bool ScoreDefElement::HasClefAttrInfo()
+bool ScoreDefElement::HasClefAttrInfo() const
 {
     // We need at least a @clef.shape and a @clef.line ?
     return (this->HasClefShape() && this->HasClefLine());
@@ -77,45 +77,45 @@ bool ScoreDefElement::HasClefAttrInfo()
     return false;
 }
 
-bool ScoreDefElement::HasKeySigAttrInfo()
+bool ScoreDefElement::HasKeySigAttrInfo() const
 {
     return (this->HasKeySig());
 }
 
-bool ScoreDefElement::HasMensurAttrInfo()
+bool ScoreDefElement::HasMensurAttrInfo() const
 {
     // What is the minimum we need? Checking only some for now. Need clarification
     return (this->HasProlatio() || this->HasTempus() || this->HasProportNum() || this->HasProportNumbase());
 }
 
-bool ScoreDefElement::HasMeterSigAttrInfo()
+bool ScoreDefElement::HasMeterSigAttrInfo() const
 {
     return (this->HasMeterCount() || this->HasMeterSym() || this->HasMeterUnit());
 }
 
-bool ScoreDefElement::HasClefElementInfo()
+bool ScoreDefElement::HasClefElementInfo() const
 {
     // Eventually we can look for a child clef element
     // We would probably need to take into account app and rdg?
     return false;
 }
 
-bool ScoreDefElement::HasKeySigElementInfo()
+bool ScoreDefElement::HasKeySigElementInfo() const
 {
     return false;
 }
 
-bool ScoreDefElement::HasMensurElementInfo()
+bool ScoreDefElement::HasMensurElementInfo() const
 {
     return false;
 }
 
-bool ScoreDefElement::HasMeterSigElementInfo()
+bool ScoreDefElement::HasMeterSigElementInfo() const
 {
     return false;
 }
 
-Clef *ScoreDefElement::GetClefCopy()
+Clef *ScoreDefElement::GetClefCopy() const
 {
     Clef *copy = NULL;
     if (this->HasClefAttrInfo()) {
@@ -130,7 +130,7 @@ Clef *ScoreDefElement::GetClefCopy()
     return copy;
 }
 
-KeySig *ScoreDefElement::GetKeySigCopy()
+KeySig *ScoreDefElement::GetKeySigCopy() const
 {
     KeySig *copy = NULL;
     if (this->HasKeySigAttrInfo()) {
@@ -145,7 +145,7 @@ KeySig *ScoreDefElement::GetKeySigCopy()
     return copy;
 }
 
-Mensur *ScoreDefElement::GetMensurCopy()
+Mensur *ScoreDefElement::GetMensurCopy() const
 {
     Mensur *copy = NULL;
     if (this->HasMensurAttrInfo()) {
@@ -160,7 +160,7 @@ Mensur *ScoreDefElement::GetMensurCopy()
     return copy;
 }
 
-MeterSig *ScoreDefElement::GetMeterSigCopy()
+MeterSig *ScoreDefElement::GetMeterSigCopy() const
 {
     MeterSig *copy = NULL;
     if (this->HasMeterSigAttrInfo()) {
diff --git a/src/staff.cpp b/src/staff.cpp
index 0e28f964e57..69783cb387d 100644
--- a/src/staff.cpp
+++ b/src/staff.cpp
@@ -97,7 +97,7 @@ bool Staff::GetPosOnPage(ArrayPtrVoid *params)
     return false;
 }
 
-int Staff::GetYRel()
+int Staff::GetYRel() const
 {
     if (m_staffAlignment) {
         return m_staffAlignment->GetYRel();
diff --git a/src/svgdevicecontext.cpp b/src/svgdevicecontext.cpp
index 0f9d5b38c13..a83e17959cd 100644
--- a/src/svgdevicecontext.cpp
+++ b/src/svgdevicecontext.cpp
@@ -140,7 +140,7 @@ void SvgDeviceContext::Commit(bool xml_declaration)
     m_committed = true;
 }
 
-void SvgDeviceContext::StartGraphic( Object *object, std::string gClass, std::string gId)
+void SvgDeviceContext::StartGraphic(Object *object, std::string gClass, std::string gId)
 {
     std::string baseClass = object->GetClassName();
     std::transform(baseClass.begin(), baseClass.begin() + 1, baseClass.begin(), ::tolower);
@@ -158,7 +158,7 @@ void SvgDeviceContext::StartGraphic( Object *object, std::string gClass, std::st
     // currentBrush.GetOpacity()).c_str();
 }
 
-void SvgDeviceContext::StartTextGraphic( Object *object, std::string gClass, std::string gId)
+void SvgDeviceContext::StartTextGraphic(Object *object, std::string gClass, std::string gId)
 {
     std::string baseClass = object->GetClassName();
     std::transform(baseClass.begin(), baseClass.begin() + 1, baseClass.begin(), ::tolower);
@@ -172,7 +172,7 @@ void SvgDeviceContext::StartTextGraphic( Object *object, std::string gClass, std
     m_currentNode.append_attribute("id") = gId.c_str();
 }
 
-void SvgDeviceContext::ResumeGraphic( Object *object, std::string gId)
+void SvgDeviceContext::ResumeGraphic(Object *object, std::string gId)
 {
     std::string xpath = "//g[@id=\"" + gId + "\"]";
     pugi::xpath_node selection = m_currentNode.select_single_node(xpath.c_str());
@@ -182,21 +182,21 @@ void SvgDeviceContext::ResumeGraphic( Object *object, std::string gId)
     m_svgNodeStack.push_back(m_currentNode);
 }
 
-void SvgDeviceContext::EndGraphic( Object *object, View *view)
+void SvgDeviceContext::EndGraphic(Object *object, View *view)
 {
     DrawSvgBoundingBox(object, view);
     m_svgNodeStack.pop_back();
     m_currentNode = m_svgNodeStack.back();
 }
 
-void SvgDeviceContext::EndResumedGraphic( Object *object, View *view)
+void SvgDeviceContext::EndResumedGraphic(Object *object, View *view)
 {
     DrawSvgBoundingBox(object, view);
     m_svgNodeStack.pop_back();
     m_currentNode = m_svgNodeStack.back();
 }
 
-void SvgDeviceContext::EndTextGraphic( Object *object, View *view)
+void SvgDeviceContext::EndTextGraphic(Object *object, View *view)
 {
     m_svgNodeStack.pop_back();
     m_currentNode = m_svgNodeStack.back();
@@ -471,7 +471,7 @@ void SvgDeviceContext::DrawRoundedRectangle(int x, int y, int width, int height,
     rectChild.append_attribute("height") = height;
     rectChild.append_attribute("rx") = radius;
     rectChild.append_attribute("style") = StringFormat("stroke-width: %d;", m_penStack.top().GetWidth()).c_str();
-    rectChild.append_attribute("fill-opacity") = "0.0"; // for empty rectangles with bounding boxes
+    // rectChild.append_attribute("fill-opacity") = "0.0"; // for empty rectangles with bounding boxes
 }
 
 void SvgDeviceContext::StartText(int x, int y, char alignement)
@@ -662,7 +662,7 @@ std::string SvgDeviceContext::GetStringSVG(bool xml_declaration)
     return m_outdata.str();
 }
 
-void SvgDeviceContext::DrawSvgBoundingBox( Object *object, View *view)
+void SvgDeviceContext::DrawSvgBoundingBox(Object *object, View *view)
 {
     bool drawBoundingBox = false;
     if (drawBoundingBox && view) {
diff --git a/src/system.cpp b/src/system.cpp
index 0d1a83477ec..fef664d7017 100644
--- a/src/system.cpp
+++ b/src/system.cpp
@@ -26,7 +26,7 @@ namespace vrv {
 // System
 //----------------------------------------------------------------------------
 
-System::System() :  Object("system-"), DrawingListInterface()
+System::System() : Object("system-"), DrawingListInterface()
 {
     // We set parent to it because we want to access the parent doc from the aligners
     m_systemAligner.SetParent(this);
@@ -70,12 +70,12 @@ void System::AddScoreDef(ScoreDef *scoreDef)
     Modify();
 }
 
-int System::GetVerticalSpacing()
+int System::GetVerticalSpacing() const
 {
     return 0; // arbitrary generic value
 }
 
-int System::GetHeight()
+int System::GetHeight() const
 {
     if (m_systemAligner.GetBottomAlignment()) {
         return -m_systemAligner.GetBottomAlignment()->GetYRel();
diff --git a/src/timestamp.cpp b/src/timestamp.cpp
index e68a5d8209a..b7bbe8b8662 100644
--- a/src/timestamp.cpp
+++ b/src/timestamp.cpp
@@ -35,7 +35,7 @@ void TimestampAttr::Reset()
     m_actualDurPos = 0.0;
 }
 
-double TimestampAttr::GetTimestampAttrAlignmentDuration(int meterUnit)
+double TimestampAttr::GetTimestampAttrAlignmentDuration(int meterUnit) const
 {
     return DUR_MAX / meterUnit * m_actualDurPos;
 }