miscfunctor.h

// Name:        miscfunctor.h
// Author:      David Bauer
// Created:     2023
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_MISCFUNCTOR_H__
#define __VRV_MISCFUNCTOR_H__
 
#include "functor.h"
 
namespace vrv {
 
class LyricElement;
 
//----------------------------------------------------------------------------
// ApplyPPUFactorFunctor
//----------------------------------------------------------------------------
 
class ApplyPPUFactorFunctor : public Functor {
public:
    ApplyPPUFactorFunctor(Page *page = NULL);
    virtual ~ApplyPPUFactorFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitLayerElement(LayerElement *layerElement) override;
    FunctorCode VisitMeasure(Measure *measure) override;
    FunctorCode VisitPage(Page *page) override;
    FunctorCode VisitStaff(Staff *staff) override;
    FunctorCode VisitSurface(Surface *surface) override;
    FunctorCode VisitSystem(System *system) override;
    FunctorCode VisitZone(Zone *zone) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The current page
    Page *m_page;
};
 
//----------------------------------------------------------------------------
// GetAlignmentLeftRightFunctor
//----------------------------------------------------------------------------
 
class GetAlignmentLeftRightFunctor : public ConstFunctor {
public:
    GetAlignmentLeftRightFunctor();
    virtual ~GetAlignmentLeftRightFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Set the classes to exclude
     */
    void ExcludeClasses(const std::vector<ClassId> &excludeClasses) { m_excludeClasses = excludeClasses; }
 
    /*
     * Get the minimum left and maximum right
     */
    int GetMinLeft() const { return m_minLeft; }
    int GetMaxRight() const { return m_maxRight; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The min left and right
    int m_minLeft;
    int m_maxRight;
    // The classes which are ignored
    std::vector<ClassId> m_excludeClasses;
};
 
//----------------------------------------------------------------------------
// InitProcessingListsFunctor
//----------------------------------------------------------------------------
 
class InitProcessingListsFunctor : public ConstFunctor {
public:
    InitProcessingListsFunctor();
    virtual ~InitProcessingListsFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Getter for the int trees
     */
    const IntTree &GetLayerTree()
    {
        this->PrepareLyricElementTracks();
        return m_layerTree;
    }
    const IntTree &GetVerseTree();
 
    /*
     * Getter for the placements (staff @n, lyric-element group, placement) of the lyric elements
     */
    const std::set<std::tuple<int, int, data_STAFFREL>> &GetLyricGroupPlaces()
    {
        this->PrepareLyricElementTracks();
        return m_lyricGroupPlaces;
    }
 
    /*
     * Functor interface
     */
    FunctorCode VisitLayer(const Layer *layer) override;
    FunctorCode VisitRefrain(const Refrain *refrain) override;
    FunctorCode VisitVerse(const Verse *verse) override;
 
protected:
    //
private:
    //
public:
    //
private:
    void PrepareLyricElementTracks();
    void CollectLyricElement(const LyricElement *lyricElement);
 
    // The IntTree for staff/layer
    IntTree m_layerTree;
    // The IntTree for staff/layer/verse/volta-track. Track 0 is direct verse content.
    IntTree m_verseTree;
    // Lyric elements collected before stable drawing and processing slots are assigned.
    std::vector<const LyricElement *> m_lyricElements;
    bool m_lyricElementTracksPrepared = false;
    // Stable volta track numbers, allocated in document order for each staff/layer/lyric group.
    std::map<std::tuple<int, int, int, std::string>, int> m_voltaTracks;
    std::map<std::tuple<int, int, int>, int> m_nextVoltaTrack;
    // Lyric elements grouped together so a direct-syllable track is reflected at every note.
    std::map<std::tuple<int, int, int>, std::vector<const LyricElement *>> m_lyricElementGroups;
    std::set<std::tuple<int, int, int>> m_directSylTrackGroups;
    // The placements of the lyric elements by staff and lyric-element group
    std::set<std::tuple<int, int, data_STAFFREL>> m_lyricGroupPlaces;
};
 
//----------------------------------------------------------------------------
// ReorderByXPosFunctor
//----------------------------------------------------------------------------
 
class ReorderByXPosFunctor : public Functor {
public:
    ReorderByXPosFunctor();
    virtual ~ReorderByXPosFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    //
};
 
} // namespace vrv
 
#endif // __VRV_MISCFUNCTOR_H__