staff.h

// Name:        staff.h
// Author:      Laurent Pugin
// Created:     2011
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_STAFF_H__
#define __VRV_STAFF_H__
 
#include "atts_shared.h"
#include "drawinginterface.h"
#include "facsimileinterface.h"
#include "object.h"
 
namespace vrv {
 
class DeviceContext;
class Layer;
class LedgerLine;
class Measure;
class StaffAlignment;
class StaffDef;
class Syl;
class TimeSpanningInterface;
class Tuning;
 
//----------------------------------------------------------------------------
// LedgerLine
//----------------------------------------------------------------------------
 
class LedgerLine {
public:
    LedgerLine() = default;
 
    void AddDash(int left, int right, int extension, const Object *event);
 
    class Dash {
    public:
        int m_x1;
        int m_x2;
        ListOfConstObjects m_events;
 
        // Constructor
        Dash(int x1, int x2, const Object *object)
        {
            m_x1 = x1;
            m_x2 = x2;
            m_events.push_back(object);
        }
 
        // Merge function to merge another Dash object into this one
        void MergeWith(const Dash &other)
        {
            // Keep the first int from this Dash object, and the second int from the other
            this->m_x1 = std::min(other.m_x1, this->m_x1);
            this->m_x2 = std::max(other.m_x2, this->m_x2);
            // Append the list from other to this
            if (!other.m_events.empty()) {
                this->m_events.insert(this->m_events.end(), other.m_events.begin(), other.m_events.end());
            }
        }
    };
 
protected:
    //
private:
    //
public:
    // std::list<std::pair<int, int>> m_dashes;
    std::list<Dash> m_dashes;
 
protected:
    //
private:
    //
};
 
//----------------------------------------------------------------------------
// Staff
//----------------------------------------------------------------------------
 
class Staff : public Object,
              public VisibilityDrawingInterface,
              public FacsimileInterface,
              public AttCoordY1,
              public AttNInteger,
              public AttTyped,
              public AttVisibility {
 
public:
    Staff(int n = 1, bool isOssia = false);
    virtual ~Staff();
    Object *Clone() const override { return new Staff(*this); }
    void Reset() override;
    std::string GetClassName() const override { return (this->IsOssia() ? "oStaff" : "staff"); }
 
    void CloneReset() override;
 
    FacsimileInterface *GetFacsimileInterface() override { return vrv_cast<FacsimileInterface *>(this); }
    const FacsimileInterface *GetFacsimileInterface() const override
    {
        return vrv_cast<const FacsimileInterface *>(this);
    }
    VisibilityDrawingInterface *GetVisibilityDrawingInterface() override
    {
        return vrv_cast<VisibilityDrawingInterface *>(this);
    }
    const VisibilityDrawingInterface *GetVisibilityDrawingInterface() const override
    {
        return vrv_cast<const VisibilityDrawingInterface *>(this);
    }
 
    bool IsOssia() const { return (m_isOssia); }
    void SetOssia(bool isOssia) { m_isOssia = isOssia; }
    int GetNForOssia() const;
    int GetNFromOssia() const;
 
    void AttributesToExternal() override;
    void AttributesToInternal() override;
 
    void SetDrawingRotation(double drawingRotation) { m_drawingRotation = drawingRotation; }
    double GetDrawingRotation() const { return m_drawingRotation; }
    bool HasDrawingRotation() const { return (m_drawingRotation != 0.0); }
    int GetDrawingRotationOffsetFor(int x);
 
    void ClearLedgerLines();
 
    bool IsSupportedChild(ClassId classId) override;
 
    bool AddChildAdditionalCheck(Object *child) override;
 
    int GetDrawingX() const override;
    int GetDrawingY() const override;
    virtual double GetDrawingRotate() const;
 
    void AdjustDrawingStaffSize();
 
    int GetDrawingStaffNotationSize() const;
 
    bool DrawingIsVisible() const;
 
    bool IsMensural() const;
    bool IsNeume() const;
    bool IsTablature() const;
    bool IsTabGuitar() const { return m_drawingNotationType == NOTATIONTYPE_tab_guitar; }
    bool IsTabLuteFrench() const { return m_drawingNotationType == NOTATIONTYPE_tab_lute_french; }
    bool IsTabLuteGerman() const { return m_drawingNotationType == NOTATIONTYPE_tab_lute_german; }
    bool IsTabLuteItalian() const { return m_drawingNotationType == NOTATIONTYPE_tab_lute_italian; }
    bool IsTabWithStemsOutside() const;
 
    int GetStaffIdx() const { return Object::GetIdx(); }
 
    int CalcPitchPosYRel(const Doc *doc, int loc) const;
 
    StaffAlignment *GetAlignment() { return m_staffAlignment; }
    const StaffAlignment *GetAlignment() const { return m_staffAlignment; }
    void SetAlignment(StaffAlignment *alignment) { m_staffAlignment = alignment; }
 
    ArrayOfLedgerLines &GetLedgerLinesAbove() { return m_ledgerLinesAbove; }
    const ArrayOfLedgerLines &GetLedgerLinesAbove() const { return m_ledgerLinesAbove; }
    ArrayOfLedgerLines &GetLedgerLinesAboveCue() { return m_ledgerLinesAboveCue; }
    const ArrayOfLedgerLines &GetLedgerLinesAboveCue() const { return m_ledgerLinesAboveCue; }
    ArrayOfLedgerLines &GetLedgerLinesBelow() { return m_ledgerLinesBelow; }
    const ArrayOfLedgerLines &GetLedgerLinesBelow() const { return m_ledgerLinesBelow; }
    ArrayOfLedgerLines &GetLedgerLinesBelowCue() { return m_ledgerLinesBelowCue; }
    const ArrayOfLedgerLines &GetLedgerLinesBelowCue() const { return m_ledgerLinesBelowCue; }
 
    void AddLedgerLineAbove(int count, int left, int right, int extension, bool cueSize, const Object *event);
    void AddLedgerLineBelow(int count, int left, int right, int extension, bool cueSize, const Object *event);
 
    bool IsOnStaffLine(int y, const Doc *doc) const;
 
    int GetNearestInterStaffPosition(int y, const Doc *doc, data_STAFFREL place) const;
 
    void SetFromFacsimile(Doc *doc);
 
    int GetOssiaDrawingShift(const Measure *measure, Doc *doc) 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:
    void AddLedgerLines(ArrayOfLedgerLines &lines, int count, int left, int right, int extension, const Object *event);
 
public:
    int m_drawingLines;
 
    data_NOTATIONTYPE m_drawingNotationType;
 
    int m_drawingStaffSize;
 
    std::vector<Object *> m_timeSpanningElements;
 
    int m_drawingFacsY;
 
    StaffDef *m_drawingStaffDef;
 
    Tuning *m_drawingTuning;
 
private:
    StaffAlignment *m_staffAlignment;
 
    ArrayOfLedgerLines m_ledgerLinesAbove;
    ArrayOfLedgerLines m_ledgerLinesBelow;
    ArrayOfLedgerLines m_ledgerLinesAboveCue;
    ArrayOfLedgerLines m_ledgerLinesBelowCue;
 
    double m_drawingRotation;
 
    bool m_isOssia;
};
 
} // namespace vrv
 
#endif