layerelement.h

// Name:        layerelement.h
// Author:      Laurent Pugin
// Created:     2011
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_LAYER_ELEMENT_H__
#define __VRV_LAYER_ELEMENT_H__
 
#include <set>
 
//----------------------------------------------------------------------------
 
#include "atts_shared.h"
#include "facsimileinterface.h"
#include "fraction.h"
#include "linkinginterface.h"
#include "object.h"
 
namespace vrv {
 
class Beam;
class BeamElementCoord;
class FTrem;
class Layer;
class Liquescent;
class Mensur;
class MeterSig;
class Staff;
class StaffAlignment;
 
struct AlignMeterParams;
 
// Helper enums
enum StaffSearch { ANCESTOR_ONLY = 0, RESOLVE_CROSS_STAFF };
 
//----------------------------------------------------------------------------
// LayerElement
//----------------------------------------------------------------------------
 
class LayerElement : public Object,
                     public FacsimileInterface,
                     public LinkingInterface,
                     public AttCoordX1,
                     public AttLabelled,
                     public AttTyped {
public:
    LayerElement();
    LayerElement(ClassId classId);
    virtual ~LayerElement();
    void Reset() override;
 
    void CloneReset() override;
 
    FacsimileInterface *GetFacsimileInterface() override { return vrv_cast<FacsimileInterface *>(this); }
    const FacsimileInterface *GetFacsimileInterface() const override
    {
        return vrv_cast<const FacsimileInterface *>(this);
    }
    LinkingInterface *GetLinkingInterface() override { return vrv_cast<LinkingInterface *>(this); }
    const LinkingInterface *GetLinkingInterface() const override { return vrv_cast<const LinkingInterface *>(this); }
 
    virtual bool HasToBeAligned() const { return false; }
 
    virtual bool IsScoreDefElement() const { return false; }
 
    virtual bool IsRelativeToStaff() const { return false; }
 
    LayerElement *ThisOrSameasLink();
    const LayerElement *ThisOrSameasLink() const;
 
    ElementScoreDefRole GetScoreDefRole() const { return m_scoreDefRole; }
    void SetScoreDefRole(ElementScoreDefRole scoreDefRole) { m_scoreDefRole = scoreDefRole; }
 
 
    bool IsGraceNote() const;
    bool IsInLigature() const;
    FTrem *GetAncestorFTrem();
    const FTrem *GetAncestorFTrem() const;
    Beam *GetAncestorBeam();
    const Beam *GetAncestorBeam() const;
    bool IsInBeam() const;
 
    void SetDrawingCueSize(bool drawingCueSize) { m_drawingCueSize = drawingCueSize; }
    bool GetDrawingCueSize() const { return m_drawingCueSize; }
 
    void SetIsInBeamSpan(bool isInBeamSpan);
    bool GetIsInBeamSpan() const { return m_isInBeamspan; }
 
    int GetAlignmentLayerN() const { return m_alignmentLayerN; }
    void SetAlignmentLayerN(int alignmentLayerN) { m_alignmentLayerN = alignmentLayerN; }
 
    int GetOriginalLayerN() const;
 
    int GetDrawingX() const override;
    int GetDrawingY() const override;
 
    int GetDrawingXRel() const { return m_drawingXRel; }
    virtual void SetDrawingXRel(int drawingXRel);
    void CacheXRel(bool restore = false);
    int GetDrawingYRel() const { return m_drawingYRel; }
    virtual void SetDrawingYRel(int drawingYRel);
    void CacheYRel(bool restore = false);
 
    void CenterDrawingX();
 
    int GetDrawingTop(const Doc *doc, int staffSize, bool withArtic = true, ArticType articType = ARTIC_INSIDE) const;
    int GetDrawingBottom(
        const Doc *doc, int staffSize, bool withArtic = true, ArticType articType = ARTIC_INSIDE) const;
 
    int GetDrawingRadius(const Doc *doc, bool isInLigature = false) const;
 
    Alignment *GetAlignment() { return m_alignment; }
    const Alignment *GetAlignment() const { return m_alignment; }
    void ResetAlignment() { m_alignment = NULL; }
    void SetAlignment(Alignment *alignment) { m_alignment = alignment; }
 
    Staff *GetAncestorStaff(StaffSearch strategy = ANCESTOR_ONLY, bool assertExistence = true);
    const Staff *GetAncestorStaff(StaffSearch strategy = ANCESTOR_ONLY, bool assertExistence = true) const;
 
    Staff *GetCrossStaff(Layer *&layer);
    const Staff *GetCrossStaff(const Layer *&layer) const;
 
    data_STAFFREL_basic GetCrossStaffRel() const;
 
    void GetOverflowStaffAlignments(StaffAlignment *&above, StaffAlignment *&below);
 
    Alignment *GetGraceAlignment();
    const Alignment *GetGraceAlignment() const;
    void ResetGraceAlignment() { m_graceAlignment = NULL; }
    void SetGraceAlignment(Alignment *graceAlignment);
    bool HasGraceAlignment() const { return (m_graceAlignment != NULL); }
 
    Fraction GetAlignmentDuration(const AlignMeterParams &params, bool notGraceOnly = true,
        data_NOTATIONTYPE notationType = NOTATIONTYPE_cmn) const;
 
    Fraction GetAlignmentDuration(bool notGraceOnly = true, data_NOTATIONTYPE notationType = NOTATIONTYPE_cmn) const;
 
    Fraction GetSameAsContentAlignmentDuration(const AlignMeterParams &params, bool notGraceOnly = true,
        data_NOTATIONTYPE notationType = NOTATIONTYPE_cmn) const;
 
    Fraction GetContentAlignmentDuration(const AlignMeterParams &params, bool notGraceOnly = true,
        data_NOTATIONTYPE notationType = NOTATIONTYPE_cmn) const;
 
    Fraction GetContentAlignmentDuration(
        bool notGraceOnly = true, data_NOTATIONTYPE notationType = NOTATIONTYPE_cmn) const;
 
    bool GenerateZoneBounds(int *ulx, int *uly, int *lrx, int *lry) const;
 
    virtual int AdjustOverlappingLayers(const Doc *doc, const std::vector<LayerElement *> &otherElements,
        bool areDotsAdjusted, bool &isUnison, bool &stemSameAs);
 
    std::pair<int, bool> CalcElementHorizontalOverlap(const Doc *doc, const std::vector<LayerElement *> &otherElements,
        bool areDotsAdjusted, bool isChordElement, bool isLowerElement = false, bool unison = true);
 
    virtual data_STEMMODIFIER GetDrawingStemMod() const;
 
    virtual bool HasCrossStaff() const { return (m_crossStaff != NULL); }
 
    char32_t StemModToGlyph(data_STEMMODIFIER stemMod) const;
 
    MapOfDotLocs CalcOptimalDotLocations();
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
protected:
    std::vector<int> GetElementsInUnison(
        const std::set<int> &firstChord, const std::set<int> &secondChord, data_STEMDIRECTION stemDirection) const;
 
    virtual MapOfNoteLocs CalcNoteLocations(NotePredicate predicate = NULL) const { return {}; }
 
    virtual MapOfDotLocs CalcDotLocations(int layerCount, bool primary) const { return {}; }
 
    //----------------//
    // Static methods //
    //----------------//
 
    static int GetDotCount(const MapOfDotLocs &dotLocations);
 
    static int GetCollisionCount(const MapOfDotLocs &dotLocs1, const MapOfDotLocs &dotLocs2);
 
private:
    int GetDrawingArticulationTopOrBottom(data_STAFFREL place, ArticType type) const;
 
    void GetChordOverflow(StaffAlignment *&above, StaffAlignment *&below, int staffN);
 
public:
    int m_drawingFacsX;
    int m_drawingFacsY; // This is used only for accid, syl
    Staff *m_crossStaff;
    Layer *m_crossLayer;
 
protected:
    Alignment *m_alignment;
 
    Alignment *m_graceAlignment;
 
    int m_drawingYRel;
 
    int m_cachedYRel;
 
    int m_drawingXRel;
 
    int m_cachedXRel;
 
    bool m_drawingCueSize;
 
private:
    ElementScoreDefRole m_scoreDefRole;
 
    int m_alignmentLayerN;
 
    // flag to indicate that layerElement belongs to the beamSpan
    bool m_isInBeamspan;
};
 
} // namespace vrv
 
#endif