note.h

// Name:        note.h
// Author:      Laurent Pugin
// Created:     2011
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_NOTE_H__
#define __VRV_NOTE_H__
 
#include <cassert>
 
//----------------------------------------------------------------------------
 
#include "accid.h"
#include "altsyminterface.h"
#include "atts_analytical.h"
#include "atts_externalsymbols.h"
#include "atts_mensural.h"
#include "atts_midi.h"
#include "atts_shared.h"
#include "atts_stringtab.h"
#include "beam.h"
#include "chord.h"
#include "durationinterface.h"
#include "layerelement.h"
#include "offsetinterface.h"
#include "pitchinterface.h"
#include "transposition.h"
 
namespace vrv {
 
class Accid;
class Chord;
class Note;
class Slur;
class TabGrp;
class Tie;
class Verse;
 
//----------------------------------------------------------------------------
// Note
//----------------------------------------------------------------------------
 
class Note : public LayerElement,
             public StemmedDrawingInterface,
             public AltSymInterface,
             public DurationInterface,
             public OffsetInterface,
             public PitchInterface,
             public PositionInterface,
             public AttColor,
             public AttColoration,
             public AttCue,
             public AttExtSymAuth,
             public AttExtSymNames,
             public AttGraced,
             public AttHarmonicFunction,
             public AttMidiVelocity,
             public AttNoteHeads,
             public AttNoteVisMensural,
             public AttStems,
             public AttStemsCmn,
             public AttStringtab,
             public AttTiePresent,
             public AttVisibility {
public:
    Note();
    virtual ~Note();
    Object *Clone() const override { return new Note(*this); }
    void Reset() override;
    std::string GetClassName() const override { return "note"; }
 
    AltSymInterface *GetAltSymInterface() override { return vrv_cast<AltSymInterface *>(this); }
    const AltSymInterface *GetAltSymInterface() const override { return vrv_cast<const AltSymInterface *>(this); }
    DurationInterface *GetDurationInterface() override { return vrv_cast<DurationInterface *>(this); }
    const DurationInterface *GetDurationInterface() const override { return vrv_cast<const DurationInterface *>(this); }
    OffsetInterface *GetOffsetInterface() override { return vrv_cast<OffsetInterface *>(this); }
    const OffsetInterface *GetOffsetInterface() const override { return vrv_cast<const OffsetInterface *>(this); }
    PitchInterface *GetPitchInterface() override { return vrv_cast<PitchInterface *>(this); }
    const PitchInterface *GetPitchInterface() const override { return vrv_cast<const PitchInterface *>(this); }
    PositionInterface *GetPositionInterface() override { return vrv_cast<PositionInterface *>(this); }
    const PositionInterface *GetPositionInterface() const override { return vrv_cast<const PositionInterface *>(this); }
    StemmedDrawingInterface *GetStemmedDrawingInterface() override { return vrv_cast<StemmedDrawingInterface *>(this); }
    const StemmedDrawingInterface *GetStemmedDrawingInterface() const override
    {
        return vrv_cast<const StemmedDrawingInterface *>(this);
    }
 
    bool HasToBeAligned() const override { return true; }
 
    bool IsSupportedChild(ClassId classId) override;
 
    bool AddChild(Object *object) override;
 
    bool AddChildAdditionalCheck(Object *child) override;
 
    void AlignDotsShift(const Note *otherNote);
 
    Accid *GetDrawingAccid();
    const Accid *GetDrawingAccid() const;
 
    Chord *IsChordTone();
    const Chord *IsChordTone() const;
    data_DURATION GetDrawingDur() const;
    bool IsNoteGroupExtreme() const; // used to find if it is the highest or lowest note in a note group
 
    TabGrp *IsTabGrpNote();
    const TabGrp *IsTabGrpNote() const;
 
    std::u32string GetTabFretString(data_NOTATIONTYPE notationType, int &overline, int &strike, int &underline) const;
 
    bool IsUnisonWith(const Note *note, bool ignoreAccid = false) const;
 
    void SetNoteGroup(ChordNoteGroup *noteGroup, int position);
    ChordNoteGroup *GetNoteGroup() { return m_noteGroup; }
    int GetNoteGroupPosition() const { return m_noteGroupPosition; }
 
    void SetFlippedNotehead(bool flippedNotehead) { m_flippedNotehead = flippedNotehead; }
    bool GetFlippedNotehead() const { return m_flippedNotehead; }
 
    int GetDiatonicPitch() const;
 
    Point GetStemUpSE(const Doc *doc, int staffSize, bool isCueSize) const override;
    Point GetStemDownNW(const Doc *doc, int staffSize, bool isCueSize) const override;
    int CalcStemLenInThirdUnits(const Staff *staff, data_STEMDIRECTION stemDir) const override;
 
    char32_t GetMensuralNoteheadGlyph() const;
 
    char32_t GetNoteheadGlyph(const data_DURATION duration) const;
 
    bool IsEnharmonicWith(const Note *note) const;
 
    bool IsVisible() const;
 
    int GetMIDIPitch(int shift = 0, int octaveShift = 0) const;
 
    int GetPitchClass() const;
 
    bool HasStemSameasNote() const { return (m_stemSameas); }
    Note *GetStemSameasNote() { return m_stemSameas; }
    const Note *GetStemSameasNote() const { return m_stemSameas; }
    void SetStemSameasNote(Note *stemSameas) { m_stemSameas = stemSameas; }
 
    StemSameasDrawingRole GetStemSameasRole() const { return m_stemSameasRole; }
    void SetStemSameasRole(StemSameasDrawingRole stemSameasRole) { m_stemSameasRole = stemSameasRole; }
 
    data_STEMDIRECTION CalcStemDirForSameasNote(int verticalCenter);
 
    void CalcNoteHeadShiftForSameasNote(Note *stemSameas, data_STEMDIRECTION stemDir);
 
public:
    //----------------//
    // Static methods //
    //----------------//
 
    static bool HandleLedgerLineStemCollision(const Doc *doc, const Staff *staff, const Note *note1, const Note *note2);
 
    static int PnameToPclass(data_PITCHNAME pitchName);
 
    TransPitch GetTransPitch() const;
    void UpdateFromTransPitch(const TransPitch &tp, bool hasKeySig);
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
protected:
    MapOfNoteLocs CalcNoteLocations(NotePredicate predicate = NULL) const override;
 
    MapOfDotLocs CalcDotLocations(int layerCount, bool primary) const override;
 
private:
    int GetChromaticAlteration() const;
 
public:
    //
private:
    bool m_flippedNotehead;
 
    ChordNoteGroup *m_noteGroup;
 
    int m_noteGroupPosition;
 
    Note *m_stemSameas;
 
    StemSameasDrawingRole m_stemSameasRole;
};
 
//----------------------------------------------------------------------------
// DiatonicSort
//----------------------------------------------------------------------------
 
class DiatonicSort {
 
public:
    DiatonicSort() {}
 
    bool operator()(const Object *first, const Object *second) const
    {
        const Note *n1 = dynamic_cast<const Note *>(first);
        const Note *n2 = dynamic_cast<const Note *>(second);
        assert(n1 && n2);
        return (n1->GetDiatonicPitch() < n2->GetDiatonicPitch());
    }
};
 
//----------------------------------------------------------------------------
// TabCourseSort
//----------------------------------------------------------------------------
 
class TabCourseSort {
 
public:
    TabCourseSort() {}
 
    bool operator()(const Object *first, const Object *second) const
    {
        const Note *n1 = dynamic_cast<const Note *>(first);
        const Note *n2 = dynamic_cast<const Note *>(second);
        assert(n1 && n2);
        return (n1->GetTabCourse() > n2->GetTabCourse());
    }
};
 
} // namespace vrv
 
#endif