measure.h

// Name:        measure.h
// Author:      Laurent Pugin
// Created:     2012
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_MEASURE_H__
#define __VRV_MEASURE_H__
 
#include "atts_cmn.h"
#include "atts_shared.h"
#include "barline.h"
#include "facsimileinterface.h"
#include "horizontalaligner.h"
#include "object.h"
 
namespace vrv {
 
class ControlElement;
class Ending;
class LayerElement;
class ScoreDef;
class System;
class TimestampAttr;
 
//----------------------------------------------------------------------------
// Measure
//----------------------------------------------------------------------------
 
class Measure : public Object,
                public FacsimileInterface,
                public AttBarring,
                public AttCoordX1,
                public AttCoordX2,
                public AttMeasureLog,
                public AttMeterConformanceBar,
                public AttNNumberLike,
                public AttPointing,
                public AttTyped {
private:
    using BarlineRenditionPair = std::pair<data_BARRENDITION, data_BARRENDITION>;
 
public:
    Measure(MeasureType measuredMusic = MEASURED, int logMeasureNb = -1);
    virtual ~Measure();
    Object *Clone() const override { return new Measure(*this); };
    void Reset() override;
    std::string GetClassName() const override { return "measure"; }
 
    void CloneReset() override;
 
    FacsimileInterface *GetFacsimileInterface() override { return vrv_cast<FacsimileInterface *>(this); }
    const FacsimileInterface *GetFacsimileInterface() const override
    {
        return vrv_cast<const FacsimileInterface *>(this);
    }
 
    bool IsMeasuredMusic() const { return (m_measureType == MEASURED); }
 
    bool IsNeumeLine() const { return (m_measureType == NEUMELINE); }
 
    int GetIndex() const { return m_index; }
    void SetIndex(int index) { m_index = index; }
 
    bool IsSupportedChild(ClassId classId) override;
 
    bool AddChildAdditionalCheck(Object *child) override;
 
    void AddChildBack(Object *object);
 
    bool HasCachedHorizontalLayout() const { return (m_cachedWidth != VRV_UNSET); }
 
    int GetDrawingX() const override;
 
    void ResetCachedDrawingX() const override;
 
    int GetDrawingXRel() const { return m_drawingXRel; }
    void SetDrawingXRel(int drawingXRel);
    void CacheXRel(bool restore = false);
    int GetCachedXRel() const { return m_cachedXRel; }
    void ResetCachedXRel() { m_cachedXRel = VRV_UNSET; }
 
    bool IsFirstInSystem() const;
    bool IsLastInSystem() const;
 
    int GetMeasureIdx() const { return Object::GetIdx(); }
 
    data_BARRENDITION GetDrawingLeftBarLine() const { return m_leftBarLine.GetForm(); }
    void SetDrawingLeftBarLine(data_BARRENDITION type) { m_leftBarLine.SetForm(type); }
    data_BARRENDITION GetDrawingRightBarLine() const { return m_rightBarLine.GetForm(); }
    void SetDrawingRightBarLine(data_BARRENDITION type) { m_rightBarLine.SetForm(type); }
    data_BARRENDITION GetDrawingLeftBarLineByStaffN(int staffN) const;
    data_BARRENDITION GetDrawingRightBarLineByStaffN(int staffN) const;
 
    bool HasInvisibleStaffBarlines() const { return !m_invisibleStaffBarlines.empty(); }
 
    BarlineRenditionPair SelectDrawingBarLines(const Measure *previous) const;
 
    void SetDrawingBarLines(Measure *previous, int barlineDrawingFlags);
 
    void SetInvisibleStaffBarlines(
        Measure *previous, ListOfObjects &currentInvisible, ListOfObjects &previousInvisible, int barlineDrawingFlags);
 
    BarLine *GetLeftBarLine() { return &m_leftBarLine; }
    const BarLine *GetLeftBarLine() const { return &m_leftBarLine; }
    BarLine *GetRightBarLine() { return &m_rightBarLine; }
    const BarLine *GetRightBarLine() const { return &m_rightBarLine; }
 
    int GetNonJustifiableLeftMargin() const { return m_measureAligner.GetNonJustifiableMargin(); }
 
    int GetLeftBarLineXRel() const;
    int GetLeftBarLineLeft() const;
    int GetLeftBarLineRight() const;
    int GetRightBarLineXRel() const;
    int GetRightBarLineLeft() const;
    int GetRightBarLineRight() const;
 
    int CalculateRightBarLineWidth(const Doc *doc, int staffSize) const;
 
    int GetWidth() const;
 
    int GetInnerWidth() const;
 
    int GetInnerCenterX() const;
 
    int GetCachedWidth() const { return m_cachedWidth; }
    int GetCachedOverflow() const { return m_cachedOverflow; }
    void ResetCachedWidth() { m_cachedWidth = VRV_UNSET; }
    void ResetCachedOverflow() { m_cachedOverflow = VRV_UNSET; }
 
    int GetDrawingOverflow();
 
    int GetSectionRestartShift(const Doc *doc) const;
 
    ScoreDef *GetDrawingScoreDef() { return m_drawingScoreDef; }
    const ScoreDef *GetDrawingScoreDef() const { return m_drawingScoreDef; }
    void SetDrawingScoreDef(ScoreDef *drawingScoreDef);
    void ResetDrawingScoreDef();
 
    Ending *GetDrawingEnding() { return m_drawingEnding; }
    const Ending *GetDrawingEnding() const { return m_drawingEnding; }
    void SetDrawingEnding(Ending *ending) { m_drawingEnding = ending; }
 
    bool HasAlignmentRefWithMultipleLayers() const { return m_hasAlignmentRefWithMultipleLayers; }
    void HasAlignmentRefWithMultipleLayers(bool hasRef) { m_hasAlignmentRefWithMultipleLayers = hasRef; }
 
    /*
     * Return the first staff of each staffGrp according to the scoreDef
     */
    std::vector<Staff *> GetFirstStaffGrpStaves(ScoreDef *scoreDef);
 
    Staff *GetTopVisibleStaff();
    const Staff *GetTopVisibleStaff() const;
 
    Staff *GetBottomVisibleStaff();
    const Staff *GetBottomVisibleStaff() const;
 
    int EnclosesTime(int time) const;
 
    Fraction GetLastTimeOffset() const { return m_scoreTimeOffset.back(); }
 
    double GetLastRealTimeOffset() const { return m_realTimeOffsetMilliseconds.back(); }
    double GetRealTimeOffsetMilliseconds(int repeat) const;
 
    void ClearScoreTimeOffset() { m_scoreTimeOffset.clear(); }
    void AddScoreTimeOffset(Fraction offset) { m_scoreTimeOffset.push_back(offset); }
    void ClearRealTimeOffset() { m_realTimeOffsetMilliseconds.clear(); }
    void AddRealTimeOffset(double milliseconds) { m_realTimeOffsetMilliseconds.push_back(milliseconds); }
 
    void SetCurrentTempo(double tempo) { m_currentTempo = tempo; }
    double GetCurrentTempo() const { return m_currentTempo; }
 
    std::vector<std::pair<LayerElement *, LayerElement *>> GetInternalTieEndpoints();
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
public:
    // flags for drawing measure barline based on visibility or other conditions
    enum BarlineDrawingFlags {
        SYSTEM_BREAK = 0x1,
        SCORE_DEF_INSERT = 0x2,
        INVISIBLE_MEASURE_CURRENT = 0x4,
        INVISIBLE_MEASURE_PREVIOUS = 0x8
    };
    int m_drawingFacsX1;
    int m_drawingFacsX2;
 
    mutable MeasureAligner m_measureAligner;
 
    TimestampAligner m_timestampAligner;
 
protected:
    int m_drawingXRel;
 
    int m_cachedXRel;
 
    int m_cachedOverflow;
    int m_cachedWidth;
 
private:
    MeasureType m_measureType;
 
    int m_index;
 
    BarLine m_leftBarLine;
    BarLine m_rightBarLine;
 
    ScoreDef *m_drawingScoreDef;
 
    Ending *m_drawingEnding;
 
    bool m_hasAlignmentRefWithMultipleLayers;
 
    std::vector<Fraction> m_scoreTimeOffset;
    std::vector<double> m_realTimeOffsetMilliseconds;
    double m_currentTempo;
 
    std::map<int, BarlineRenditionPair> m_invisibleStaffBarlines;
};
 
} // namespace vrv
 
#endif