elementpart.h

// Name:        elementpart.h
// Author:      Laurent Pugin
// Created:     2017
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_ELEMENT_PART_H__
#define __VRV_ELEMENT_PART_H__
 
#include "atts_cmn.h"
#include "atts_shared.h"
#include "atts_visual.h"
#include "layerelement.h"
 
namespace vrv {
 
class TupletNum;
 
//----------------------------------------------------------------------------
// Dots
//----------------------------------------------------------------------------
 
class Dots : public LayerElement, public AttAugmentDots {
public:
    Dots();
    virtual ~Dots();
    void Reset() override;
    std::string GetClassName() const override { return "dots"; }
    Object *Clone() const override { return new Dots(*this); }
 
    bool HasToBeAligned() const override { return true; }
 
    std::set<int> GetDotLocsForStaff(const Staff *staff) const;
    std::set<int> &ModifyDotLocsForStaff(const Staff *staff);
 
    const MapOfDotLocs &GetMapOfDotLocs() const { return m_dotLocsByStaff; }
    void SetMapOfDotLocs(const MapOfDotLocs &dotLocs) { m_dotLocsByStaff = dotLocs; };
    void ResetMapOfDotLocs() { m_dotLocsByStaff.clear(); }
 
    void IsAdjusted(bool isAdjusted) { m_isAdjusted = isAdjusted; }
    bool IsAdjusted() const { return m_isAdjusted; }
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
    int GetFlagShift() const { return m_flagShift; }
    void SetFlagShift(int shiftVal) { m_flagShift = shiftVal; }
 
private:
    //
public:
    //
private:
    MapOfDotLocs m_dotLocsByStaff;
 
    bool m_isAdjusted;
    int m_flagShift;
};
 
//----------------------------------------------------------------------------
// Flag
//----------------------------------------------------------------------------
 
class Flag : public LayerElement {
public:
    Flag();
    virtual ~Flag();
    void Reset() override;
    std::string GetClassName() const override { return "flag"; }
    Object *Clone() const override { return new Flag(*this); }
 
    bool HasToBeAligned() const override { return true; }
 
    char32_t GetFlagGlyph(data_STEMDIRECTION stemDir) const;
 
    Point GetStemUpSE(const Doc *doc, int staffSize, bool graceSize) const;
    Point GetStemDownNW(const Doc *doc, int staffSize, bool graceSize) 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:
    int m_drawingNbFlags;
 
private:
};
 
//----------------------------------------------------------------------------
// TupletBracket
//----------------------------------------------------------------------------
 
class TupletBracket : public LayerElement, public AttTupletVis {
public:
    TupletBracket();
    virtual ~TupletBracket();
    void Reset() override;
    std::string GetClassName() const override { return "tupletBracket"; }
    Object *Clone() const override { return new TupletBracket(*this); }
 
    int GetDrawingXRelLeft() const { return m_drawingXRelLeft; }
    void SetDrawingXRelLeft(int drawingXRelLeft) { m_drawingXRelLeft = drawingXRelLeft; }
    int GetDrawingXRelRight() const { return m_drawingXRelRight; }
    void SetDrawingXRelRight(int drawingXRelRight) { m_drawingXRelRight = drawingXRelRight; }
    // Vertical positions
    int GetDrawingYRelLeft() const { return m_drawingYRelLeft; }
    void SetDrawingYRelLeft(int drawingYRelLeft) { m_drawingYRelLeft = drawingYRelLeft; }
    int GetDrawingYRelRight() const { return m_drawingYRelRight; }
    void SetDrawingYRelRight(int drawingYRelRight) { m_drawingYRelRight = drawingYRelRight; }
 
    int GetDrawingXLeft() const;
    int GetDrawingXRight() const;
    int GetDrawingYLeft() const;
    int GetDrawingYRight() const;
 
    TupletNum *GetAlignedNum() { return m_alignedNum; }
    const TupletNum *GetAlignedNum() const { return m_alignedNum; }
    void SetAlignedNum(TupletNum *alignedNum) { m_alignedNum = alignedNum; }
 
    //----------//
    // 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_drawingXRelLeft;
    int m_drawingXRelRight;
    int m_drawingYRelLeft = 0;
    int m_drawingYRelRight = 0;
    TupletNum *m_alignedNum;
};
 
//----------------------------------------------------------------------------
// TupletNum
//----------------------------------------------------------------------------
 
class TupletNum : public LayerElement, public AttNumberPlacement, public AttTupletVis {
public:
    TupletNum();
    virtual ~TupletNum();
    void Reset() override;
    std::string GetClassName() const override { return "tupletNum"; }
    Object *Clone() const override { return new TupletNum(*this); }
 
    int GetDrawingYMid() const;
    int GetDrawingXMid(const Doc *doc = NULL) const;
 
    TupletBracket *GetAlignedBracket() { return m_alignedBracket; }
    const TupletBracket *GetAlignedBracket() const { return m_alignedBracket; }
    void SetAlignedBracket(TupletBracket *alignedBracket);
 
    //----------//
    // 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:
    TupletBracket *m_alignedBracket;
};
 
} // namespace vrv
 
#endif