horizontalaligner.h

// Name:        horizontalaligner.h
// Author:      Laurent Pugin
// Created:     2013
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_HORIZONTAL_ALIGNER_H__
#define __VRV_HORIZONTAL_ALIGNER_H__
 
#include "atts_shared.h"
#include "fraction.h"
#include "object.h"
#include "vrv.h"
 
namespace vrv {
 
class Accid;
class AlignmentReference;
class FloatingObject;
class GraceAligner;
class LedgerLine;
class MeasureAligner;
class Note;
class TimestampAttr;
 
enum AlignmentType {
    ALIGNMENT_MEASURE_START = 0,
    // Non-justifiable
    ALIGNMENT_SCOREDEF_CLEF,
    ALIGNMENT_SCOREDEF_KEYSIG,
    ALIGNMENT_SCOREDEF_MENSUR,
    ALIGNMENT_SCOREDEF_METERSIG,
    ALIGNMENT_MEASURE_LEFT_BARLINE,
    // Justifiable
    ALIGNMENT_FULLMEASURE,
    ALIGNMENT_FULLMEASURE2,
    ALIGNMENT_CLEF,
    ALIGNMENT_KEYSIG,
    ALIGNMENT_MENSUR,
    ALIGNMENT_METERSIG,
    ALIGNMENT_PROPORT,
    ALIGNMENT_DOT,
    ALIGNMENT_CUSTOS,
    ALIGNMENT_ACCID,
    ALIGNMENT_GRACENOTE,
    ALIGNMENT_BARLINE,
    ALIGNMENT_DIVLINE,
    ALIGNMENT_DEFAULT,
    // Non-justifiable
    ALIGNMENT_MEASURE_RIGHT_BARLINE,
    ALIGNMENT_SCOREDEF_CAUTION_CLEF,
    ALIGNMENT_SCOREDEF_CAUTION_KEYSIG,
    ALIGNMENT_SCOREDEF_CAUTION_MENSUR,
    ALIGNMENT_SCOREDEF_CAUTION_METERSIG,
    ALIGNMENT_MEASURE_END
};
 
#define BARLINE_REFERENCES -1
#define TSTAMP_REFERENCES -2
 
//----------------------------------------------------------------------------
// Alignment
//----------------------------------------------------------------------------
 
class Alignment : public Object {
public:
    Alignment();
    Alignment(const Fraction &time, AlignmentType type = ALIGNMENT_DEFAULT);
    virtual ~Alignment();
    void Reset() override;
 
    void ClearGraceAligners();
 
    bool IsSupportedChild(ClassId classId) override;
 
    void SetXRel(int xRel);
    int GetXRel() const { return m_xRel; }
 
    void SetTime(const Fraction &time) { m_time = time; }
    Fraction GetTime() const { return m_time; }
 
    bool operator==(const Alignment &other) const;
    std::weak_ordering operator<=>(const Alignment &other) const;
 
    bool AddLayerElementRef(LayerElement *element);
 
    void SetType(AlignmentType type) { m_type = type; }
    AlignmentType GetType() const { return m_type; }
 
    bool IsOfType(const std::vector<AlignmentType> &types) const;
 
    void GetLeftRight(
        const std::vector<int> &staffNs, int &minLeft, int &maxRight, const std::vector<ClassId> &excludes = {}) const;
    void GetLeftRight(int staffN, int &minLeft, int &maxRight, const std::vector<ClassId> &excludes = {}) const;
 
    const MapOfIntGraceAligners &GetGraceAligners() { return m_graceAligners; }
 
    GraceAligner *GetGraceAligner(int id);
 
    bool HasGraceAligner(int id) const;
 
    bool PerformBoundingBoxAlignment() const;
 
    AlignmentReference *GetReferenceWithElement(const LayerElement *element, int staffN = VRV_UNSET);
    const AlignmentReference *GetReferenceWithElement(const LayerElement *element, int staffN = VRV_UNSET) const;
 
    std::pair<int, int> GetAlignmentTopBottom() const;
 
    bool HasAccidVerticalOverlap(const Alignment *otherAlignment, int staffN) const;
 
    bool HasAlignmentReference(int staffN) const;
 
    bool HasTimestampOnly() const;
 
    std::string LogDebugTreeMsg() override
    {
        return StringFormat("%d %f", this->GetXRel(), this->GetTime().ToDouble());
    }
 
    //----------------//
    // Static methods //
    //----------------//
 
    static int HorizontalSpaceForDuration(
        const Fraction &intervalTime, data_DURATION maxActualDur, double spacingLinear, double spacingNonLinear);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    AlignmentReference *GetAlignmentReference(int staffN);
 
public:
    //
private:
    int m_xRel;
    Fraction m_time;
    AlignmentType m_type;
    MapOfIntGraceAligners m_graceAligners;
};
 
//----------------------------------------------------------------------------
// AlignmentReference
//----------------------------------------------------------------------------
 
class AlignmentReference : public Object, public AttNInteger {
public:
    AlignmentReference();
    AlignmentReference(int staffN);
    virtual ~AlignmentReference();
    void Reset() override;
 
    bool IsSupportedChild(ClassId classId) override;
 
    void AddChild(Object *object) override;
 
    bool HasAccidVerticalOverlap(const ArrayOfConstObjects &objects) const;
 
    bool HasMultipleLayer() const { return (m_layerCount > 1); }
 
    bool HasCrossStaffElements() const;
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    //
public:
    //
private:
    int m_layerCount;
};
 
//----------------------------------------------------------------------------
// HorizontalAligner
//----------------------------------------------------------------------------
 
class HorizontalAligner : public Object {
public:
    HorizontalAligner(ClassId classId);
    virtual ~HorizontalAligner();
    void Reset() override;
 
    bool CopyChildren() const override { return false; }
 
    int GetAlignmentCount() const { return this->GetChildCount(); }
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
protected:
    Alignment *SearchAlignmentAtTime(const Fraction &time, AlignmentType type, int &idx);
    const Alignment *SearchAlignmentAtTime(const Fraction &time, AlignmentType type, int &idx) const;
 
    void AddAlignment(Alignment *alignment, int idx = -1);
 
private:
    //
public:
    //
private:
};
 
//----------------------------------------------------------------------------
// MeasureAligner
//----------------------------------------------------------------------------
 
class MeasureAligner : public HorizontalAligner {
public:
    MeasureAligner();
    virtual ~MeasureAligner();
    void Reset() override;
 
    bool IsSupportedChild(ClassId classId) override;
 
    Alignment *GetAlignmentAtTime(const Fraction &time, AlignmentType type);
 
    void SetMaxTime(const Fraction &time);
 
    Fraction GetMaxTime() const;
 
    int GetNonJustifiableMargin() const { return m_nonJustifiableLeftMargin; }
 
    void SetInitialTstamp(data_DURATION meterUnit);
    Fraction GetInitialTstampDur() const { return m_initialTstampDur; }
 
    Alignment *GetLeftAlignment() { return m_leftAlignment; }
    const Alignment *GetLeftAlignment() const { return m_leftAlignment; }
    Alignment *GetLeftBarLineAlignment() { return m_leftBarLineAlignment; }
    const Alignment *GetLeftBarLineAlignment() const { return m_leftBarLineAlignment; }
 
    Alignment *GetRightAlignment() { return m_rightAlignment; }
    const Alignment *GetRightAlignment() const { return m_rightAlignment; }
    Alignment *GetRightBarLineAlignment() { return m_rightBarLineAlignment; }
    const Alignment *GetRightBarLineAlignment() const { return m_rightBarLineAlignment; }
 
    void AdjustProportionally(const ArrayOfAdjustmentTuples &adjustments);
 
    void PushAlignmentsRight();
 
    void AdjustGraceNoteSpacing(const Doc *doc, Alignment *alignment, int staffN);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    //
public:
    //
private:
    Alignment *m_leftAlignment;
    Alignment *m_rightAlignment;
 
    Alignment *m_leftBarLineAlignment;
    Alignment *m_rightBarLineAlignment;
 
    int m_nonJustifiableLeftMargin;
 
    Fraction m_initialTstampDur;
};
 
//----------------------------------------------------------------------------
// GraceAligner
//----------------------------------------------------------------------------
 
class GraceAligner : public HorizontalAligner {
public:
    GraceAligner();
    virtual ~GraceAligner();
    void Reset() override;
 
    Alignment *GetAlignmentAtTime(const Fraction &time, AlignmentType type);
 
    void StackGraceElement(LayerElement *object);
 
    void AlignStack();
 
    void SetWidth(int totalWidth) { m_totalWidth = totalWidth; }
    int GetWidth() const { return m_totalWidth; }
 
    int GetGraceGroupLeft(int staffN) const;
    int GetGraceGroupRight(int staffN) const;
 
    void SetGraceAlignmentXPos(const Doc *doc);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    //
public:
    //
private:
    ArrayOfObjects m_graceStack;
    int m_totalWidth;
};
 
//----------------------------------------------------------------------------
// TimestampAligner
//----------------------------------------------------------------------------
 
class TimestampAligner : public Object {
public:
    // constructors and destructors
    TimestampAligner();
    virtual ~TimestampAligner();
 
    void Reset() override;
 
    bool IsSupportedChild(ClassId classId) override;
 
    TimestampAttr *GetTimestampAtTime(double time);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    //
public:
    //
private:
    //
};
 
} // namespace vrv
 
#endif