rest.h

// Name:        rest.h
// Author:      Laurent Pugin
// Created:     2011
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_REST_H__
#define __VRV_REST_H__
 
#include "altsyminterface.h"
#include "atts_externalsymbols.h"
#include "atts_mensural.h"
#include "atts_visual.h"
#include "durationinterface.h"
#include "layerelement.h"
#include "offsetinterface.h"
#include "positioninterface.h"
 
namespace vrv {
 
class TransPitch;
 
enum RestLayer { RL_UNSET = -1, RL_sameLayer, RL_otherLayer };
 
enum RestAccidental { RA_UNSET = -1, RA_none, RA_s, RA_f, RA_x, RA_n };
 
enum RestLayerPlace { RLP_UNSET = -1, RLP_restOnTopLayer, RLP_restOnBottomLayer };
 
enum RestNotePlace { RNP_UNSET = -1, RNP_noteInSpace, RNP_noteOnLine };
 
//----------------------------------------------------------------------------
// Rest
//----------------------------------------------------------------------------
 
class Rest : public LayerElement,
             public AltSymInterface,
             public DurationInterface,
             public OffsetInterface,
             public PositionInterface,
             public AttColor,
             public AttCue,
             public AttEnclosingChars,
             public AttExtSymAuth,
             public AttExtSymNames,
             public AttRestVisMensural {
public:
    Rest();
    virtual ~Rest();
    Object *Clone() const override { return new Rest(*this); }
    void Reset() override;
    std::string GetClassName() const override { return "rest"; }
 
    bool IsSupportedChild(ClassId classId) override;
 
    bool AddChild(Object *object) override;
 
    AltSymInterface *GetAltSymInterface() override { return vrv_cast<AltSymInterface *>(this); }
    const AltSymInterface *GetAltSymInterface() const override { return vrv_cast<const AltSymInterface *>(this); }
    OffsetInterface *GetOffsetInterface() override { return vrv_cast<OffsetInterface *>(this); }
    const OffsetInterface *GetOffsetInterface() const override { return vrv_cast<const OffsetInterface *>(this); }
    PositionInterface *GetPositionInterface() override { return vrv_cast<PositionInterface *>(this); }
    const PositionInterface *GetPositionInterface() const override { return vrv_cast<const PositionInterface *>(this); }
    DurationInterface *GetDurationInterface() override { return vrv_cast<DurationInterface *>(this); }
    const DurationInterface *GetDurationInterface() const override { return vrv_cast<const DurationInterface *>(this); }
 
    bool HasToBeAligned() const override { return true; }
 
    char32_t GetRestGlyph() const;
    char32_t GetRestGlyph(const data_DURATION duration) const;
 
    int GetOptimalLayerLocation(const Staff *staff, const Layer *layer, int defaultLocation) const;
 
    void UpdateFromTransLoc(const TransPitch &tp);
 
    std::pair<char32_t, char32_t> GetEnclosingGlyphs() 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:
    std::pair<int, RestAccidental> GetLocationRelativeToOtherLayers(
        const Layer *currentLayer, bool isTopLayer, bool &restOverlap) const;
 
    int GetLocationRelativeToCurrentLayer(const Staff *currentStaff, const Layer *currentLayer, bool isTopLayer) const;
 
    int GetFirstRelativeElementLocation(
        const Staff *currentStaff, const Layer *currentLayer, bool isPrevious, bool isTopLayer) const;
 
    int GetMarginLayerLocation(bool isTopLayer, bool restOverlap) const;
 
    std::pair<int, RestAccidental> GetElementLocation(const Object *object, const Layer *layer, bool isTopLayer) const;
 
    int GetRestOffsetFromOptions(
        RestLayer layer, const std::pair<int, RestAccidental> &location, bool isTopLayer) const;
 
    bool DetermineRestPosition(const Staff *staff, const Layer *layer, bool &isTopLayer) const;
 
public:
    //
private:
};
 
} // namespace vrv
 
#endif