accid.h

// Name:        accid.h
// Author:      Laurent Pugin
// Created:     201X
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_ACCID_H__
#define __VRV_ACCID_H__
 
#include "atts_externalsymbols.h"
#include "atts_gestural.h"
#include "floatingobject.h"
#include "layerelement.h"
#include "offsetinterface.h"
#include "positioninterface.h"
 
namespace vrv {
 
class AlignmentReference;
class AccidFloatingObject;
 
//----------------------------------------------------------------------------
// Accid
//----------------------------------------------------------------------------
 
class Accid : public LayerElement,
              public OffsetInterface,
              public PositionInterface,
              public AttAccidental,
              public AttAccidentalGes,
              public AttAccidLog,
              public AttColor,
              public AttEnclosingChars,
              public AttExtSymAuth,
              public AttExtSymNames,
              public AttPlacementOnStaff,
              public AttPlacementRelEvent {
public:
    Accid();
    virtual ~Accid();
    Object *Clone() const override { return new Accid(*this); }
    void Reset() override;
    std::string GetClassName() const override { return "accid"; }
 
    bool IsSupportedChild(ClassId classId) override;
 
    void ClearFloatingObject();
 
    void InitFloatingObject();
 
    void InitShowAccidGes();
 
    AccidFloatingObject *GetFloatingObject() { return m_floatingObject; }
 
    bool IsRelativeToStaff() const override { return (this->HasLoc() || (this->HasOloc() && this->HasPloc())); }
 
    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); }
 
    bool HasToBeAligned() const override { return true; }
 
    void SetDrawingUnisonAccid(Accid *drawingUnison) { m_drawingUnison = drawingUnison; }
    Accid *GetDrawingUnisonAccid() { return m_drawingUnison; }
    const Accid *GetDrawingUnisonAccid() const { return m_drawingUnison; }
 
    std::u32string GetSymbolStr(data_NOTATIONTYPE notationType) const;
 
    void AdjustX(LayerElement *element, const Doc *doc, int staffSize, std::vector<Accid *> &leftAccids,
        std::set<Accid *> &adjustedAccids);
 
    void AdjustToLedgerLines(const Doc *doc, LayerElement *element, int staffSize);
 
    void IsAlignedWithSameLayer(bool alignWithSameLayer) { m_alignedWithSameLayer = alignWithSameLayer; }
    bool IsAlignedWithSameLayer() const { return m_alignedWithSameLayer; }
 
    //----------------//
    // Static methods //
    //----------------//
 
    static char32_t GetAccidGlyph(data_ACCIDENTAL_WRITTEN accid);
 
    static std::u32string CreateSymbolStr(data_ACCIDENTAL_WRITTEN accid, data_ENCLOSURE enclosure = ENCLOSURE_NONE,
        data_NOTATIONTYPE notationType = NOTATIONTYPE_NONE, const Resources *resources = NULL, data_HEXNUM glyphNum = 0,
        std::string glyphName = "");
 
    //----------//
    // 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:
    Accid *m_drawingUnison;
    bool m_alignedWithSameLayer;
 
    AccidFloatingObject *m_floatingObject;
};
 
//----------------------------------------------------------------------------
// AccidFloatingObject
//----------------------------------------------------------------------------
 
class AccidFloatingObject : public FloatingObject {
public:
    AccidFloatingObject();
    virtual ~AccidFloatingObject() {}
    std::string GetClassName() const override { return "accid"; }
    void Reset() override;
 
private:
    //
public:
    //
private:
    //
};
 
//----------------------------------------------------------------------------
// AccidSpaceSort
//----------------------------------------------------------------------------
 
class AccidSpaceSort {
 
public:
    AccidSpaceSort() = default;
 
    bool operator()(const Accid *first, const Accid *second) const
    {
        if (first->GetDrawingY() == second->GetDrawingY()) {
            // with unissons, natural should always be the last accidental
            return ((first->GetAccid() == ACCIDENTAL_WRITTEN_n) && (second->GetAccid() != ACCIDENTAL_WRITTEN_n));
        }
        else {
            return (first->GetDrawingY() > second->GetDrawingY());
        }
    }
};
 
//----------------------------------------------------------------------------
// AccidOctaveSort
//----------------------------------------------------------------------------
 
class AccidOctaveSort {
 
public:
    AccidOctaveSort() = default;
 
    // Encodes parent ID + accid type + pitch
    std::string GetOctaveID(const Accid *accid) const;
 
    bool operator()(const Accid *first, const Accid *second) const
    {
        return this->GetOctaveID(first) < this->GetOctaveID(second);
    }
};
 
} // namespace vrv
 
#endif