ff_smartshapes.h

/*
 * File:   ff_smartshapes.h
 * Author: Jari Williamsson
 *
 * Created on den 16 april 2011, 21:20
 */
 
#ifndef FF_SMARTSHAPES_H
#define FF_SMARTSHAPES_H
 
#include "ff_noteframe.h"
#include "ff_text.h"
 
 
#ifdef PDK_FRAMEWORK_SMARTSHAPES
 
/*****************************************************/
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
/* Undocumented PDK stuff */
 
#include "pragma_align_begin.h"
class __EDTSmartShapeMeasMark
{
public:
   CMPER    shapeNum;
   CMPER    centerShapeNum;
private:
   twobyte     CCCC;
   twobyte     DDDD;
   twobyte     EEEE;
   twobyte     FFFF;
public:
   __EDTSmartShapeMeasMark() : shapeNum(0), centerShapeNum(0),
                           CCCC(0), DDDD(0), EEEE(0), FFFF(0) {}
};
#include "pragma_align_end.h"
 
#define __ot_SmartShapeMeasMark MAKEEXTAG(edOther,'M','x')
 
#include "pragma_align_begin.h"
struct __EDTSmartShapeEntryMark
{
        CMPER           shapeNum; // CMPER of the smartshape (unsigned twobyte)
        twobyte         BBBB;
        twobyte         CCCC;
        twobyte         DDDD;
        twobyte         EEEE;
};
#include "pragma_align_end.h"
 
#define __dt_SmartShapeEntryMark MAKEEXTAG(edEntryDetail,'E','x')
 
#include "pragma_align_begin.h"
class __SSENDPT  // current size: 8 bytes
{
public:
   twobyte     inst;
   twobyte     meas;
   union
   {
      TimeEdu32 edu;        // for measure-based shapes
      ENTNUM      entryNum;      // for entry-based shapes
   } attachment;
   __SSENDPT() : inst(0), meas(0)
   {
      attachment.entryNum = 0;   // initialize the biggest side of the union
   };
   ENTNUM GetEntryNum() const { return attachment.entryNum; }
   TimeEdu32 GetEdu() const { return attachment.edu; }
   void SetEntryNum(ENTNUM entryNum) { attachment.entryNum=entryNum; }
   void SetEdu(TimeEdu32 edu) { attachment.edu=edu; }
#if OPERATING_SYSTEM == MAC_OS
   void SwapWords() // necessary adjustment on Macintosh after loading and before saving
   {
      attachment.entryNum=attachment.entryNum/0x10000+(attachment.entryNum%0x10000)*0x10000;
   }
#endif
};
#include "pragma_align_end.h"
 
#include "pragma_align_begin.h"
class __SSENDPTADJ  // current size: 6 bytes
{
public:
   ETOFFSET offset;
   FLAG_16     flag;
   __SSENDPTADJ() : flag(0), offset(0,0) {}
};
#include "pragma_align_end.h"
 
#include "pragma_align_begin.h"
class __SSCTLPTADJ  // current size: 10 bytes
{
public:
   ETOFFSET controlPoint1;
   ETOFFSET controlPoint2;
   FLAG_16     flag;
   __SSCTLPTADJ() : flag(0),controlPoint1(),controlPoint2() { }
};
#include "pragma_align_end.h"
 
#include "pragma_align_begin.h"
class __SSTERMSEG   // current size: 8 + 6 + 10 + 6 = 30 bytes
{
public:
   __SSENDPT     endPt;
   __SSENDPTADJ  endPtAdj;
   __SSCTLPTADJ  ctlPtAdj;
   __SSENDPTADJ  breakAdj;
   __SSTERMSEG() : endPt(), endPtAdj(), ctlPtAdj(), breakAdj() {}
};
#include "pragma_align_end.h"
 
#include "pragma_align_begin.h"
class __EDTSmartShape
{
  public:
    twobyte     shapeType;
    FLAG_32     flag;
    __SSTERMSEG   termSeg1;      // terminating segments
    __SSTERMSEG   termSeg2;      // terminating segments
    __SSCTLPTADJ  fullCtlPtAdj;  // used for single-system shapes
    twobyte     noteID[2];     // Note attached smart shapes
                               // use this extra data for noteID.
    utwobyte    ssLineStyleID;  //
    FLAG_16     flag2;         // type specific properties.  For example, a slur
                               // has a direction property, OVER, UNDER, or AUTO.
    twobyte     lyricNum[2];   // for lyric-based shapes
    ETAG        lyricTag[2];
    __EDTSmartShape() : shapeType(0), flag(0), fullCtlPtAdj(),
                            ssLineStyleID(0), flag2(0), termSeg1(), termSeg2()
    {
      noteID[0] = 0;
      noteID[1] = 0;
      lyricNum[0] = 0;
      lyricNum[1] = 0;
      lyricTag[0] = 0;
      lyricTag[1] = 0;
    }
};
#include "pragma_align_end.h"
 
#define __edOther8Inci  MAKETAG(edMultiInciOther,8)  /* 8 other incidences/struct */
 
const EXTAG __ot_SmartShape     = MAKEEXTAG(__edOther8Inci,'S','x');
 
#include "pragma_align_begin.h"
class __EDTCenterShape
{
public:
   __SSENDPTADJ  breakAdj1;
   __SSENDPTADJ  breakAdj2;
   __SSCTLPTADJ  ctlPtAdj;
   __EDTCenterShape() : ctlPtAdj(),breakAdj1(),breakAdj2() {}
};
#include "pragma_align_end.h"
 
#define __dt_CenterShape MAKEEXTAG(edDetail3Inci,'C','x')
 
const FLAG_32 __SS_FLAG_RESERVED   = 0x80000000L; // Reserved for future expansion
const FLAG_32 __SS_ENTRYBASED      = 0x40000000L; // Entry-based vs measure-based
const FLAG_32 __SS_ROTATE          = 0x20000000L; // Always set for slurs
const FLAG_32 __SS_LYRICBASED      = 0x10000000L;       // lyric-based smart shape
const FLAG_32 __SS_PRESETSHAPE     = 0x00008000L; // If set, shapeType field is a predefined
                                                // shape (see defines below). In the future,
                                                // shapeType could also be user defined
                                                // shapes.
const FLAG_32 __SS_MAKEHORZ        = 0x00000400L; // endpoints are locked together
                                                // vertically (so shape stays 'horizontal',
                                                // like 8va or dashed line)
const FLAG_32 __SS_PUSHENDSTART    = 0x00000200L; // Always set nowadays
const FLAG_32 __SS_MAKEVERT        = 0x00000100L; // "make vertical"
const FLAG_32 __SS_ENGRAVER_SLUR_BITS = 0x00000030L;
 
 
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
/*****************************************************/
 
 
 
 
class FCSmartShape;
 
class FCSmartShapeMeasureMark : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTSmartShapeMeasMark _smartshapemeasmark;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return __ot_SmartShapeMeasMark; }
    int DataSizeLoad() const override { return sizeof(__EDTSmartShapeMeasMark); }
    void* Allocate() override { return (void*) &_smartshapemeasmark; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_smartshapemeasmark, ((FCSmartShapeMeasureMark*)pSource)->_GetSmartShapeMeasureMark(), sizeof(_smartshapemeasmark));
        _datablock = &_smartshapemeasmark;
        _loadedsize = sizeof(_smartshapemeasmark);
    }
 
    __FCBaseData* CreateObject() override
                { return new FCSmartShapeMeasureMark(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCSmartShapeMeasureMark"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SMARTSHAPEMEASUREMARK; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetSmartShapeMeasureMark() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSmartShapeMeasureMark() : __FCInciOther()
    {
        /* The __EDTSmartShapeMeasMark is initialized automatically */
        _datablock = &_smartshapemeasmark;
        _loadedsize = sizeof(_smartshapemeasmark);
    }
 
    void SetShapeNumber(CMPER value) { _smartshapemeasmark.shapeNum = value; }
 
    void _SetCenterShapeNumber(CMPER value) { _smartshapemeasmark.centerShapeNum = value; }
 
    CMPER GetShapeNumber() const { return _smartshapemeasmark.shapeNum; }
 
    CMPER _GetCenterShapeNumber() { return _smartshapemeasmark.centerShapeNum; }
 
    twobyte GetMeasure() const override { return _dataid.other.cmper; }
 
    FCSmartShape* CreateSmartShape(bool load_center_shapes = true);
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCSmartShape> CreateSmartShape_GC(bool load_center_shapes = true)
    { return makeLuaSharedPtr(CreateSmartShape(load_center_shapes)); }
#endif
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutInt("Shape Number: ", GetShapeNumber());
        DebugOutInt("Center Shape Number: ", _GetCenterShapeNumber());
    }
#endif
};
 
#ifdef PDK_FRAMEWORK_ENTRIES
class FCSmartShapeEntryMark : public __FCEntryDetail
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTSmartShapeEntryMark _smartshapeentrymark;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return __dt_SmartShapeEntryMark; }
    int DataSizeLoad() const override { return sizeof(__EDTSmartShapeEntryMark); }
    void* Allocate() override { return (void*) &_smartshapeentrymark; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_smartshapeentrymark, ((FCSmartShapeEntryMark*)pSource)->_GetSmartShapeEntryMark(), sizeof(_smartshapeentrymark));
        _datablock = &_smartshapeentrymark;
        _loadedsize = sizeof(_smartshapeentrymark);
    }
 
    __FCBaseData* CreateObject() override
                { return new FCSmartShapeEntryMark(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCSmartShapeEntryMark"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SMARTSHAPEENTRYMARK; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetSmartShapeEntryMark() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSmartShapeEntryMark() : __FCEntryDetail()
    {
        /* __EDTSmartShapeEntryMark is note initialized automatically */
        memset(&_smartshapeentrymark, 0, sizeof(_smartshapeentrymark));
        _datablock = &_smartshapeentrymark;
        _loadedsize = sizeof(_smartshapeentrymark);
    }
 
    FCSmartShape* CreateSmartShape(bool load_center_shapes);
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    /*  \brief GC version of CreateSmartShape for Lua. */
    luabridge::RefCountedPtr<FCSmartShape> CreateSmartShape_GC(bool load_center_shapes)
    { return makeLuaSharedPtr(CreateSmartShape(load_center_shapes)); }
#endif
    
    bool CalcLeftMark();
    
    bool CalcRightMark();
 
    void SetShapeNumber(CMPER value) { _smartshapeentrymark.shapeNum = value; }
    
    CMPER GetShapeNumber() const { return _smartshapeentrymark.shapeNum; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    twobyte CalcLastInci() override;
    
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetSmartShapeFlag(state);
    }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();
        DebugOutInt("Shape Number: ", GetShapeNumber());
    }
#endif
};
#endif //PDK_FRAMEWORK_ENTRIES
 
class FCCenterSmartShape : public __FCNoInciDetail
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTCenterShape _centershape;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return __dt_CenterShape; }
    int DataSizeLoad() const override { return sizeof(__EDTCenterShape); }
    void* Allocate() override { return (void*) &_centershape; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_centershape, ((FCCenterSmartShape*)pSource)->_GetCenterSmartShape(), sizeof(_centershape));
        _datablock = &_centershape;
        _loadedsize = sizeof(_centershape);
    }
 
    __FCBaseData* CreateObject() override
                { return new FCCenterSmartShape(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCenterSmartShape"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CENTERSMARTSHAPE; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetCenterSmartShape() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCCenterSmartShape() : __FCNoInciDetail()
    {
        /* The '_centershape' data member is initialized automatically. */
        _datablock = &_centershape;
        _loadedsize = sizeof(_centershape);
    }
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciDetail::DebugDump();
    }
#endif
};
 
 
 
 
class FCSmartShape;
 
class FCSmartShapeSegment : public __FCBase
{
    __SSTERMSEG* _pSegment;
    FCSmartShape* _pRealObject;
    bool _isleftsidesegment;
public:
    const char* ClassName() const override { return "FCSmartShapeSegment"; }
 
    FCSmartShapeSegment(__SSTERMSEG* pSeg, FCSmartShape* pReference, bool leftsidesegment) : __FCBase()
    {
        _pSegment = pSeg;
        _pRealObject = pReference;
        _isleftsidesegment = leftsidesegment;
    }
 
    twobyte GetStaff() const { return _pSegment->endPt.inst; }
 
    twobyte GetMeasure() const { return _pSegment->endPt.meas; }
    
    twobyte GetNoteID() const;
 
    TimeEdu32 GetMeasurePos() const { return _pSegment->endPt.attachment.edu; }
 
    ENTNUM GetEntryNumber() const { return _pSegment->endPt.attachment.entryNum; }
 
    twobyte GetEndpointOffsetX() const { return _pSegment->endPtAdj.offset.x; }
 
    twobyte GetEndpointOffsetY() const { return _pSegment->endPtAdj.offset.y; }
 
    twobyte GetControlPoint1OffsetX() const { return _pSegment->ctlPtAdj.controlPoint1.x; }
 
    twobyte GetControlPoint1OffsetY() const { return _pSegment->ctlPtAdj.controlPoint1.y; }
 
    twobyte GetControlPoint2OffsetX() const { return _pSegment->ctlPtAdj.controlPoint2.x; }
 
    twobyte GetControlPoint2OffsetY() const { return _pSegment->ctlPtAdj.controlPoint2.y; }
 
    twobyte GetBreakOffsetX() const { return _pSegment->breakAdj.offset.x; }
 
    twobyte GetBreakOffsetY() const { return _pSegment->breakAdj.offset.y; }
 
    void SetStaff(twobyte staff) { _pSegment->endPt.inst = staff; }
 
    void SetMeasure(twobyte measureno)
    {
        _pSegment->endPt.meas = measureno;
    }
 
    void SetNoteID(twobyte noteID);
    
    void SetMeasurePos(TimeEdu32 edupos) { _pSegment->endPt.attachment.edu = edupos; }
 
    void SetEndpointOffsetX(twobyte value) { _pSegment->endPtAdj.offset.x = value; }
 
    void SetEndpointOffsetY(twobyte value) 
    {        
        _pSegment->endPtAdj.offset.y = value;
    }
    
    void SetControlPoint1OffsetX(twobyte value) { _pSegment->ctlPtAdj.controlPoint1.x = value; }
 
    void SetControlPoint1OffsetY(twobyte value) { _pSegment->ctlPtAdj.controlPoint1.y = value; }
 
    void SetControlPoint2OffsetX(twobyte value) { _pSegment->ctlPtAdj.controlPoint2.x = value; }
 
    void SetControlPoint2OffsetY(twobyte value) { _pSegment->ctlPtAdj.controlPoint2.y = value; }
 
    void SetBreakOffsetX(twobyte value) { _pSegment->breakAdj.offset.x = value; }
 
    void SetBreakOffsetY(twobyte value) { _pSegment->breakAdj.offset.y = value; }
 
    void SetEntryNumber(ENTNUM value) { _pSegment->endPt.attachment.entryNum = value; }
 
#ifdef PDK_FRAMEWORK_ENTRIES
    void SetEntry(FCNoteEntry* pEntry)
    {
        if (!pEntry)
        {
            _pSegment->endPt.SetEntryNum(0);
            return;
        }
                _pSegment->endPt.SetEntryNum(pEntry->GetEntryNumber());
        pEntry->SetSmartShapeFlag(true);
    }    
#endif
 
    void SetCustomOffset(bool rightside)
    {
        _pSegment->endPtAdj.flag = rightside ? 0x400c : 0x400d;  /* Don't know what these flags mean... */
    }
    
    TimeEdu32 CalcMeasurePos() const;
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override;
#endif
 
};
 
class FCSmartShapeCtrlPointAdjust : public __FCBase
{
    __SSCTLPTADJ* _pCtrlPointAdjust;
    FCSmartShape* _pRealObject;
public:
    const char* ClassName() const override { return "FCSmartShapeCtrlPointAdjust"; }
 
    FCSmartShapeCtrlPointAdjust(__SSCTLPTADJ* pCtrlPointAdj, FCSmartShape* pReference) : __FCBase()
    {
        _pCtrlPointAdjust = pCtrlPointAdj;
        _pRealObject = pReference;
    }
 
    twobyte GetControlPoint1OffsetX() const { return _pCtrlPointAdjust->controlPoint1.x; }
 
    twobyte GetControlPoint1OffsetY() const { return _pCtrlPointAdjust->controlPoint1.y; }
 
    twobyte GetControlPoint2OffsetX() const { return _pCtrlPointAdjust->controlPoint2.x; }
 
    twobyte GetControlPoint2OffsetY() const { return _pCtrlPointAdjust->controlPoint2.y; }
 
    bool GetCustomShaped() const { return GetBitFlag(_pCtrlPointAdjust->flag, 0x4000); }
 
    
    void SetControlPoint1OffsetX(twobyte value)
    {
        _pCtrlPointAdjust->controlPoint1.x = value;
    }
 
    void SetControlPoint1OffsetY(twobyte value)
    {
        _pCtrlPointAdjust->controlPoint1.y = value;
    }
 
    void SetControlPoint2OffsetX(twobyte value)
    {
        _pCtrlPointAdjust->controlPoint2.x = value;
    }
 
    void SetControlPoint2OffsetY(twobyte value)
    {
        _pCtrlPointAdjust->controlPoint2.y = value;
    }
 
    void SetCustomShaped(bool flag)
    {
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x4000, flag);
    }
 
    void SetSlurShapeOver()
    {
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x0200, true);
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x0100, false);
    }
 
    void SetSlurShapeUnder()
    {
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x0200, false);
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x0100, true);
    }
 
    void SetSlurShapeUndetermined()
    {
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x0200, false);
        Set16BitFlag(&_pCtrlPointAdjust->flag, 0x0100, false);
    }
 
    void SetDefaultHairpinSize()
    {
        SetControlPoint1OffsetY(0);
        SetCustomShaped(false);
    }
 
    void SetDefaultSlurShape()
    {
        memset(_pCtrlPointAdjust, 0, sizeof(__SSCTLPTADJ));
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutInt("Control point 1 (x)", GetControlPoint1OffsetX());
        DebugOutInt("Control point 1 (y)", GetControlPoint1OffsetY());
        DebugOutInt("Control point 2 (x)", GetControlPoint2OffsetX());
        DebugOutInt("Control point 2 (y)", GetControlPoint2OffsetY());
        DebugOutHex("Flag (hex): ", _pCtrlPointAdjust->flag);
    }
#endif
};
 
class FCSmartShape : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTSmartShape _smartshape;
    FCSmartShapeSegment* _pTerminateSegmentLeft;
    FCSmartShapeSegment* _pTerminateSegmentRight;
    FCSmartShapeCtrlPointAdjust* _pCtrlPointAdjust;
    __FCCollection _CenterSmartShapes;
    
#ifdef PDK_FRAMEWORK_ENTRIES
    bool _RawRelink() override;
#endif //
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return __ot_SmartShape; }
    int DataSizeLoad() const override { return sizeof(__EDTSmartShape); }
    void* Allocate() override { return (void*) &_smartshape; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_smartshape, ((FCSmartShape*)pSource)->_GetSmartShape(), sizeof(_smartshape));
        _datablock = &_smartshape;
        _loadedsize = sizeof(_smartshape);
    }
 
    __FCBaseData* CreateObject() override
                { return new FCSmartShape(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum SMARTSHAPE_TYPES
    {
   SMARTSHAPE_SLURDOWN      = 0,
 
    /* Overslur (center humps up) */
   SMARTSHAPE_SLURUP        = 1,
 
   SMARTSHAPE_DIMINUENDO    = 2,
 
   SMARTSHAPE_CRESCENDO     = 3,
 
   SMARTSHAPE_OCTAVEDOWN    = 4,
 
   SMARTSHAPE_OCTAVEUP      = 5,
 
   SMARTSHAPE_DASHLINEUP    = 6,
        
   SMARTSHAPE_DASHLINEDOWN  = 7,
        
   SMARTSHAPE_DASHCURVEDOWN  = 8,
        
   SMARTSHAPE_DASHCURVEUP    = 9,
        
   SMARTSHAPE_DASHLINE      = 10,
        
   SMARTSHAPE_SOLIDLINE     = 11,
        
   SMARTSHAPE_SOLIDLINEDOWN = 12,
        
   SMARTSHAPE_SOLIDLINEUP      = 13,
        
   SMARTSHAPE_TRILL         = 14,
        
   SMARTSHAPE_SLURAUTO      = 15,
    
   SMARTSHAPE_DASHCURVEAUTO  = 16,
        
   SMARTSHAPE_TRILLEXT      = 17,
    
   SMARTSHAPE_SOLIDLINEDOWN2   = 18,
        
   SMARTSHAPE_SOLIDLINEUP2  = 19,
        
   SMARTSHAPE_TWOOCTAVEDOWN = 20,
 
   SMARTSHAPE_TWOOCTAVEUP = 21,
 
   SMARTSHAPE_DASHLINEDOWN2 = 22,
 
   SMARTSHAPE_DASHLINEUP2      = 23,
 
   SMARTSHAPE_GLISSANDO      = 25,
 
   SMARTSHAPE_TABSLIDE       = 26,
 
   SMARTSHAPE_BEND_HAT            = 27,
 
   SMARTSHAPE_BEND_CURVE          = 28,
 
   SMARTSHAPE_CUSTOM           = 29,
 
   SMARTSHAPE_SOLIDLINEUPLEFT     = 30,
        
   SMARTSHAPE_SOLIDLINEDOWNLEFT   = 31,
        
   SMARTSHAPE_DASHLINEUPLEFT      = 32,
        
   SMARTSHAPE_DASHLINEDOWNLEFT    = 33,
        
   SMARTSHAPE_SOLIDLINEUPDOWN     = 34,
        
   SMARTSHAPE_SOLIDLINEDOWNUP     = 35,
        
   SMARTSHAPE_DASHLINEUPDOWN      = 36,
        
   SMARTSHAPE_DASHLINEDOWNUP      = 37,
        
   SMARTSHAPE_HYPHEN               = 38,
        
   SMARTSHAPE_WORD_EXT             = 39,
        
    SMARTSHAPE_DASHEDSLURDOWN  = 40,
    
    SMARTSHAPE_DASHEDSLURUP  = 41,
        
    SMARTSHAPE_DASHEDSLURAUTO = 42
    };
 
 
    enum SMARTSHAPE_3STATE
    {
        SS_OFFSTATE = 0,
        
        SS_ONSTATE,
        
        SS_AUTOSTATE        
    };
 
    const char* ClassName() const override { return "FCSmartShape"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SMARTSHAPE; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetSmartShape() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSmartShape() : __FCNoInciOther()
    {
        _pTerminateSegmentLeft = NULL;
        _pTerminateSegmentRight = NULL;
        _pCtrlPointAdjust = NULL;
 
        /* SOME of the _smartshape data is auto-initialized, but not these: */
        _smartshape.shapeType = 0;
        _smartshape.flag = __SS_PUSHENDSTART;
        _smartshape.ssLineStyleID = 0;
        _smartshape.flag2 = 0;
       
        _datablock = &_smartshape; 
        _loadedsize = sizeof(_smartshape);
    }
 
    virtual ~FCSmartShape()
    {
        delete _pTerminateSegmentLeft;
        delete _pTerminateSegmentRight;
        delete _pCtrlPointAdjust;
    }
 
    twobyte _GetLeftSideNoteID() const { return _smartshape.noteID[0]; }
 
    twobyte _GetRightSideNoteID() const { return _smartshape.noteID[1]; }
 
    void _SetLeftSideNoteID(twobyte noteID) { _smartshape.noteID[0] = noteID; }
    
    void _SetRightSideNoteID(twobyte noteID) { _smartshape.noteID[1] = noteID; }
    
    void _LoadCenterShapes();
 
    void _ClearCenterShapes() { _CenterSmartShapes.ClearAll(); }
 
    bool CalcLeftCellMetricPos(FCPoint* pPoint);
 
    bool CalcRightCellMetricPos(FCPoint* pPoint);
 
#ifdef PDK_FRAMEWORK_ENTRIES
    bool CalcLeftEntryMetricPos(FCNoteEntry* pEntry, FCPoint* pPoint);
#endif //PDK_FRAMEWORK_ENTRIES
 
#ifdef PDK_FRAMEWORK_ENTRIES
    bool CalcRightEntryMetricPos(FCNoteEntry* pEntry, FCPoint* pPoint);
#endif
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SMARTSHAPE_TYPES
#else
    int
#endif
    GetShapeType() const { return (SMARTSHAPE_TYPES) _smartshape.shapeType; }
 
    bool GetEntryBased() const { return GetBitFlag(_smartshape.flag, __SS_ENTRYBASED); }
 
    bool CalcLyricBased() const;
 
    bool GetPresetShape() const
    {
        return GetBitFlag(_smartshape.flag, __SS_PRESETSHAPE);
    }
 
    FCSmartShapeSegment* GetTerminateSegmentLeft()
    {
        if (!_pTerminateSegmentLeft)
            _pTerminateSegmentLeft = new FCSmartShapeSegment(&_smartshape.termSeg1, this, true);
        return _pTerminateSegmentLeft;
    }
 
    FCSmartShapeSegment* GetTerminateSegmentRight()
    {
        if (!_pTerminateSegmentRight)
            _pTerminateSegmentRight = new FCSmartShapeSegment(&_smartshape.termSeg2, this, false);
        return _pTerminateSegmentRight;
    }
 
    FCSmartShapeCtrlPointAdjust* GetCtrlPointAdjust()
    {
        if (!_pCtrlPointAdjust)
            _pCtrlPointAdjust = new FCSmartShapeCtrlPointAdjust(&_smartshape.fullCtlPtAdj, this);
        return _pCtrlPointAdjust;
    }
 
    bool GetMakeHorizontal() const { return GetBitFlag(_smartshape.flag, __SS_MAKEHORZ); }
 
    bool GetMaintainAngle() const { return GetBitFlag(_smartshape.flag, 0x00000001); }
 
    bool GetVisible() const { return !GetBitFlag(_smartshape.flag2, 0x0001); }
 
    twobyte GetLineID() const { return _smartshape.ssLineStyleID; }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SMARTSHAPE_3STATE
#else
    int
#endif
    GetEngraverSlur() const
    {
        if (GetBitFlag(_smartshape.flag, 0x10))
            return SS_ONSTATE;
        else if (GetBitFlag(_smartshape.flag, 0x20))
            return SS_OFFSTATE;
        else
            return SS_AUTOSTATE;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SMARTSHAPE_3STATE
#else
    int
#endif
    GetAvoidAccidentals() const
    {
        if (GetBitFlag(_smartshape.flag, 0x04))
            return SS_ONSTATE;
        else if (GetBitFlag(_smartshape.flag, 0x08))
            return SS_OFFSTATE;
        else
            return SS_AUTOSTATE;
    }
 
    void SetShapeType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SMARTSHAPE_TYPES
#else
    int
#endif
    shapevalue) { _smartshape.shapeType = shapevalue; }
 
    void SetPresetShape(bool value)
    {
        Set32BitFlag(&_smartshape.flag, __SS_PRESETSHAPE, value);
    }
 
    void SetLineID(twobyte identifier) { _smartshape.ssLineStyleID = identifier; }
 
    void SetMakeHorizontal(bool state) { Set32BitFlag(&_smartshape.flag, __SS_MAKEHORZ, state); }
 
    void SetMaintainAngle(bool state) { Set32BitFlag(&_smartshape.flag, 0x00000001, state); }
 
    void SetVisible(bool visible) { Set16BitFlag(&_smartshape.flag2, 0x0001, !visible); }
 
    void SetEntryBased(bool value) { Set32BitFlag(&_smartshape.flag, __SS_ENTRYBASED, value); }
 
    void SetSlurFlags(bool entrybased)
    {
        SetEntryBased(entrybased);
        Set32BitFlag(&_smartshape.flag, __SS_ROTATE, true);
        Set32BitFlag(&_smartshape.flag, __SS_PRESETSHAPE, true);
        Set32BitFlag(&_smartshape.flag, __SS_PUSHENDSTART, true);
        SetMaintainAngle(true);
 
        Set32BitFlag(&_smartshape.flag, __SS_LYRICBASED, false);
        Set32BitFlag(&_smartshape.flag, __SS_MAKEHORZ, false);
        Set32BitFlag(&_smartshape.flag, __SS_MAKEVERT, false);
    }
 
    void SetHairpinFlags()
    {
        SetMeasureAttachedFlags(true, true);
    }
 
    void SetEntryAttachedFlags(bool presetshape)
    {
        SetEntryBased(true);
        Set32BitFlag(&_smartshape.flag, __SS_ROTATE, true);
        Set32BitFlag(&_smartshape.flag, __SS_PRESETSHAPE, presetshape);
        Set32BitFlag(&_smartshape.flag, __SS_PUSHENDSTART, true);
        SetMaintainAngle(true);
 
        Set32BitFlag(&_smartshape.flag, __SS_LYRICBASED, false);
        Set32BitFlag(&_smartshape.flag, __SS_MAKEHORZ, false);
        Set32BitFlag(&_smartshape.flag, __SS_MAKEVERT, false);
    }
 
    void SetMeasureAttachedFlags(bool presetshape, bool makehorizontal);
    
    void SetBeatAttached(bool state);
 
    bool GetBeatAttached() const;
 
    void SetEngraverSlur(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SMARTSHAPE_3STATE
#else
    int
#endif
    state
    )
    {
        switch (state)
        {
            case SS_AUTOSTATE:
                Set32BitFlag(&_smartshape.flag, 0x20, false);
                Set32BitFlag(&_smartshape.flag, 0x10, false);
                break;
            case SS_ONSTATE:
                Set32BitFlag(&_smartshape.flag, 0x20, false);
                Set32BitFlag(&_smartshape.flag, 0x10, true);
                break;
            case SS_OFFSTATE:
                Set32BitFlag(&_smartshape.flag, 0x20, true);
                Set32BitFlag(&_smartshape.flag, 0x10, false);
                break;
        }
    }
 
    void SetAvoidAccidentals(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SMARTSHAPE_3STATE
#else
    int
#endif
    state
    )
    {
        switch (state)
        {
            case SS_AUTOSTATE:
                Set32BitFlag(&_smartshape.flag, 0x08, false);
                Set32BitFlag(&_smartshape.flag, 0x04, false);
                break;
            case SS_ONSTATE:
                Set32BitFlag(&_smartshape.flag, 0x08, false);
                Set32BitFlag(&_smartshape.flag, 0x04, true);
                break;
            case SS_OFFSTATE:
                Set32BitFlag(&_smartshape.flag, 0x08, true);
                Set32BitFlag(&_smartshape.flag, 0x04, false);
                break;
        }
    }
 
    bool IsHairpin() { return ((GetShapeType() == SMARTSHAPE_CRESCENDO)
            || (GetShapeType() == SMARTSHAPE_DIMINUENDO)); }
 
    bool IsAutoSlur()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_SLURAUTO:
            case SMARTSHAPE_DASHCURVEAUTO:
            case SMARTSHAPE_DASHEDSLURAUTO:  /* Finale 25 */
                return true;
            default:
                return false;
        }
    }
 
    bool IsOverSlur()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_SLURUP:
            case SMARTSHAPE_DASHCURVEUP:
            case SMARTSHAPE_DASHEDSLURUP:  /* Finale 25 */
                return true;
            default:
                return false;
        }
    }
 
    bool IsUnderSlur()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_SLURDOWN:
            case SMARTSHAPE_DASHCURVEDOWN:
            case SMARTSHAPE_DASHEDSLURDOWN:   /* Finale 25 */
                return true;
            default:
                return false;
        }
    }
 
    bool IsTwoHooks()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_SOLIDLINEDOWN2:
            case SMARTSHAPE_SOLIDLINEUP2:
            case SMARTSHAPE_DASHLINEDOWN2:
            case SMARTSHAPE_DASHLINEUP2:
                return true;
            default:
                return false;
        }
    }
 
    bool IsSlur()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_SLURDOWN:
            case SMARTSHAPE_SLURUP:
            case SMARTSHAPE_SLURAUTO:
            case SMARTSHAPE_DASHCURVEAUTO:
            case SMARTSHAPE_DASHCURVEDOWN:
            case SMARTSHAPE_DASHCURVEUP:
            case SMARTSHAPE_DASHEDSLURAUTO:
            case SMARTSHAPE_DASHEDSLURDOWN:
            case SMARTSHAPE_DASHEDSLURUP:
                return true;
            default:
                return false;
        }
    }
 
    bool IsSolidSlur()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_SLURDOWN:
            case SMARTSHAPE_SLURUP:
            case SMARTSHAPE_SLURAUTO:
                return true;
            default:
                return false;
        }
    }
 
    bool IsDashedCurve()
    {
        switch (GetShapeType())
        {
            case SMARTSHAPE_DASHCURVEAUTO:
            case SMARTSHAPE_DASHCURVEDOWN:
            case SMARTSHAPE_DASHCURVEUP:
                return true;
            default:
                return false;
        }
    }
    
    bool IsDashedSlur()
    {
#if FXT_VERSION >= FINALEVERSION_25
        switch (GetShapeType())
        {
            case SMARTSHAPE_DASHEDSLURAUTO:
            case SMARTSHAPE_DASHEDSLURDOWN:
            case SMARTSHAPE_DASHEDSLURUP:
                return true;
            default:
                return false;
        }
#else
        return false;
#endif
    }
 
    bool IsTabSlide()
    {
        return (GetShapeType() == SMARTSHAPE_TABSLIDE);
    }
 
    bool IsGlissando()
    {
        return (GetShapeType() == SMARTSHAPE_GLISSANDO);
    }
 
    bool IsCustomLine()
    {
        return (GetShapeType() == SMARTSHAPE_CUSTOM);
    }
 
    bool IsEntryBased() { return GetBitFlag(_smartshape.flag, __SS_ENTRYBASED); }
 
    bool IsWithinRegion(FCMusicRegion* pRegion);
 
#ifdef PDK_FRAMEWORK_ENTRIES
    void DeleteEverything();
#endif //PDK_FRAMEWORK_ENTRIES
 
    void AssignToStaff(int newstaff);
 
    bool SaveNew() override;
 
#ifdef PDK_FRAMEWORK_ENTRIES
    bool SaveNewEverything(FCNoteEntry* pFirstEntry = NULL, FCNoteEntry* pLastEntry = NULL);
#endif //#ifdef PDK_FRAMEWORK_ENTRIES
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Shape Type: ", GetShapeType());
        DebugOutInt("Line ID: ", GetLineID());
 
        DebugOut("= Terminate segment 1 =");
        FCSmartShapeSegment* pSeg1 = GetTerminateSegmentLeft();
        pSeg1->DebugDump();
 
        DebugOut("= Terminate segment 2 =");
        FCSmartShapeSegment* pSeg2 = GetTerminateSegmentRight();
        pSeg2->DebugDump();
 
        DebugOut("Ctrl Point adjust:");
        FCSmartShapeCtrlPointAdjust* pCtrlPointAdjust = GetCtrlPointAdjust();
        pCtrlPointAdjust->DebugDump();
        //DebugOutBlock(&_smartshape.fullCtlPtAdj, sizeof(_smartshape.fullCtlPtAdj));
 
        DebugOut("= Center Smart Shapes =");
        _CenterSmartShapes.DebugDump();
 
        DebugOutHex("flag: ", _smartshape.flag);
        DebugOutHex("flag2: ", _smartshape.flag2);        
    }
#endif
};
 
 
class FCCustomSmartLineDef : public __FCNoInciOther
{
public:
    enum TEXT_REFERENCE {
        TEXTREF_LEFTSTART = 0,
        TEXTREF_LEFTCONTINUATION,
        TEXTREF_RIGHTEND,
        TEXTREF_CENTERFULL,
        TEXTREF_CENTERABBREVIATED
    };
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTCustomLineDefinition _customsmartlinedef;
    EDTCustomLineDefinition2012 _customsmartlinedef2012;
    bool _use2012version;  /* This is set in constructor, if running version
                            * is 2012 or above */
 
protected:    
    EXTAG Tag() const override
    {
        if (_use2012version)
            return ot_CustomLineDefinition2012;
        else
            return ot_CustomLineDefinition;
    }
    int DataSizeLoad() const override {
        return _use2012version ? sizeof(_customsmartlinedef2012) : sizeof(_customsmartlinedef);
    }
    void* Allocate() override { return _GetCustomSmartLineDef(); }
    EVERSION EnigmaVersion() const override { return _use2012version ? FINALEVERSION_2012 : FINALEVERSION_2010; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetCustomSmartLineDef(), ((FCCustomSmartLineDef*)pSource)->_GetCustomSmartLineDef(), DataSizeLoad());
        _datablock = _GetCustomSmartLineDef();
        _loadedsize = DataSizeLoad();
    }
 
    void _SetRawStringNumber
    (
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_REFERENCE
#else
    int
#endif
    reference, twobyte value)
    {
        twobyte* pRawtextnumber = NULL;
        switch (reference)
        {
            case TEXTREF_LEFTSTART:
                pRawtextnumber = _use2012version ? &_customsmartlinedef2012.leftStartTextID : &_customsmartlinedef.leftStartTextID;
                break;
            case TEXTREF_LEFTCONTINUATION:
                pRawtextnumber = _use2012version ? &_customsmartlinedef2012.leftContTextID : &_customsmartlinedef.leftContTextID;
                break;
            case TEXTREF_RIGHTEND:
                pRawtextnumber = _use2012version ? &_customsmartlinedef2012.rightEndTextID : &_customsmartlinedef.rightEndTextID;
                break;
            case TEXTREF_CENTERFULL:
                pRawtextnumber = _use2012version ? &_customsmartlinedef2012.centerFullTextID : &_customsmartlinedef.centerFullTextID;
                break;
            case TEXTREF_CENTERABBREVIATED:
                pRawtextnumber = _use2012version ? &_customsmartlinedef2012.centerAbbrTextID : &_customsmartlinedef.centerAbbrTextID;
                break;
        }
        if (pRawtextnumber) *pRawtextnumber = value;
    }
 
    __FCBaseData* CreateObject() override { return new FCCustomSmartLineDef(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCustomSmartLineDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CUSTOMSMARTLINEDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetCustomSmartLineDef() { return _use2012version ? (void*) &_customsmartlinedef2012 : (void*) &_customsmartlinedef; }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    
    FCCustomSmartLineDef();
 
 
    bool DeepDeleteData() override;
 
    twobyte GetRawStringNumber
    (
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_REFERENCE
#else
    int
#endif
    reference)
    {
        twobyte rawtextnumber = 0;
        switch (reference)
        {
            case TEXTREF_LEFTSTART:
                rawtextnumber = _use2012version ? _customsmartlinedef2012.leftStartTextID : _customsmartlinedef.leftStartTextID;
                break;
            case TEXTREF_LEFTCONTINUATION:
                rawtextnumber = _use2012version ? _customsmartlinedef2012.leftContTextID : _customsmartlinedef.leftContTextID;
                break;
            case TEXTREF_RIGHTEND:
                rawtextnumber = _use2012version ? _customsmartlinedef2012.rightEndTextID : _customsmartlinedef.rightEndTextID;
                break;
            case TEXTREF_CENTERFULL:
                rawtextnumber = _use2012version ? _customsmartlinedef2012.centerFullTextID : _customsmartlinedef.centerFullTextID;
                break;
            case TEXTREF_CENTERABBREVIATED:
                rawtextnumber = _use2012version ? _customsmartlinedef2012.centerAbbrTextID : _customsmartlinedef.centerAbbrTextID;
                break;
        }
        return rawtextnumber;
    }
   
    Evpu16 GetHorizontalTextPos
    (
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REFERENCE
#else
     int
#endif
     reference)
    {
        twobyte position = 0;
        switch (reference)
        {
            case TEXTREF_LEFTSTART:
                position = _use2012version ? _customsmartlinedef2012.leftStartTextHoriz : _customsmartlinedef.leftStartTextHoriz;
                break;
            case TEXTREF_LEFTCONTINUATION:
                position = _use2012version ? _customsmartlinedef2012.leftContTextHoriz : _customsmartlinedef.leftContTextHoriz;
                break;
            case TEXTREF_RIGHTEND:
                position = _use2012version ? _customsmartlinedef2012.rightEndTextHoriz : _customsmartlinedef.rightEndTextHoriz;
                break;
            case TEXTREF_CENTERFULL:
                position = _use2012version ? _customsmartlinedef2012.centerFullTextHoriz : _customsmartlinedef.centerFullTextHoriz;
                break;
            case TEXTREF_CENTERABBREVIATED:
                position = _use2012version ? _customsmartlinedef2012.centerAbbrTextHoriz : _customsmartlinedef.centerAbbrTextHoriz;
                break;
        }
        return position;
    }
 
    
    Evpu16 GetVerticalTextPos
    (
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REFERENCE
#else
     int
#endif
     reference)
    {
        twobyte position = 0;
        switch (reference)
        {
            case TEXTREF_LEFTSTART:
                position = _use2012version ? _customsmartlinedef2012.leftStartTextVert : _customsmartlinedef.leftStartTextVert;
                break;
            case TEXTREF_LEFTCONTINUATION:
                position = _use2012version ? _customsmartlinedef2012.leftContTextVert : _customsmartlinedef.leftContTextVert;
                break;
            case TEXTREF_RIGHTEND:
                position = _use2012version ? _customsmartlinedef2012.rightEndTextVert : _customsmartlinedef.rightEndTextVert;
                break;
            case TEXTREF_CENTERFULL:
                position = _use2012version ? _customsmartlinedef2012.centerFullTextVert : _customsmartlinedef.centerFullTextVert;
                break;
            case TEXTREF_CENTERABBREVIATED:
                position = _use2012version ? _customsmartlinedef2012.centerAbbrTextVert : _customsmartlinedef.centerAbbrTextVert;
                break;
        }
        return position;
    }
    
    
    void SetHorizontalTextPos
    (
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REFERENCE
#else
     int
#endif
     reference,
     Evpu16 position)
    {
        Evpu16* pPosition = NULL;
        switch (reference)
        {
            case TEXTREF_LEFTSTART:
                pPosition = _use2012version ? &_customsmartlinedef2012.leftStartTextHoriz : &_customsmartlinedef.leftStartTextHoriz;
                break;
            case TEXTREF_LEFTCONTINUATION:
                pPosition = _use2012version ? &_customsmartlinedef2012.leftContTextHoriz : &_customsmartlinedef.leftContTextHoriz;
                break;
            case TEXTREF_RIGHTEND:
                pPosition = _use2012version ? &_customsmartlinedef2012.rightEndTextHoriz : &_customsmartlinedef.rightEndTextHoriz;
                break;
            case TEXTREF_CENTERFULL:
                pPosition = _use2012version ? &_customsmartlinedef2012.centerFullTextHoriz : &_customsmartlinedef.centerFullTextHoriz;
                break;
            case TEXTREF_CENTERABBREVIATED:
                pPosition = _use2012version ? &_customsmartlinedef2012.centerAbbrTextHoriz : &_customsmartlinedef.centerAbbrTextHoriz;
                break;
        }
        if (pPosition) *pPosition = position;
    }
    
    void SetVerticalTextPos
    (
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REFERENCE
#else
     int
#endif
     reference,
     Evpu16 position)
    {
        Evpu16* pPosition = NULL;
        switch (reference)
        {
            case TEXTREF_LEFTSTART:
                pPosition = _use2012version ? &_customsmartlinedef2012.leftStartTextVert : &_customsmartlinedef.leftStartTextVert;
                break;
            case TEXTREF_LEFTCONTINUATION:
                pPosition = _use2012version ? &_customsmartlinedef2012.leftContTextVert : &_customsmartlinedef.leftContTextVert;
                break;
            case TEXTREF_RIGHTEND:
                pPosition = _use2012version ? &_customsmartlinedef2012.rightEndTextVert : &_customsmartlinedef.rightEndTextVert;
                break;
            case TEXTREF_CENTERFULL:
                pPosition = _use2012version ? &_customsmartlinedef2012.centerFullTextVert : &_customsmartlinedef.centerFullTextVert;
                break;
            case TEXTREF_CENTERABBREVIATED:
                pPosition = _use2012version ? &_customsmartlinedef2012.centerAbbrTextVert : &_customsmartlinedef.centerAbbrTextVert;
                break;
        }
        if (pPosition) *pPosition = position;
    }
 
    twobyte GetLineStyle() const
    {
        return _use2012version ? _customsmartlinedef2012.linetype : _customsmartlinedef.linetype;
    }
    
    Efix16 GetLineWidth() const
    {
        switch (GetLineStyle())
        {
            case CUSTOMLINE_SOLID:
                return _use2012version ? _customsmartlinedef2012.linedata.solid.lineWidth : _customsmartlinedef.linetypeinfo;
            case CUSTOMLINE_DASHED:
                return _use2012version ? _customsmartlinedef2012.linedata.dashed.lineWidth : _customsmartlinedef.linetypeinfo;
        }
        return 0;
    }
 
    twobyte GetStartArrowheadStyle() const
    {
        return _use2012version ? _customsmartlinedef2012.endpointstylestart : _customsmartlinedef.endpointstylestart;
    }
 
    twobyte GetEndArrowheadStyle() const
    {
        return _use2012version ? _customsmartlinedef2012.endpointstyleend : _customsmartlinedef.endpointstyleend;
    }
 
    twobyte GetStartArrowheadShapeID() const
    {
        if (GetStartArrowheadStyle()!= CLENDPOINT_CUSTOM) return 0;
        return _use2012version ? _customsmartlinedef2012.startPointData : _customsmartlinedef.startarrowdataLo;
    }
 
    twobyte GetEndArrowheadShapeID() const
    {
        if (GetEndArrowheadStyle()!= CLENDPOINT_CUSTOM) return 0;
        return _use2012version ? _customsmartlinedef2012.endPointData : _customsmartlinedef.endarrowdataLo;
    }
 
    eUniChar32 GetLineCharacter() const
    {
        if (GetLineStyle() != CUSTOMLINE_CHARACTER) return 0;
        return _use2012version ? _customsmartlinedef2012.linedata.character.lineChar : _customsmartlinedef.linetypeinfo;
    }
    
    FCString* CreateTextString(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_REFERENCE
#else
    int
#endif
    reference)
    {
        twobyte rawtextnumber = GetRawStringNumber(reference);
        if (!rawtextnumber) return NULL;
        FCRawText rawtext;
        rawtext.SetCustomTag(tx_SmartShape);
        if (!rawtext.Load(rawtextnumber)) return NULL;
        return rawtext.CreateString();
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTextString_GC(int reference)
    { return makeLuaSharedPtr(CreateTextString(reference)); }
#endif
 
    bool SaveTextString(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_REFERENCE
#else
    int
#endif
    reference, FCString* pString)
    {
        twobyte rawtextnumber = GetRawStringNumber(reference);
        if (!rawtextnumber) return false;
        FCRawText rawtext;
        rawtext.SetCustomTag(tx_SmartShape);
        rawtext.SetText(pString);
        return rawtext.SaveAs(rawtextnumber);
    }
 
    bool SaveNewTextString(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_REFERENCE
#else
    int
#endif
    reference, FCString* pString)
    {
        if (!pString) return false;        
        FCRawText rawtext;
        rawtext.SetCustomTag(tx_SmartShape);
        rawtext.SetText(pString);
        if (rawtext.SaveNew())
        {
            _SetRawStringNumber(reference, rawtext.GetItemNo());
            return true;
        }
        return false;
    }
 
 
    twobyte GetLineCharacterBaselineShift() const
    {
        if (GetLineStyle() != CUSTOMLINE_CHARACTER) return 0;
        if (_use2012version)
        {
            return _customsmartlinedef2012.linedata.character.baselineShiftEMs;
        }
        else
        {
            return 0;
        }
    }
 
    void SetLineCharacterBaselineShift(twobyte baseline)
    {
        if (GetLineStyle() != CUSTOMLINE_CHARACTER) return;
        if (_use2012version)
        {
            _customsmartlinedef2012.linedata.character.baselineShiftEMs = baseline;
        }
        else
        {
            /* Nothing yet */
        }
    }
 
    void GetLineCharacterFontInfo(FCFontInfo* pFontInfo)
    {
        if (!pFontInfo) return;
        if (GetLineStyle() != CUSTOMLINE_CHARACTER) return;
        if (_use2012version)
        {
            pFontInfo->SetNameByID(_customsmartlinedef2012.linedata.character.font);
            pFontInfo->SetSize(_customsmartlinedef2012.linedata.character.size);
            pFontInfo->SetEnigmaStyles(_customsmartlinedef2012.linedata.character.efx);
        }
        else
        {
            pFontInfo->SetNameByID(_customsmartlinedef.fontID_length);
            pFontInfo->SetSize(_customsmartlinedef.fontsize_space);
            pFontInfo->SetEnigmaStyles(_customsmartlinedef.efx);
        }
    }
 
    void SetLineCharacterFontInfo(FCFontInfo* pFontInfo)
    {
        if (!pFontInfo) return;
        if (GetLineStyle() != CUSTOMLINE_CHARACTER) return;
        if (_use2012version)
        {
            _customsmartlinedef2012.linedata.character.font = pFontInfo->GetIDByName();
            _customsmartlinedef2012.linedata.character.size = pFontInfo->GetSize();
            _customsmartlinedef2012.linedata.character.efx = pFontInfo->GetEnigmaStyles();
        }
        else
        {
            _customsmartlinedef.fontID_length = pFontInfo->GetIDByName();
            _customsmartlinedef.fontsize_space = pFontInfo->GetSize();
            _customsmartlinedef.efx = pFontInfo->GetEnigmaStyles();
        }
    }
 
    bool GetHorizontal() const
    {
        if (_use2012version)
            return GetBitFlag(_customsmartlinedef2012.flag, SL_HORIZONTAL);
        else
            return GetBitFlag(_customsmartlinedef.efx, SL_HORIZONTAL);
    }
 
    void SetHorizontal(bool state)
    {
        if (_use2012version)
            Set16BitFlag(&_customsmartlinedef2012.flag, SL_HORIZONTAL, state);
        else
            Set16BitFlag(&_customsmartlinedef.efx, SL_HORIZONTAL, state);
    }
    
    bool GetUseAfterStartTextOffset() const
    {
        if (_use2012version)
            return GetBitFlag(_customsmartlinedef2012.flag, SL_LINEADJUST_STARTHORIZ);
        else
            return GetBitFlag(_customsmartlinedef.efx, SL_LINEADJUST_STARTHORIZ);
    }
 
    void SetUseAfterStartTextOffset(bool state)
    {
        if (_use2012version)
            Set16BitFlag(&_customsmartlinedef2012.flag, SL_LINEADJUST_STARTHORIZ, state);
        else
            Set16BitFlag(&_customsmartlinedef.efx, SL_LINEADJUST_STARTHORIZ, state);
    }
 
    Evpu16 GetStartLineHorizontalOffset() const
    {
        return _use2012version ? _customsmartlinedef2012.lineadjustStartHoriz : _customsmartlinedef.lineadjustStartHoriz;
    }
 
    void SetStartLineHorizontalOffset(Evpu16 value)
    {
        if (_use2012version)
            _customsmartlinedef2012.lineadjustStartHoriz = value;
        else
            _customsmartlinedef.lineadjustStartHoriz = value;
    }
    
    bool GetUseBeforeEndTextOffset() const
    {
        if (_use2012version)
            return GetBitFlag(_customsmartlinedef2012.flag, SL_LINEADJUST_ENDHORIZ);
        else
            return GetBitFlag(_customsmartlinedef.efx, SL_LINEADJUST_ENDHORIZ);
    }
 
    void SetUseBeforeEndTextOffset(bool state)
    {
        if (_use2012version)
            Set16BitFlag(&_customsmartlinedef2012.flag, SL_LINEADJUST_ENDHORIZ, state);
        else
            Set16BitFlag(&_customsmartlinedef.efx, SL_LINEADJUST_ENDHORIZ, state);
    }
 
    Evpu16 GetEndLineHorizontalOffset() const
    {
        return _use2012version ? _customsmartlinedef2012.lineadjustEndHoriz : _customsmartlinedef.lineadjustEndHoriz;
    }
 
    void SetEndLineHorizontalOffset(Evpu16 value)
    {
        if (_use2012version)
            _customsmartlinedef2012.lineadjustEndHoriz = value;
        else
            _customsmartlinedef.lineadjustEndHoriz = value;
    }
    
    bool GetUseAfterContinuationTextOffset() const
    {
        if (_use2012version)
            return GetBitFlag(_customsmartlinedef2012.flag, SL_LINEADJUST_CONTHORIZ);
        else
            return GetBitFlag(_customsmartlinedef.efx, SL_LINEADJUST_CONTHORIZ);
    }
 
    void SetUseAfterContinuationTextOffset(bool state)
    {
        if (_use2012version)
            Set16BitFlag(&_customsmartlinedef2012.flag, SL_LINEADJUST_CONTHORIZ, state);
        else
            Set16BitFlag(&_customsmartlinedef.efx, SL_LINEADJUST_CONTHORIZ, state);
    }
    
    Evpu16 GetContinuationLineHorizontalOffset() const
    {
        return _use2012version ? _customsmartlinedef2012.lineadjustContinueHoriz : _customsmartlinedef.lineadjustContinueHoriz;
    }
 
    void SetContinuationLineHorizontalOffset(Evpu16 value)
    {
        if (_use2012version)
            _customsmartlinedef2012.lineadjustContinueHoriz = value;
        else
            _customsmartlinedef.lineadjustContinueHoriz = value;
    }
    
    Evpu16 GetLineVerticalOffset() const
    {
        /* start and end are always the same, so return the start. */
        return _use2012version ? _customsmartlinedef2012.lineadjustStartVert : _customsmartlinedef.lineadjustStartVert;
    }
 
    void SetLineVerticalOffset(Evpu16 value)
    {
        /* Since the UI only supports one value, set both. */
        if (_use2012version)
        {
            _customsmartlinedef2012.lineadjustStartVert = value;
            _customsmartlinedef2012.lineadjustEndVert = value;
        }
        else
        {
            _customsmartlinedef.lineadjustStartVert = value;
            _customsmartlinedef.lineadjustEndVert = value;
        }
    }
 
    void SetLineStyle(twobyte value)
    {
        switch (value)
        {
            case CUSTOMLINE_SOLID:
            case CUSTOMLINE_DASHED:
            case CUSTOMLINE_CHARACTER:
                break;
            default:
                return;
        }
        if (_use2012version)
            _customsmartlinedef2012.linetype = value;
        else
            _customsmartlinedef.linetype = value;
    }
 
    void SetLineWidth(Efix16 value)
    {
        switch (GetLineStyle())
        {
            case CUSTOMLINE_SOLID:
                if (_use2012version)
                    _customsmartlinedef2012.linedata.solid.lineWidth = value;
                else
                    _customsmartlinedef.linetypeinfo = value;
                break;
            case CUSTOMLINE_DASHED:
                if (_use2012version)
                    _customsmartlinedef2012.linedata.dashed.lineWidth = value;
                else
                    _customsmartlinedef.linetypeinfo = value;
                break;
        }
    }
 
 
    Efix16 GetLineDashLength() const
    {
        if (GetLineStyle() != CUSTOMLINE_DASHED) return 0;
        if (_use2012version)
            return _customsmartlinedef2012.linedata.dashed.dashOn;
        else
        {
            /* Nothing yet */
            return 0;
        }
        return 0;
    }
 
    void SetLineDashLength(Efix16 value)
    {
        if (GetLineStyle() != CUSTOMLINE_DASHED) return;
        if (_use2012version)
            _customsmartlinedef2012.linedata.dashed.dashOn = value;
        else
        {
            /* Nothing yet */
        }        
    }
 
    Efix16 GetLineDashSpace() const
    {
        if (GetLineStyle() != CUSTOMLINE_DASHED) return 0;
        if (_use2012version)
            return _customsmartlinedef2012.linedata.dashed.dashOff;
        else
        {
            /* Nothing yet */
        }
        return 0;
    }
 
    void SetLineDashSpace(Efix16 value)
    {
        if (GetLineStyle() != CUSTOMLINE_DASHED) return;
        if (_use2012version)
            _customsmartlinedef2012.linedata.dashed.dashOff = value;
        else
        {
        }
    }
    
    void SetStartArrowheadStyle(twobyte value)
    {
        switch (value)
        {
            case CLENDPOINT_NONE:
            case CLENDPOINT_PRESET:
            case CLENDPOINT_CUSTOM:
            case CLENDPOINT_HOOK:
                break;
            default:
                return;
        }
 
        if (_use2012version)
            _customsmartlinedef2012.endpointstylestart = value;
        else
            _customsmartlinedef.endpointstylestart = value;
    }
 
    void SetStartArrowheadShapeID(twobyte shapeID)
    {
        if (_use2012version)
            _customsmartlinedef2012.startPointData = shapeID;
        else
            _customsmartlinedef.startarrowdataLo = shapeID;
    }
 
    void SetEndArrowheadStyle(twobyte value)
    {
        switch (value)
        {
            case CLENDPOINT_NONE:
            case CLENDPOINT_PRESET:
            case CLENDPOINT_CUSTOM:
            case CLENDPOINT_HOOK:
                break;
            default:
                return;
        }
        if (_use2012version)
            _customsmartlinedef2012.endpointstyleend = value;
        else
            _customsmartlinedef.endpointstyleend = value;
    }
 
    Efix16 GetStartHookLength() const
    {
        if (GetStartArrowheadStyle() != CLENDPOINT_HOOK) return 0;
        if (_use2012version)
            return _customsmartlinedef2012.startPointData;
        else
        {
            /* Nothing yet */
        }
        return 0;
    }
 
    void SetStartHookLength(Efix16 value)
    {
        if (GetStartArrowheadStyle() != CLENDPOINT_HOOK) return;
        if (_use2012version)
            _customsmartlinedef2012.startPointData = value;
        else
        {
            /* Nothing yet */
        }
    }
 
    Efix16 GetEndHookLength() const
    {
        if (GetEndArrowheadStyle() != CLENDPOINT_HOOK) return 0;
        if (_use2012version)
            return _customsmartlinedef2012.endPointData;
        else
        {
            /* Nothing yet */
        }
        return 0;
    }
 
    void SetEndHookLength(Efix16 value)
    {
        if (GetEndArrowheadStyle() != CLENDPOINT_HOOK) return;
        if (_use2012version)
            _customsmartlinedef2012.endPointData = value;
        else
        {
            /* Nothing yet */
        }
    }
 
    void SetEndArrowheadShapeID(twobyte shapeID)
    {
        if (_use2012version)
            _customsmartlinedef2012.endPointData = shapeID;
        else
            _customsmartlinedef.endarrowdataLo = shapeID;
    }
 
    void SetLineCharacter(eUniChar32 character)
    {
        if (GetLineStyle() != CUSTOMLINE_CHARACTER) return;
        if (_use2012version)
            _customsmartlinedef2012.linedata.character.lineChar = character;
        else
            _customsmartlinedef.linetypeinfo = character;
    }        
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
    }
#endif
 
};
 
 
 
class FCSmartShapeMeasureMarks : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCSmartShapeMeasureMark(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCSmartShapeMeasureMarks() : __FCCollectionInciOther() {}
 
    const char* ClassName() const override { return "FCSmartShapeMeasureMarks"; }
 
    int LoadAll() override;
 
    int LoadAllForRegion(FCMusicRegion* pRegion, bool removeduplicates = true);
 
    void RemoveDuplicateReferences()
    {
        for (int i = 0; i < GetCount() - 1; i++)
        {
            FCSmartShapeMeasureMark* pShapeMark1 = (FCSmartShapeMeasureMark*) GetItemAt(i);
 
            int j = GetCount() - 1;
            while (j > i)
            {
                FCSmartShapeMeasureMark* pShapeMark2 = (FCSmartShapeMeasureMark*) GetItemAt(j);
                if (pShapeMark2->GetShapeNumber() == pShapeMark1->GetShapeNumber())
                {
                    ClearItemAt(j);
                }
                j--;
            }
        }
    }
 
    void KeepSlursOnly()
    {
        int i = GetCount() - 1;
        while (i >= 0)
        {
            FCSmartShapeMeasureMark* pShapeMark = (FCSmartShapeMeasureMark*) GetItemAt(i);
            FCSmartShape* pSlur = pShapeMark->CreateSmartShape(false);
 
            if (pSlur)
            {
                if (!pSlur->IsSlur()) ClearItemAt(i);
                delete pSlur;
            }
            i--;            
        }
    }
 
    void KeepHairpinsOnly()
    {
        int i = GetCount() - 1;
        while (i >= 0)
        {
            FCSmartShapeMeasureMark* pShapeMark = (FCSmartShapeMeasureMark*) GetItemAt(i);
            FCSmartShape* pHairpin = pShapeMark->CreateSmartShape(false);                       
 
            if (pHairpin && (!pHairpin->IsHairpin())) ClearItemAt(i);
            i--;
            delete pHairpin;
        }
    }
 
    void KeepCustomLinesOnly()
    {
        int i = GetCount() - 1;
        while (i >= 0)
        {
            FCSmartShapeMeasureMark* pShapeMark = (FCSmartShapeMeasureMark*) GetItemAt(i);
            FCSmartShape* pSmartshape = pShapeMark->CreateSmartShape(false);
 
            if (pSmartshape && (!pSmartshape->IsCustomLine())) ClearItemAt(i);
            i--;
            delete pSmartshape;
        }
    }
 
    void KeepSystemStavesOnly(FCSystemStaves* pSystemStaves)
    {
        int i = GetCount() - 1;
        while (i >= 0)
        {
            FCSmartShapeMeasureMark* pShapeMark = (FCSmartShapeMeasureMark*) GetItemAt(i);
            FCSmartShape* pSmartShape = pShapeMark->CreateSmartShape(false);
 
                        if (pSmartShape)
                        {
                                if (!pSystemStaves->FindStaff(pSmartShape->GetTerminateSegmentLeft()->GetStaff()) &&
                                        !pSystemStaves->FindStaff(pSmartShape->GetTerminateSegmentRight()->GetStaff()))
                                {
                                        ClearItemAt(i);
                                }
                        }
            i--;
            delete pSmartShape;
        }
    }
 
    void KeepStaffOnly(twobyte staffno)
    {
        int i = GetCount() - 1;
        while (i >= 0)
        {
            FCSmartShapeMeasureMark* pShapeMark = (FCSmartShapeMeasureMark*) GetItemAt(i);
            FCSmartShape* pSmartShape = pShapeMark->CreateSmartShape(false);
 
                        if (pSmartShape)
                        {
                                if ((pSmartShape->GetTerminateSegmentLeft()->GetStaff() != staffno) &&
                                        (pSmartShape->GetTerminateSegmentRight()->GetStaff() != staffno))
                                {
                                        ClearItemAt(i);
                                }
                        }
            i--;
            delete pSmartShape;
        }
    }
 
    FCSmartShapeMeasureMark* FindSmartShapeMarkByID(CMPER cmperSmartShape)
    {
        for (int i = 0; i < GetCount() - 1; i++)
        {
            FCSmartShapeMeasureMark* pShapeMark = (FCSmartShapeMeasureMark*) GetItemAt(i);
            if (pShapeMark->GetShapeNumber() == cmperSmartShape) return pShapeMark;
        }        
        return NULL;
    }
 
    FCSmartShapeMeasureMark* GetItemAt(int index) const { return (FCSmartShapeMeasureMark*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
#ifdef PDK_FRAMEWORK_ENTRIES
class FCSmartShapeEntryMarks : public __FCCollectionEntryDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCSmartShapeEntryMark(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCSmartShapeEntryMarks"; }
    
    FCSmartShapeEntryMarks(FCNoteEntry* pConnectEntry = NULL) :
            __FCCollectionEntryDetail(pConnectEntry) {}
    
    FCSmartShapeEntryMark* GetItemAt(int index) const { return (FCSmartShapeEntryMark*) __FCCollectionEntryDetail::GetItemAt(index); }
};
 
 
 
class FCCustomSmartLineDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCustomSmartLineDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCCustomSmartLineDefs() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCCustomSmartLineDefs"; }
 
    FCCustomSmartLineDef* GetItemAt(int index) const
                { return (FCCustomSmartLineDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
#endif //PDK_FRAMEWORK_ENTRIES
 
 
 
class FCSmartShapes : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCSmartShape(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCSmartShapes"; }
 
    FCSmartShape* FindLeftEntryNumber(ENTNUM entnum)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCSmartShape* pSmartShape = (FCSmartShape*) GetItemAt(i);
            if (!pSmartShape->IsEntryBased()) continue;
            if (pSmartShape->GetTerminateSegmentLeft()->GetEntryNumber() == entnum)
            {
                return pSmartShape;
            }
        }
        return NULL;
    }
 
};
 
#endif /* PDK_FRAMEWORK_SMARTSHAPES */
 
#endif  /* FF_SMARTSHAPES_H */