convertfunctor.h

// Name:        convertfunctor.h
// Author:      David Bauer
// Created:     2023
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_CONVERTFUNCTOR_H__
#define __VRV_CONVERTFUNCTOR_H__
 
#include "functor.h"
 
//----------------------------------------------------------------------------
 
#include "alignfunctor.h"
 
namespace vrv {
 
//----------------------------------------------------------------------------
// ConvertToPageBasedFunctor
//----------------------------------------------------------------------------
 
class ConvertToPageBasedFunctor : public Functor {
public:
    ConvertToPageBasedFunctor(Page *page);
    virtual ~ConvertToPageBasedFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return true; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitDiv(Div *div) override;
    FunctorCode VisitEditorialElement(EditorialElement *editorialElement) override;
    FunctorCode VisitEditorialElementEnd(EditorialElement *editorialElement) override;
    FunctorCode VisitEnding(Ending *ending) override;
    FunctorCode VisitEndingEnd(Ending *ending) override;
    FunctorCode VisitMeasure(Measure *measure) override;
    FunctorCode VisitMdiv(Mdiv *mdiv) override;
    FunctorCode VisitMdivEnd(Mdiv *mdiv) override;
    FunctorCode VisitScore(Score *score) override;
    FunctorCode VisitScoreEnd(Score *score) override;
    FunctorCode VisitScoreDef(ScoreDef *scoreDef) override;
    FunctorCode VisitSection(Section *section) override;
    FunctorCode VisitSectionEnd(Section *section) override;
    FunctorCode VisitSystemElement(SystemElement *systemElement) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The system we are moving the content to
    System *m_currentSystem;
    // The page being processed
    Page *m_page;
};
 
//----------------------------------------------------------------------------
// ConvertToCastOffMensuralFunctor
//----------------------------------------------------------------------------
 
class ConvertToCastOffMensuralFunctor : public DocFunctor {
public:
    ConvertToCastOffMensuralFunctor(Doc *doc, System *targetSystem);
    virtual ~ConvertToCastOffMensuralFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitLayer(Layer *layer) override;
    FunctorCode VisitMeasure(Measure *measure) override;
    FunctorCode VisitObject(Object *object) override;
    FunctorCode VisitScoreDef(ScoreDef *scoreDef) override;
    FunctorCode VisitStaff(Staff *staff) override;
    FunctorCode VisitSystemElement(SystemElement *systemElement) override;
 
protected:
    //
private:
    bool IsValidBreakPoint(const Alignment *alignment, const int nbLayers);
    void InitSegment(Object *object);
 
public:
    //
private:
    std::list<Measure *> m_segments;
    std::list<Measure *>::iterator m_currentSegment;
    std::list<const Alignment *> m_breakPoints;
    std::list<const Alignment *>::const_iterator m_currentBreakPoint;
    // The content layer from which we are copying the elements
    Staff *m_contentStaff;
    Layer *m_contentLayer;
    // The target system, measure, staff & layer
    System *m_targetSystem;
    Staff *m_targetStaff;
    Layer *m_targetLayer;
};
 
//----------------------------------------------------------------------------
// ConvertToUnCastOffMensuralFunctor
//----------------------------------------------------------------------------
 
class ConvertToUnCastOffMensuralFunctor : public Functor {
public:
    ConvertToUnCastOffMensuralFunctor();
    virtual ~ConvertToUnCastOffMensuralFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Getter and setter for various properties
     */
    void ResetContent();
    void TrackSegmentsToDelete(bool trackSegments) { m_trackSegmentsToDelete = trackSegments; }
    const ArrayOfObjects &GetSegmentsToDelete() const { return m_segmentsToDelete; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitLayer(Layer *layer) override;
    FunctorCode VisitMeasure(Measure *measure) override;
    FunctorCode VisitSection(Section *section) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The content/target measure and layer => NULL at the beginning of a section
    Measure *m_contentMeasure;
    Layer *m_contentLayer;
    // Indicates if we keep a reference of the measure segments to delete at the end
    bool m_trackSegmentsToDelete;
    // Measure segments to delete at the end (fill in the first pass only)
    ArrayOfObjects m_segmentsToDelete;
};
 
//----------------------------------------------------------------------------
// ConvertToCmnFunctor
//----------------------------------------------------------------------------
 
class ConvertToCmnFunctor : public DocFunctor {
public:
    ConvertToCmnFunctor(Doc *doc, System *targetSystem, Score *score);
    virtual ~ConvertToCmnFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return true; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitChord(Chord *chord) override;
    FunctorCode VisitLayer(Layer *layer) override;
    FunctorCode VisitLayerElement(LayerElement *object) override;
    FunctorCode VisitLigature(Ligature *ligature) override;
    FunctorCode VisitLigatureEnd(Ligature *ligature) override;
    FunctorCode VisitMeasure(Measure *measure) override;
    FunctorCode VisitMeasureEnd(Measure *measure) override;
    FunctorCode VisitNote(Note *note) override;
    FunctorCode VisitRest(Rest *rest) override;
    FunctorCode VisitScoreDef(ScoreDef *scoreDef) override;
    FunctorCode VisitStaff(Staff *staff) override;
    FunctorCode VisitStaffEnd(Staff *staff) override;
    FunctorCode VisitSystemElement(SystemElement *systemElement) override;
    FunctorCode VisitSystemEnd(System *system) override;
 
protected:
    //
private:
    bool IsGlobalMensur(const Alignment *alignment, const int nbLayers, Mensur &mensur);
    Fraction CalcMeasureDuration(const Mensur &mensur);
    void ConvertDurationInterface(DurationInterface *interface, ClassId classId);
    void SplitDurationInterface(ClassId classId, data_DURATION elementDur, Fraction time, Fraction duration);
    void ConvertAccid(Note *cmnNote, const Accid *accid, bool &isFirstNote);
    void ConvertClef(Clef *cmnClef, const Clef *clef);
    void ConvertMensur(const Mensur *mensur);
 
    class MensurInfo {
    public:
        Mensur m_mensur;
        Fraction m_time;
    };
 
    class MeasureInfo {
    public:
        MeasureInfo(const Fraction &time, const Fraction &duration) : m_time(time), m_duration(duration)
        {
            m_measure = NULL;
        }
 
    public:
        Measure *m_measure;
        Fraction m_time;
        Fraction m_duration;
    };
 
    class CmnDuration {
    public:
        CmnDuration(data_DURATION duration, int dots, int num = 1, int numbase = 1)
            : m_duration(duration), m_dots(dots), m_num(num), m_numbase(numbase)
        {
        }
 
    public:
        data_DURATION m_duration;
        int m_dots;
        int m_num;
        int m_numbase;
    };
 
    void SplitDurationIntoCmn(
        data_DURATION elementDur, Fraction duration, const Mensur *mensur, std::list<CmnDuration> &cmnDurations);
 
public:
    //
private:
    Score *m_score;
    std::vector<MeasureInfo> m_measures;
    std::vector<MeasureInfo>::iterator m_currentMeasure;
    std::vector<Layer *> m_layers;
    std::vector<Layer *>::iterator m_currentLayer;
    std::list<Clef *> m_clefs;
    Clef *m_layerClef;
    System *m_targetSystem;
    AlignMeterParams m_currentParams;
    ListOfObjects m_durationElements;
    BracketSpan *m_ligature;
    BracketSpan *m_coloration;
    Tuplet *m_proportTuplet;
    Staff *m_currentStaff;
    std::string m_startid;
    int m_n;
};
 
//----------------------------------------------------------------------------
// ConvertMarkupAnalyticalFunctor
//----------------------------------------------------------------------------
 
class ConvertMarkupAnalyticalFunctor : public Functor {
public:
    ConvertMarkupAnalyticalFunctor(bool permanent);
    virtual ~ConvertMarkupAnalyticalFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return true; }
 
    /*
     * Get the notes with unresolved open ties
     */
    const std::vector<Note *> &GetCurrentNotes() const { return m_currentNotes; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitChord(Chord *chord) override;
    FunctorCode VisitChordEnd(Chord *chord) override;
    FunctorCode VisitMeasureEnd(Measure *measure) override;
    FunctorCode VisitMRest(MRest *mRest) override;
    FunctorCode VisitNote(Note *note) override;
    FunctorCode VisitRest(Rest *rest) override;
 
protected:
    //
private:
    // Helper for converting markup
    void ConvertToFermata(Fermata *fermata, AttFermataPresent *fermataPresent, const std::string &id);
 
public:
    //
private:
    // The current notes with open ties
    std::vector<Note *> m_currentNotes;
    // The current chord (if in a chord)
    Chord *m_currentChord;
    // Control events to be added to the measure (at its end)
    ArrayOfObjects m_controlEvents;
    // Indicates whether the conversion is permanent
    bool m_permanent;
};
 
//----------------------------------------------------------------------------
// ConvertMarkupArticFunctor
//----------------------------------------------------------------------------
 
class ConvertMarkupArticFunctor : public Functor {
public:
    ConvertMarkupArticFunctor();
    virtual ~ConvertMarkupArticFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return true; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitArtic(Artic *artic) override;
    FunctorCode VisitLayerEnd(Layer *layer) override;
 
protected:
    //
private:
    void SplitMultival(Artic *artic) const;
 
public:
    //
private:
    // The articulations that need to be converted
    std::vector<Artic *> m_articsToConvert;
};
 
//----------------------------------------------------------------------------
// ConvertMarkupScoreDefFunctor
//----------------------------------------------------------------------------
 
class ConvertMarkupScoreDefFunctor : public DocFunctor {
public:
    ConvertMarkupScoreDefFunctor(Doc *doc);
    virtual ~ConvertMarkupScoreDefFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return true; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitScore(Score *score) override;
    FunctorCode VisitScoreDefElement(ScoreDefElement *scoreDefElement) override;
    FunctorCode VisitScoreDefElementEnd(ScoreDefElement *scoreDefElement) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The scoreDef we are moving the content from
    ScoreDefElement *m_currentScoreDef;
};
 
//----------------------------------------------------------------------------
// ConvertToMensuralViewFunctor
//----------------------------------------------------------------------------
 
class ConvertToMensuralViewFunctor : public DocFunctor {
public:
    ConvertToMensuralViewFunctor(Doc *doc);
    virtual ~ConvertToMensuralViewFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return true; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitEditorialElement(EditorialElement *editorialElement) override;
    FunctorCode VisitLayer(Layer *layer) override;
    FunctorCode VisitLayerEnd(Layer *layer) override;
    FunctorCode VisitLayerElement(LayerElement *layerElement) override;
    FunctorCode VisitLayerElementEnd(LayerElement *layerElement) override;
    FunctorCode VisitLigature(Ligature *ligature) override;
    FunctorCode VisitLigatureEnd(Ligature *ligature) override;
 
protected:
    //
private:
    //
public:
    //
private:
    Layer *m_viewLayer;
    ListOfObjects m_stack;
};
 
} // namespace vrv
 
#endif // __VRV_CONVERTFUNCTOR_H__