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

    virtual EXTAG Tag() { return __ot_SmartShapeMeasMark; }
    virtual int DataSizeLoad() { return sizeof(__EDTSmartShapeMeasMark); }
    virtual void* Allocate() { return (void*) &_smartshapemeasmark; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_smartshapemeasmark, ((FCSmartShapeMeasureMark*)pSource)->_GetSmartShapeMeasureMark(), sizeof(_smartshapemeasmark));
        _datablock = &_smartshapemeasmark;
        _loadedsize = sizeof(_smartshapemeasmark);
    }

    virtual __FCBaseData* CreateObject()
                { return new FCSmartShapeMeasureMark(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCSmartShapeMeasureMark"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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 { return _dataid.other.cmper; }

    FCSmartShape* CreateSmartShape(bool load_center_shapes = true);

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCSmartShape* CreateSmartShape_GC(bool load_center_shapes = true);
#endif

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutDigit("Shape Number: ", GetShapeNumber());
        DebugOutDigit("Center Shape Number: ", _GetCenterShapeNumber());
    }
#endif
};


class FCSmartShapeEntryMark : public __FCEntryDetail
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTSmartShapeEntryMark _smartshapeentrymark;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return __dt_SmartShapeEntryMark; }
    virtual int DataSizeLoad() { return sizeof(__EDTSmartShapeEntryMark); }
    virtual void* Allocate() { return (void*) &_smartshapeentrymark; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_smartshapeentrymark, ((FCSmartShapeEntryMark*)pSource)->_GetSmartShapeEntryMark(), sizeof(_smartshapeentrymark));
        _datablock = &_smartshapeentrymark;
        _loadedsize = sizeof(_smartshapeentrymark);
    }

    virtual __FCBaseData* CreateObject()
                { return new FCSmartShapeEntryMark(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCSmartShapeEntryMark"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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
    /*  \brief GC version of CreateSmartShape for Lua. */
    FCSmartShape* CreateSmartShape_GC(bool 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

    virtual twobyte CalcLastInci();
    
    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetSmartShapeFlag(state);
    }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCEntryDetail::DebugDump();
        DebugOutDigit("Shape Number: ", GetShapeNumber());        
    }
#endif
};

class FCCenterSmartShape : public __FCNoInciDetail
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTCenterShape _centershape;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return __dt_CenterShape; }
    virtual int DataSizeLoad() { return sizeof(__EDTCenterShape); }
    virtual void* Allocate() { return (void*) &_centershape; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_centershape, ((FCCenterSmartShape*)pSource)->_GetCenterSmartShape(), sizeof(_centershape));
        _datablock = &_centershape;
        _loadedsize = sizeof(_centershape);
    }

    virtual __FCBaseData* CreateObject()
                { return new FCCenterSmartShape(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCenterSmartShape"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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
    virtual void DebugDump()
    {
        __FCNoInciDetail::DebugDump();
    }
#endif
};




class FCSmartShape;

class FCSmartShapeSegment : public __FCBase
{
    __SSTERMSEG* _pSegment;
    FCSmartShape* _pRealObject;
    bool _isleftsidesegment;
public:
    virtual const char* ClassName() { 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... */
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump();
#endif

};

class FCSmartShapeCtrlPointAdjust : public __FCBase
{
    __SSCTLPTADJ* _pCtrlPointAdjust;
    FCSmartShape* _pRealObject;
public:
    virtual const char* ClassName() { 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
    virtual void DebugDump()
    {
        __FCBase::DebugDump();
        DebugOutDigit("Control point 1 (x)", GetControlPoint1OffsetX());
        DebugOutDigit("Control point 1 (y)", GetControlPoint1OffsetY());
        DebugOutDigit("Control point 2 (x)", GetControlPoint2OffsetX());
        DebugOutDigit("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;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return __ot_SmartShape; }
    virtual int DataSizeLoad() { return sizeof(__EDTSmartShape); }
    virtual void* Allocate() { return (void*) &_smartshape; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_smartshape, ((FCSmartShape*)pSource)->_GetSmartShape(), sizeof(_smartshape));
        _datablock = &_smartshape;
        _loadedsize = sizeof(_smartshape);
    }

    virtual __FCBaseData* CreateObject()
                { 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        
    };

    virtual const char* ClassName() { return "FCSmartShape"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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);

    bool CalcLeftEntryMetricPos(FCNoteEntry* pEntry, FCPoint* pPoint);

    bool CalcRightEntryMetricPos(FCNoteEntry* pEntry, FCPoint* pPoint);

#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 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);

    void DeleteEverything();

    void AssignToStaff(int newstaff);

    virtual bool SaveNew();

    bool SaveNewEverything(FCNoteEntry* pFirstEntry = NULL, FCNoteEntry* pLastEntry = NULL);

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Shape Type: ", GetShapeType());
        DebugOutDigit("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
};

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

#include "pragma_align_begin.h"
struct __EDTCustomLineType_Solid2012
{
        Efix16 lineWidth;
};
#include "pragma_align_end.h"

#include "pragma_align_begin.h"
// for linetype == CUSTOMLINE_DASHED
struct __EDTCustomLineType_Dashed2012
{
        Efix16 lineWidth;
        Efix16 dashOn;
        Efix16 dashOff;
};
#include "pragma_align_end.h"


#include "pragma_align_begin.h"
// for linetype == CUSTOMLINE_CHARACTER
struct __EDTCustomLineType_Character2012
{
        ufourbyte       lineChar;
        EFONTID         font;                           // Enigma Font ID
        twobyte     size;                               // Font size in points
        FLAG_16         efx;                            // Font efx (FONT_EFX_*)
        fourbyte        baselineShiftEMs;       // in EMs
};
#include "pragma_align_end.h"

#include "pragma_align_begin.h"
struct __EDTCustomLineDefinition2012
{
        twobyte linetype;                               // CUSTOMLINE_SOLID = solid line
                                                                        // CUSTOMLINE_DASHED = dashed line
                                                                        // CUSTOMLINE_CHARACTER = line consisting of characters 
        union
        {
                __EDTCustomLineType_Solid2012 solid;
                __EDTCustomLineType_Dashed2012 dashed;
                __EDTCustomLineType_Character2012 character;
        } linedata;
        // [xref: LINECAP]
        twobyte endpointstylestart;             // CLENDPOINT_NONE - None
                                                                        // CLENDPOINT_PRESET - Preset Arrowhead
                                                                        // CLENDPOINT_CUSTOM - Custom Arrowhead
                                                                        // CLENDPOINT_HOOK - Hook
        twobyte endpointstyleend;               // Same constants as for endpointstylestart.
        fourbyte startPointData;                // If endpointstylestart is non-zero, this
                                                                        // contains the preset/custom arrowhead shape ID
                                                                        // for start point, or the Hook length in Efix32
                                                                        // for CLENDPOINT_HOOK style
        fourbyte endPointData;                  // If endpointstylestart is non-zero, this
                                                                        // contains the preset/custom arrowhead shape ID
                                                                        // for start point, or the Hook length in Efix32
                                                                        // for CLENDPOINT_HOOK style
        // remaining SSLINESTYLE fields
        FLAG_16 flag;                                   // Flag bits.
        twobyte leftStartTextID;                        // The smart shape (tx_SmartShape) raw text ID
                                                                        // for left start text.
        twobyte leftContTextID;                 // The smart shape raw text ID for left
                                                                        // continuation text.
        twobyte rightEndTextID;                 // The smart shape raw text ID for right end text.
        twobyte centerFullTextID;               // The smart shape raw text ID for centered full text.
        twobyte centerAbbrTextID;               // The smart shape raw text ID for centered
                                                                        // abbreviated text.
        Evpu16 leftStartTextHoriz;              // Horizontal start text position
        Evpu16 leftStartTextVert;               // Vertical start text position
        Evpu16 leftContTextHoriz;               // Horizontal continuation text position
        Evpu16 leftContTextVert;                // Vertical continuation text position
        Evpu16 rightEndTextHoriz;               // Horizontal right-end text position
        Evpu16 rightEndTextVert;                // Vertical right-end text position
        Evpu16 centerFullTextHoriz;             // Horizontal position for centered full text
        Evpu16 centerFullTextVert;              // Vertical position for centered full text
        Evpu16 centerAbbrTextHoriz;             // Horizontal position for abbreviated text
        Evpu16 centerAbbrTextVert;              // Vertical position for abbreviated text
        Evpu16 lineadjustStartHoriz;    // Line adjustment for horizontal start point
        Evpu16 lineadjustStartVert;             // Vertical line adjustment for start point.
                                                                        // This value should be the same as lineadjustEndVert.
        Evpu16 lineadjustEndHoriz;              // Horizontal end line adjustment
        Evpu16 lineadjustEndVert;               // Vertical end line adjustment. This
                                                                        // value should be the same as lineadjustStartVert.
        Evpu16 lineadjustContinueHoriz; // Line adjustments for continue horizontally
        twobyte AAAA;                                   // reserved, set to 0
};
#include "pragma_align_end.h"

#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:    
    virtual EXTAG Tag()
    {
        if (_use2012version)
            return MAKEEXTAG(edSpecialOther, 'l', 's');
        else
            return MAKEEXTAG(MAKETAG(edMultiInciOther, 6), 'l', 's');
    }
    virtual int DataSizeLoad() {
        return _use2012version ? sizeof(_customsmartlinedef2012) : sizeof(_customsmartlinedef);
    }
    virtual void* Allocate() { return _use2012version ? (void*) &_customsmartlinedef2012 : (void*) &_customsmartlinedef; }
    virtual EVERSION EnigmaVersion() { return _use2012version ? FINALEVERSION_2012 : FINALEVERSION_2010; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        if (_use2012version)
        {
            memcpy(&_customsmartlinedef2012, ((FCCustomSmartLineDef*)pSource)->_GetCustomSmartLineDef(), sizeof(_customsmartlinedef2012));
            _datablock = &_customsmartlinedef2012;
            _loadedsize = sizeof(_customsmartlinedef2012);
        }
        else
        {
            memcpy(&_customsmartlinedef, ((FCCustomSmartLineDef*)pSource)->_GetCustomSmartLineDef(), sizeof(_customsmartlinedef));
            _datablock = &_customsmartlinedef;
            _loadedsize = sizeof(_customsmartlinedef);
        }
    }

    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;
    }

    virtual __FCBaseData* CreateObject() { return new FCCustomSmartLineDef(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCustomSmartLineDef"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CUSTOMSMARTLINEDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetCustomSmartLineDef() { return _use2012version ? (void*) &_customsmartlinedef2012 : (void*) &_customsmartlinedef; }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    
    FCCustomSmartLineDef();


    virtual bool DeepDeleteData();

    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

    FCString* CreateTextString_GC(int 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->GetNameByID();
            _customsmartlinedef2012.linedata.character.size = pFontInfo->GetSize();
            _customsmartlinedef2012.linedata.character.efx = pFontInfo->GetEnigmaStyles();
        }
        else
        {
            _customsmartlinedef.fontID_length = pFontInfo->GetNameByID();
            _customsmartlinedef.fontsize_space = pFontInfo->GetSize();
            _customsmartlinedef.efx = pFontInfo->GetEnigmaStyles();
        }
    }

    bool GetHorizontal() const
    {
        if (_use2012version)
        {
            return GetBitFlag(_customsmartlinedef2012.flag, 0x0001);
        }
        else
        {
            /* Nothing yet */
        }
        return false;
    }

    void SetHorizontal(bool state)
    {
        if (_use2012version)
        {            
            Set16BitFlag(&_customsmartlinedef2012.flag, 0x0001, state);
        }
        else
        {
            /* Nothing yet */
        }
    }

    void SetUseAfterStartTextOffset(bool state)
    {
        if (_use2012version)
        {
            Set16BitFlag(&_customsmartlinedef2012.flag, 0x0002, state);
        }
        else
        {
            /* Nothing yet */
        }
    }

    void SetAfterStartTextOffset(Evpu16 value)
    {
        if (_use2012version)
        {
            _customsmartlinedef2012.lineadjustStartHoriz = value;
        }
        else
        {
            /* Nothing yet */
        }
    }

    void SetUseBeforeEndTextOffset(bool state)
    {
        if (_use2012version)
        {
            Set16BitFlag(&_customsmartlinedef2012.flag, 0x0004, state);
        }
        else
        {
            /* Nothing yet */
        }
    }
    
    void SetUseAfterContinuedTextOffset(bool state)
    {
        if (_use2012version)
        {
            Set16BitFlag(&_customsmartlinedef2012.flag, 0x0008, state);
        }
        else
        {
            /* Nothing yet */
        }
    }
    
    void SetAfterContinuedTextOffset(Evpu16 value)
    {
        if (_use2012version)
        {
            _customsmartlinedef2012.lineadjustContinueHoriz = value;
        }
        else
        {
            /* Nothing yet */
        }
    }
    
    void SetLineVerticalOffset(twobyte value)
    {
        if (_use2012version)
        {
            /* Since the UI only supports one value, set both. */
            _customsmartlinedef2012.lineadjustStartVert = value;
            _customsmartlinedef2012.lineadjustEndVert = value;
        }
        else
        {
            /* Nothing yet */
        }
    }


    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
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
    }
#endif

};



class FCSmartShapeMeasureMarks : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCSmartShapeMeasureMark(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCSmartShapeMeasureMarks() : __FCCollectionInciOther() {}

    virtual const char* ClassName() { return "FCSmartShapeMeasureMarks"; }

    virtual int LoadAll();

    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();

            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();

            if (!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();

            if (!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();

            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();

            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) { return (FCSmartShapeMeasureMark*) __FCCollectionInciOther::GetItemAt(index); }
};



class FCSmartShapeEntryMarks : public __FCCollectionEntryDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCSmartShapeEntryMark(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCSmartShapeEntryMarks"; }
    
    FCSmartShapeEntryMarks(FCNoteEntry* pConnectEntry = NULL) :
            __FCCollectionEntryDetail(pConnectEntry) {}
    
    FCSmartShapeEntryMark* GetItemAt(int index) { return (FCSmartShapeEntryMark*) __FCCollectionEntryDetail::GetItemAt(index); }
};



class FCCustomSmartLineDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCCustomSmartLineDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCCustomSmartLineDefs() : __FCCollectionNoInciOther() {}

    virtual const char* ClassName() { return "FCCustomSmartLineDefs"; }

    FCCustomSmartLineDef* GetItemAt(int index)
                { return (FCCustomSmartLineDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};




class FCSmartShapes : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCSmartShape(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { 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 */