verovio-doxygen/html/drawinginterface_8h_source.html

// Name:        drawinginterface.h

// Author:      Laurent Pugin

// Created:     2015

// Copyright (c) Authors and others. All rights reserved.


#ifndef __VRV_DRAWING_INTERFACE_H__

#define __VRV_DRAWING_INTERFACE_H__


#include "clef.h"

#include "devicecontextbase.h"

#include "keysig.h"

#include "mensur.h"

#include "metersig.h"

#include "metersiggrp.h"

#include "proport.h"

#include "vrvdef.h"


namespace vrv {


class Object;

class Stem;


//----------------------------------------------------------------------------

// DrawingListInterface

//----------------------------------------------------------------------------


class DrawingListInterface {

public:

    DrawingListInterface();

    virtual ~DrawingListInterface();

    virtual void Reset();


    void AddToDrawingList(Object *element);


    ArrayOfObjects *GetDrawingList();


    void ResetDrawingList();


    //-----------------//

    // Pseudo functors //

    //-----------------//


    FunctorCode InterfaceResetData(ResetDataFunctor &functor);


private:

    //

public:

    //

protected:

    ArrayOfObjects m_drawingList;


private:

    //

};


//----------------------------------------------------------------------------

// BeamDrawingInterface

//----------------------------------------------------------------------------


class BeamDrawingInterface : public ObjectListInterface {

public:

    BeamDrawingInterface();

    virtual ~BeamDrawingInterface();

    virtual void Reset();


    bool IsFirstIn(const LayerElement *element) const;

    bool IsLastIn(const LayerElement *element) const;


    bool HasCoords() const { return !m_beamElementCoords.empty(); }

    void InitCoords(const ArrayOfObjects &childList, Staff *staff, data_BEAMPLACE place);

    void InitCoords(const ListOfObjects &childList, Staff *staff, data_BEAMPLACE place);


    void InitCue(bool beamCue);


    void InitGraceStemDir(bool graceGrp);


    bool IsHorizontal() const;


    bool IsRepeatedPattern() const;


    bool HasOneStepHeight() const;


    int GetTotalBeamWidth() const;


    void ClearCoords();


    virtual std::pair<int, int> GetAdditionalBeamCount() const { return { 0, 0 }; }


    virtual std::pair<int, int> GetFloatingBeamCount() const { return { 0, 0 }; }


    void GetBeamOverflow(StaffAlignment *&above, StaffAlignment *&below) const;


    void GetBeamChildOverflow(StaffAlignment *&above, StaffAlignment *&below) const;


    //-----------------//

    // Pseudo functors //

    //-----------------//


    FunctorCode InterfaceResetData(ResetDataFunctor &functor);


protected:

    int GetPosition(const LayerElement *element) const;


    //

private:

    bool IsHorizontalMixedBeam(const std::vector<int> &items, const std::vector<data_BEAMPLACE> &directions) const;


public:

    // values to be set before calling CalcBeam

    bool m_changingDur;

    bool m_beamHasChord;

    bool m_hasMultipleStemDir;

    bool m_cueSize;

    Staff *m_crossStaffContent;

    data_STAFFREL_basic m_crossStaffRel;

    bool m_isSpanningElement;

    data_DURATION m_shortestDur;

    data_STEMDIRECTION m_notesStemDir;

    data_BEAMPLACE m_drawingPlace;

    Staff *m_beamStaff;


    // values set by CalcBeam

    int m_beamWidth;

    int m_beamWidthBlack;

    int m_beamWidthWhite;

    int m_fractionSize;


    ArrayOfBeamElementCoords m_beamElementCoords;


private:

    //

};


//----------------------------------------------------------------------------

// StaffDefDrawingInterface

//----------------------------------------------------------------------------


class StaffDefDrawingInterface {

public:

    StaffDefDrawingInterface();

    virtual ~StaffDefDrawingInterface();

    virtual void Reset();


    bool DrawClef() const { return (m_drawClef && m_currentClef.HasShape()); }

    void SetDrawClef(bool drawClef) { m_drawClef = drawClef; }

    bool DrawKeySig() const { return (m_drawKeySig); }

    void SetDrawKeySig(bool drawKeySig) { m_drawKeySig = drawKeySig; }

    bool DrawMensur() const { return (m_drawMensur && (m_currentMensur.HasSign() || m_currentMensur.HasNum())); }

    void SetDrawMensur(bool drawMensur) { m_drawMensur = drawMensur; }

    bool DrawMeterSig() const

    {

        return (m_drawMeterSig && (m_currentMeterSig.HasUnit() || m_currentMeterSig.HasSym()));

    }

    void SetDrawMeterSig(bool drawMeterSig) { m_drawMeterSig = drawMeterSig; }

    bool DrawMeterSigGrp() const;

    void SetDrawMeterSigGrp(bool drawMeterSigGrp) { m_drawMeterSigGrp = drawMeterSigGrp; }


    void SetCurrentClef(const Clef *clef);

    void SetCurrentKeySig(const KeySig *keySig);

    void SetCurrentMensur(const Mensur *mensur);

    void SetCurrentMeterSig(const MeterSig *meterSig);

    void SetCurrentMeterSigGrp(const MeterSigGrp *meterSigGrp);

    void AlternateCurrentMeterSig(const Measure *measure);

    void SetCurrentProport(const Proport *proport);


    Clef *GetCurrentClef() { return &m_currentClef; }

    const Clef *GetCurrentClef() const { return &m_currentClef; }

    KeySig *GetCurrentKeySig() { return &m_currentKeySig; }

    const KeySig *GetCurrentKeySig() const { return &m_currentKeySig; }

    Mensur *GetCurrentMensur() { return &m_currentMensur; }

    const Mensur *GetCurrentMensur() const { return &m_currentMensur; }

    MeterSig *GetCurrentMeterSig() { return &m_currentMeterSig; }

    const MeterSig *GetCurrentMeterSig() const { return &m_currentMeterSig; }

    MeterSigGrp *GetCurrentMeterSigGrp() { return &m_currentMeterSigGrp; }

    const MeterSigGrp *GetCurrentMeterSigGrp() const { return &m_currentMeterSigGrp; }

    Proport *GetCurrentProport() { return &m_currentProport; }

    const Proport *GetCurrentProport() const { return &m_currentProport; }


    //-----------------//

    // Pseudo functors //

    //-----------------//


    FunctorCode InterfaceResetData(ResetDataFunctor &functor);


private:

    Clef m_currentClef;

    KeySig m_currentKeySig;

    Mensur m_currentMensur;

    MeterSig m_currentMeterSig;

    MeterSigGrp m_currentMeterSigGrp;

    Proport m_currentProport;


    bool m_drawClef;

    bool m_drawKeySig;

    bool m_drawMensur;

    bool m_drawMeterSig;

    bool m_drawMeterSigGrp;

};


//----------------------------------------------------------------------------

// StemmedDrawingInterface

//----------------------------------------------------------------------------


class StemmedDrawingInterface {

public:

    StemmedDrawingInterface();

    virtual ~StemmedDrawingInterface();

    virtual void Reset();


    void SetDrawingStem(Stem *stem);

    Stem *GetDrawingStem() { return m_drawingStem; }

    const Stem *GetDrawingStem() const { return m_drawingStem; }


    void SetDrawingStemDir(data_STEMDIRECTION stemDir);

    data_STEMDIRECTION GetDrawingStemDir() const;

    void SetDrawingStemLen(int drawingStemLen);

    int GetDrawingStemLen() const;

    int GetDrawingStemModRelY() const;


    Point GetDrawingStemStart(const Object *object = NULL) const;

    Point GetDrawingStemEnd(const Object *object = NULL) const;


    virtual Point GetStemUpSE(const Doc *doc, int staffSize, bool graceSize) const = 0;

    virtual Point GetStemDownNW(const Doc *doc, int staffSize, bool graceSize) const = 0;

    virtual int CalcStemLenInThirdUnits(const Staff *staff, data_STEMDIRECTION stemDir) const = 0;


    //-----------------//

    // Pseudo functors //

    //-----------------//


    FunctorCode InterfaceResetData(ResetDataFunctor &functor);


protected:

    Stem *m_drawingStem;

};


} // namespace vrv


#endif