drawinginterface.h

// 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;
};
 
//----------------------------------------------------------------------------
// VisibilityDrawingInterface
//----------------------------------------------------------------------------
 
class VisibilityDrawingInterface {
public:
    VisibilityDrawingInterface();
    virtual ~VisibilityDrawingInterface();
    virtual void Reset();
 
    void SetVisibility(VisibilityType visibility) { m_visibility = visibility; }
    bool IsHidden() const { return (m_visibility == Hidden); }
 
    //-----------------//
    // Pseudo functors //
    //-----------------//
 
private:
    VisibilityType m_visibility;
};
 
} // namespace vrv
 
#endif