verticalaligner.h

// Name:        verticalaligner.h
// Author:      Laurent Pugin
// Created:     2013
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_VERTICAL_ALIGNER_H__
#define __VRV_VERTICAL_ALIGNER_H__
 
#include "object.h"
 
namespace vrv {
 
class AttSpacing;
class FloatingObject;
class ScoreDef;
class StaffAlignment;
class StaffDef;
class System;
class SystemAligner;
 
//----------------------------------------------------------------------------
// SystemAligner
//----------------------------------------------------------------------------
 
class SystemAligner : public Object {
public:
    enum class SpacingType { System, Staff, Brace, Bracket, None };
 
    // constructors and destructors
    SystemAligner();
    virtual ~SystemAligner();
 
    bool IsSupportedChild(ClassId classId) override;
 
    bool CopyChildren() const override { return false; }
 
    void Reset() override;
 
    StaffAlignment *GetBottomAlignment() { return m_bottomAlignment; }
    const StaffAlignment *GetBottomAlignment() const { return m_bottomAlignment; }
 
    StaffAlignment *GetStaffAlignment(int idx, Staff *staff, const Doc *doc);
 
    void ReorderBy(const std::vector<int> &staffNs);
 
    StaffAlignment *GetStaffAlignmentForStaffN(int staffN);
    const StaffAlignment *GetStaffAlignmentForStaffN(int staffN) const;
 
    System *GetSystem();
 
    void FindAllPositionerPointingTo(ArrayOfFloatingPositioners *positioners, const FloatingObject *object);
 
    void FindAllIntersectionPoints(
        SegmentedLine &line, const BoundingBox &boundingBox, const std::vector<ClassId> &classIds, int margin) const;
    int GetOverflowAbove(const Doc *doc, bool scoreDefClef = false) const;
    int GetOverflowBelow(const Doc *doc, bool scoreDefClef = false) const;
 
    double GetJustificationSum(const Doc *doc) const;
 
    void SetSpacing(const ScoreDef *scoreDef);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    SpacingType GetAboveSpacingType(const Staff *staff);
    SpacingType CalculateSpacingAbove(const StaffDef *staffDef) const;
 
public:
    //
private:
    StaffAlignment *m_bottomAlignment;
    std::map<int, SpacingType> m_spacingTypes;
    System *m_system;
};
 
//----------------------------------------------------------------------------
// StaffAlignment
//----------------------------------------------------------------------------
 
class StaffAlignment : public Object {
public:
    StaffAlignment();
    virtual ~StaffAlignment();
 
    void SetYRel(int yRel);
    int GetYRel() const { return m_yRel; }
 
    void AddVerseN(int verseN, data_STAFFREL place);
    int GetVerseCount(bool collapse) const;
    int GetVerseCountAbove(bool collapse) const;
    int GetVerseCountBelow(bool collapse) const;
    int GetVersePositionAbove(int verseN, bool collapse) const;
    int GetVersePositionBelow(int verseN, bool collapse) const;
 
    void SetCurrentFloatingPositioner(FloatingObject *object, Object *objectX, Object *objectY, char spanningType);
 
    const ArrayOfFloatingPositioners &GetFloatingPositioners() { return m_floatingPositioners; }
 
    FloatingPositioner *FindFirstFloatingPositioner(ClassId classId);
    const FloatingPositioner *FindFirstFloatingPositioner(ClassId classId) const;
 
    ArrayOfFloatingPositioners FindAllFloatingPositioners(ClassId classId);
 
    FloatingPositioner *GetCorrespFloatingPositioner(const FloatingObject *object);
    const FloatingPositioner *GetCorrespFloatingPositioner(const FloatingObject *object) const;
 
    Staff *GetStaff() { return m_staff; }
    const Staff *GetStaff() const { return m_staff; }
    void SetStaff(Staff *staff, const Doc *doc, SystemAligner::SpacingType spacingType);
 
    System *GetParentSystem() { return m_system; }
    const System *GetParentSystem() const { return m_system; }
    void SetParentSystem(System *system);
 
    int GetStaffSize() const;
 
    const AttSpacing *GetAttSpacing() const;
 
    int CalcOverflowAbove(const BoundingBox *box) const;
    int CalcOverflowBelow(const BoundingBox *box) const;
 
    int GetMinimumSpacing(const Doc *doc) const;
    int CalcMinimumRequiredSpacing(const Doc *doc) const;
    SystemAligner::SpacingType GetSpacingType() const { return m_spacingType; }
 
    void SetOverflowAbove(int overflowAbove);
    int GetOverflowAbove() const { return m_overflowAbove; }
    void SetOverflowBelow(int overflowBottom);
    int GetOverflowBelow() const { return m_overflowBelow; }
    void SetOverlap(int overlap);
    int GetOverlap() const { return m_overlap; }
    void SetRequestedSpaceAbove(int space);
    int GetRequestedSpaceAbove() const { return m_requestedSpaceAbove; }
    void SetRequestedSpaceBelow(int space);
    int GetRequestedSpaceBelow() const { return m_requestedSpaceBelow; }
    void SetRequestedSpacing(int spacing) { m_requestedSpacing = spacing; }
    int GetRequestedSpacing() const { return m_requestedSpacing; }
    int GetStaffHeight() const { return m_staffHeight; }
    void SetScoreDefClefOverflowAbove(int overflowAbove) { m_scoreDefClefOverflowAbove = overflowAbove; }
    int GetScoreDefClefOverflowAbove() const { return m_scoreDefClefOverflowAbove; }
    void SetScoreDefClefOverflowBelow(int overflowBelow) { m_scoreDefClefOverflowBelow = overflowBelow; }
    int GetScoreDefClefOverflowBelow() const { return m_scoreDefClefOverflowBelow; }
 
    double GetJustificationFactor(const Doc *doc) const;
 
    void AddBBoxAbove(BoundingBox *box) { m_overflowAboveBBoxes.push_back(box); }
    void AddBBoxBelow(BoundingBox *box) { m_overflowBelowBBoxes.push_back(box); }
    void ClearBBoxesAbove() { m_overflowAboveBBoxes.clear(); }
    void ClearBBoxesBelow() { m_overflowBelowBBoxes.clear(); }
    ArrayOfBoundingBoxes &GetBBoxesAboveForModification() { return m_overflowAboveBBoxes; }
    ArrayOfBoundingBoxes &GetBBoxesBelowForModification() { return m_overflowBelowBBoxes; }
    const ArrayOfBoundingBoxes &GetBBoxesAbove() { return m_overflowAboveBBoxes; }
    const ArrayOfBoundingBoxes &GetBBoxesBelow() { return m_overflowBelowBBoxes; }
 
    void ClearPositioners();
 
    void SortPositioners();
 
    void FindAllIntersectionPoints(
        SegmentedLine &line, const BoundingBox &boundingBox, const std::vector<ClassId> &classIds, int margin) const;
 
    void AdjustBracketGroupSpacing(const Doc *doc, const StaffAlignment *previous, int spacing);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    int GetMinimumStaffSpacing(const Doc *doc, const AttSpacing *attSpacing) const;
 
    bool IsInBracketGroup(bool isFirst) const;
 
public:
    //
private:
    SystemAligner::SpacingType m_spacingType = SystemAligner::SpacingType::None;
 
    ArrayOfFloatingPositioners m_floatingPositioners;
    bool m_floatingPositionersSorted;
    Staff *m_staff;
    System *m_system;
    int m_yRel;
    std::set<int> m_verseAboveNs;
    std::set<int> m_verseBelowNs;
 
    int m_overflowAbove;
    int m_overflowBelow;
    int m_overlap;
    int m_requestedSpaceAbove;
    int m_requestedSpaceBelow;
    int m_requestedSpacing;
    int m_staffHeight;
    int m_scoreDefClefOverflowAbove;
    int m_scoreDefClefOverflowBelow;
 
    ArrayOfBoundingBoxes m_overflowAboveBBoxes;
    ArrayOfBoundingBoxes m_overflowBelowBBoxes;
};
 
} // namespace vrv
 
#endif