ff_base.h

/*
 * File:   ff_base.h
 * Author: Jari Williamsson
 *
 * Created on den 26 december 2009, 14:03
 *
 *  Important! Don't use size_t in general, since it's crashes Lua on 64-bit Windows if used in method prototypes.
 */
 
#ifndef _FF_BASE_H
#define _FF_BASE_H
 
#include <finalepdk.h>
#include <ctype.h>
#ifdef PDK_FRAMEWORK_TINYXML
#include <tinyxml2.h>
#endif
#include <ctime>  /* strftime */
#include <algorithm>
#include <typeinfo>
#include <string>
#include <vector>
 
#ifdef PDK_FRAMEWORK_DEBUG
#if OPERATING_SYSTEM == WINDOWS
#include <stdio.h>  /* sprintf */
#endif
#endif
 
/* Define macros to simplify Lua/non-Lua types */
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
#include "fflua_lua.h"
#define _LUACODE(x) x
#define _NOLUACODE(x)
#define _state_ptr lua_State*
void __finale_version_check(EVERSION version, const char* funcName, const char* className);
#define FINALE_VERSION_CHECK(version) __finale_version_check(version, __func__, typeid(*this).name())
#else
#define _LUACODE(x)
#define _NOLUACODE(x) x
typedef void* _state_ptr;
#define FINALE_VERSION_CHECK(version)
#endif // PDK_FRAMEWORK_LUAFRIENDLY
 
#define _ENUMCODE(x) _NOLUACODE(x)
 
#ifndef LB2
#define LB2(C)
#endif
 
#ifndef LB3
#define LB3(C)
#endif
 
// Macros for selecting an item from one or another struct for getters and setters
#define _GET_OLD_NEW_MEMBER_SELECT(MEMBEROLD, MEMBERNEW, DATAOLD, DATANEW, ISNEW) \
    ( (ISNEW) ? DATANEW.MEMBERNEW : static_cast<decltype(DATANEW.MEMBERNEW)>(DATAOLD.MEMBEROLD) )
#define _SET_OLD_NEW_MEMBER_SELECT(MEMBEROLD, MEMBERNEW, DATAOLD, DATANEW, ISNEW) \
    (([&]() -> decltype(DATANEW.MEMBERNEW)& { return (ISNEW) ? DATANEW.MEMBERNEW : DATAOLD.MEMBEROLD; })())
 
/* Forward declararations of some required classes. */
class FCString;
class FCUI;
class FCNumbers;
 
class __FCBase //warning, this breaks FCString and other stuff: LB3(: public std::enable_shared_from_this<__FCBase>)
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS      
    void *_UserData;
    void *_UserData2;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
        enum PDKFRAMEWORK_CLASSID
        {
                FCID_UNKNOWN = 0,
                FCID_ACCIDENTALMOD,
        FCID_ACTIVELYRIC,
                FCID_ALLOTMENT,
                FCID_ARTICULATION,
                FCID_ARTICULATIONDEF,
                FCID_BACKWARDREPEAT,
                FCID_BASELINE,
                FCID_BEAMMOD,
                FCID_BEATCHARTELEMENT,
        FCID_BOOKMARK,
                FCID_BROKENBEAMMOD,
        FCID_CATEGORYDEF,
                FCID_CELLCLEFCHANGE,
                FCID_CELLFRAMEHOLD,
        FCID_CELLGRAPHIC,
        FCID_CELLTEXT,
                FCID_CENTERSMARTSHAPE,          
                FCID_CHORD,
                FCID_CHORDPREFS,
                FCID_CHORDSUFFIXELEMENT,
                FCID_CHORUSSYLLABLE,
                FCID_CLEFDEF,
        FCID_COMPOSITETIMESIGBOTTOMELEMENT,
        FCID_COMPOSITETIMESIGTOPELEMENT,
                FCID_CROSSSTAFFMOD,
                FCID_CUSTOMSMARTLINEDEF,
                FCID_CUSTOMSTEMMOD,
                FCID_DISTANCEPREFS,
                FCID_DOTMOD,
        FCID_ENCLOSURE,
                FCID_ENDINGREPEAT,
        FCID_ENIGMATEXTSTYLE,
        FCID_ENTRYALTERMOD,
                FCID_EXECUTABLESHAPEDEF,
        FCID_EXPRESSION,
        
        FCID_FONTINFO,
        
                FCID_FONTPREFS,
        FCID_FREEZESYSTEM,
                FCID_FRETBOARDSTYLEDEF,
                FCID_FRETBOARDSTYLEDEFS,
                FCID_FRETBOARDGROUPDEF,
                FCID_FRETBOARDGROUPDEFS,
                FCID_FRETINSTRUMENTDEF,
                FCID_GENERALPREFS,
                FCID_GRIDSGUIDESPREFS,
        FCID_GROUP,
                FCID_GROUPNAMEPOSITIONPREFS,
                FCID_HUMANPLAYBACKPREFS,
                FCID_INDEPENDENTCELLDETAIL,
                FCID_INSTRUMENTDEF,
                FCID_INSTRUMENTPLAYBACKDATA,
        FCID_KEYMODEDEF,
        FCID_KEYSIGNATURE,
                FCID_LAYERPREFS,
                FCID_LYRICSBASELINE,
                FCID_LYRICSPREFS,
        FCID_MEASURE,
        FCID_MEASURENUMBERREGION,
                FCID_METATOOLASSIGNMENT,
                FCID_MIDIEXPRESSION,
                FCID_MISCDOCPREFS,
        FCID_MULTIMEASUREREST,
                FCID_MULTIMEASURERESTPREFS,
                FCID_MULTISTAFFINSTRUMENT,
                FCID_MULTISTAFFINSTRUMENTS,
                FCID_MUSICCHARACTERPREFS,
                FCID_MUSICSPACINGPREFS,
        
        FCID_NUMBER,
                FCID_NOTEHEADMOD,
                FCID_OTHERINCI,
                FCID_PERCUSSIONLAYOUTNOTE,
        FCID_PERCUSSIONSTAFF,           
                FCID_PERFORMANCEMOD,
        FCID_PAGE,
                FCID_PAGEFORMATPREFS,
        FCID_PAGEGRAPHIC,
        FCID_PAGETEXT,
                FCID_PART,
                FCID_PARTEXTRACTPREFS,
                FCID_PARTSCOPEPREFS,
        FCID_PARTSTAFFVOICING,
                FCID_PERCUSSIONNOTEMOD,
                FCID_PIANOBRACEPREFS,
                        FCID_PLAYBACKPREFS,
                FCID_RAWTEXT,
                FCID_RAWDATA,
                        FCID_REPEATPREFS,
                FCID_SECONDARYBEAMBREAKMOD,
        FCID_BEAMEXTENSIONMOD,
                FCID_SECTIONSYLLABLE,
                FCID_SEPARATEMEASURENUMBER,
        FCID_SEPARATEPLACEMENT,
        FCID_SHAPEDEF,
        FCID_SHAPEEXPRESSIONDEF,
                FCID_SLURCONTOURPREFS,
                FCID_SIZEPREFS,
                FCID_SMARTSHAPE,
                FCID_SMARTSHAPEENTRYMARK,
                FCID_SMARTSHAPEMEASUREMARK,
                FCID_SMARTSHAPEPREFS,
        FCID_STAFF,
                FCID_STAFFLIST,
        FCID_STAFFNAMEPOSITION,
                FCID_STAFFNAMEPOSITIONPREFS,
                FCID_STAFFSTYLEASSIGN,
        FCID_STAFFSTYLEDEF,
        FCID_STAFFSYSTEM,
                FCID_STEMCONNECTIONTABLE,
                FCID_STEMMOD,
        
        FCID_STRING,
        
                FCID_SYLLABLEENTRYMOD,
        FCID_SYSTEMSTAFF,
                FCID_TABLATURENOTEMOD,
                FCID_TEMPOELEMENT,
        FCID_TEXTBLOCK,
                FCID_TEXTEXPRESSIONDEF,
        FCID_TEXTREPEAT,
        FCID_TEXTREPEATDEF,
                FCID_TIEMOD,
                FCID_TIEPREFS,
                FCID_TIECONTOURPREFS,
                FCID_TIEPLACEMENTPREFS,
        FCID_TIMESIGNATURE,
                FCID_TUPLET,
                FCID_TUPLETPREFS,
                FCID_VERSESYLLABLE
        };
 
    virtual const PDKFRAMEWORK_CLASSID GetClassID() const { return FCID_UNKNOWN; }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
#ifndef DOXYGEN_SHOULD_IGNORE_THIS      
        int _Lua_GetClassID() const { return (int) GetClassID(); }
#endif
#endif
    
    enum MEASUREMENTUNITS
    {
        MEASUREMENTUNIT_DEFAULT = UNIT_DEFAULT,
        
        MEASUREMENTUNIT_EVPUS = UNIT_EVPUS,
        
        MEASUREMENTUNIT_INCHES = UNIT_INCHES,
        
        MEASUREMENTUNIT_CENTIMETERS = UNIT_CENTS,
        
        MEASUREMENTUNIT_POINTS = UNIT_POINTS,
        
        MEASUREMENTUNIT_PICAS = UNIT_PICAS,
        
        MEASUREMENTUNIT_SPACES = UNIT_SPACES,
        
        MEASUREMENTUNIT_MILLIMETERS = 100
    };
    
    virtual const char* ClassName() const = 0;
 
protected:
    __FCBase()
    {
        _UserData = NULL;
        _UserData2 = NULL;
    }
public:
    
    /* NOTE: This was a bug that wasn't discovered until April 04 2013, so all
     * plug-ins that use primitive collections (such as string collections)
     * should be rebuilt. */
    virtual ~__FCBase()
    {
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugMsgInt(const char* pszPrefixText, int i);
 
    void DebugMsgHex(const char* pszPrefixText, int i);
 
    void DebugMsgString(const char* pszPrefixText, const char * thestring);
 
    void DebugMsg(const char* pszMsg);
 
        static void DebugOutPtr(const char* pszPrefixText, void* ptr);
 
    static void DebugOutInt(const char* pszPrefixText, int i);
 
    static void DebugOutFloat(const char* pszPrefixText, double f);
 
    static void DebugOutTag(const char* pszPrefixText, EXTAG extag);
 
    static void DebugOutHex(const char* pszPrefixText, int i);
 
    static void DebugOutBin(const char* pszPrefixText, int i);
    
    static void DebugOutString(const char* pszPrefixText, const char * thestring);
 
    static void DebugOutString(const char* pszPrefixText, FCString* pString);
 
    static void DebugOutBool(const char* pszPrefixText, bool state);
 
    static void DebugOutBlock(const void * pBuffer, int startoffset, int size);
 
    static void DebugOutByteArrayBlock(const void * pBuffer, int startoffset, int size);
 
    static void DebugOut(const char* pszLine);
    
    void DebugOutMenuInfo(FCUI* pUI, int menuixd_horiz, int menuixd_vert) const;
 
#ifdef PDK_FRAMEWORK_FORMAT
    int DebugOutFormat(const char *fmt, ...);
#endif
 
    virtual void DebugDump();
 
    virtual void DebugDataDump();
 
    virtual void DebugDataByteArrayDump();
#endif
    
    void Set16BitFlag(FLAG_16 *flag, FLAG_16 flagbits, bool state);
 
    void Set32BitFlag(FLAG_32 *flag, FLAG_32 flagbits, bool state);
 
    bool GetBitFlag(FLAG_32 flag, FLAG_32 flagbits) const { return (flag & flagbits) != 0; }
 
        int GetBitCount(FLAG_32 flag);
 
        void SetSpecific32Bit(FLAG_32* flag, int bitnumber, bool state);
 
    void SetUserData(void* pData) { _UserData = pData; }
 
    void SetUserData2(void* pData) { _UserData2 = pData; }
 
    void* GetUserData() const { return _UserData; }
 
    void* GetUserData2() const { return _UserData2; }
 
    virtual bool IsIdentical(const __FCBase* pCompareObject) const
        {
                if (!pCompareObject) return false;
                if (ClassName() != pCompareObject->ClassName()) return false;  /* Should point to same const string */
                return true; 
        }
 
 
#ifdef PDK_FRAMEWORK_TINYXML
    void StoreXML_String(tinyxml2::XMLElement* pParentNode, const char* pszElementName, FCString* pStringValue);
 
    void StoreXML_Integer(tinyxml2::XMLElement* pParentNode, const char* pszElementName, int value);
 
    void StoreXML_Bool(tinyxml2::XMLElement* pParentNode, const char* pszElementName, bool value);
 
    void StoreXML_StringAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, FCString* pStringValue);
 
    void StoreXML_IntegerAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, int value);
 
    void StoreXML_BoolAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, bool value);
 
        void StoreXML_FloatAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, float value);
 
    virtual void StoreToXML([[maybe_unused]]tinyxml2::XMLElement* pParentNode) {}
 
 
    bool ReadXML_String(tinyxml2::XMLElement* pParentNode, const char* pszElementName, FCString* pStringValue);
 
    bool ReadXML_Integer(tinyxml2::XMLElement* pParentNode, const char* pszElementName, int* pValue);
 
    bool ReadXML_Bool(tinyxml2::XMLElement* pParentNode, const char* pszElementName, bool *pValue);
 
    bool ReadXML_StringAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, FCString* pStringValue);
 
    bool ReadXML_IntegerAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, int* pValue);
 
    bool ReadXML_BoolAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, bool *pValue);
 
        bool ReadXML_FloatAttribute(tinyxml2::XMLElement* pNode, const char* pszAttributeName, float *pValue);
 
    virtual bool ReadFromXML([[maybe_unused]]tinyxml2::XMLElement* pParentNode) { return false; }
#endif
};
 
class __FCBaseData : public __FCBase {
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EXTAG _customtag;
    
    virtual bool _RawRelink()
    {
        DeleteData();
        return Save();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
    EDOCID _connecteddocID;
    
    void *_datablock;
    
    bool _heapdatablock;
 
    int _loadedsize;
 
 
    EDataID _dataid;
    
 
    virtual void* Allocate() = 0;
 
    virtual void Deallocate() {
    }
 
    virtual bool IsDynamicSize() {
        return false;
    }
 
    bool LoadDataBlock();
 
    void ClearData();
    
    virtual twobyte CalcLastInci()  { return kNewInci; }
 
    virtual __FCBaseData* CreateObject() = 0;
 
    bool DataIsLoaded() const {
        return (_loadedsize > 0);
    }
 
    void _TagDocumentID();
public:
 
        const PDKFRAMEWORK_CLASSID GetClassID() const override = 0; /* Force all inherited class to have this method implementation */
    
    EDOCID GetConnectedDocID() const
    {
        return _connecteddocID;
    }
    
    bool VerifyConnectedDocID();
    
    virtual EXTAG Tag() const = 0;
 
    virtual EVERSION EnigmaVersion() const { return FXT_VERSION; }
 
    virtual int DataSizeLoad() const = 0;
 
    virtual int DataSizeSave() const;
 
 
    const char* ClassName() const override { return "__FCBaseData"; }
 
    void _CloneFrom(__FCBaseData* pSource);
 
    virtual void CloneMemoryFrom(__FCBaseData* pSource);
 
    const EDataID* _GetDataID() { return &_dataid; }
 
    int _GetLoadedSize() const { return _loadedsize; }
 
    const void* GetDataBlock() { return _datablock; }
 
    EXTAG GetCustomTag() const { return _customtag; }
 
    void SetCustomTag(EXTAG tag) { _customtag = tag; }
 
    __FCBaseData();
 
    virtual ~__FCBaseData();
 
    virtual bool Save();
 
    virtual bool Reload();
 
    virtual bool DeleteData();
 
    virtual bool DeepDeleteData()
    {
        return DeleteData();
    }
 
    virtual bool LoadFirst() = 0;
    
    virtual bool LoadLast() { return false; }
 
    virtual bool LoadNext();
 
    virtual bool LoadPrevious() { return false; }
    
    bool RelinkToCurrentView();
    
    bool RelinkToScore();
 
    __FCBaseData* CreateClone();
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutPtr("Data block: ", _datablock);
        DebugOutInt("Loaded size: ", (int) _GetLoadedSize());
    }
 
    void DebugDataDump() override
    {
        __FCBase::DebugDataDump();
        if (_datablock) DebugOutBlock(_datablock, 0, _GetLoadedSize());
    }
 
    void DebugDataByteArrayDump() override
    {
        __FCBase::DebugDataByteArrayDump();
        if (_datablock) DebugOutByteArrayBlock(_datablock, 0, _GetLoadedSize());
    }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual void DebugDataCompare(__FCBaseData *pCompareObject)
    {
        if (!pCompareObject)
        {
            DebugOut("DebugDataCompare(): Compare object is nil.");
            return;
        }
        if (_GetLoadedSize() != pCompareObject->_GetLoadedSize())
        {
            char szBuffer[200];
            snprintf(szBuffer, sizeof(szBuffer), "DebugDataCompare(): Compare size differs. %d compared to %d byte(s)", (int) _GetLoadedSize(), (int) pCompareObject->_GetLoadedSize());
            DebugOut(szBuffer);
            return;
        }
        unsigned char* pDataBlock = (unsigned char*) GetDataBlock();
        unsigned char* pCompareBlock = (unsigned char*) pCompareObject->GetDataBlock();
        int diffcount = 0;
        for (int i = 0; i < _GetLoadedSize(); i++)
        {
            if (pDataBlock[i] != pCompareBlock[i])
            {
                diffcount ++;
                char szBuffer[200];
                snprintf(szBuffer, sizeof(szBuffer), "DebugDataCompare() DIFF at 0-based byte offset %d: 0x%02x - 0x%02x ", i, pDataBlock[i], pCompareBlock[i]);
                DebugOut(szBuffer);
            }
        }
        if (diffcount == 0)
        {
            DebugOut("DebugDataCompare(): Data blocks are identical");
        }
    }
#endif
    
    void DebugDataOffsetDump(int offset, int size);
    
#endif
 
    FCNumbers* CreateRawDataDump();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCNumbers> CreateRawDataDump_GC()
    { return makeLuaSharedPtr(CreateRawDataDump()); }
#endif
 
    EXTAG GetRawTag() const { return Tag(); }
 
    CMPER GetRawOtherCmper() const { return _dataid.other.cmper; }
 
    twobyte GetRawOtherInci() const { return _dataid.other.inci; }
 
    CMPER GetRawDetailCmper1() const { return _dataid.detail.cmper1; }
 
    CMPER GetRawDetailCmper2() const { return _dataid.detail.cmper2; }
 
    twobyte GetRawDetailInci() const { return _dataid.detail.inci; }
 
    ENTNUM GetRawEntryDetailEntryNumber() const { return _dataid.entryDetail.entryNumber; }
 
    twobyte GetRawEntryDetailInci() const { return _dataid.entryDetail.inci; }
 
};
 
 
class __FCInci : public __FCBaseData
{
public:
    const char* ClassName() const override { return "__FCInci"; }
 
    bool Load(CMPER cmper, twobyte inci);
};
 
 
class FCString;
 
// this value is used to set apart "Fixed" (absolute) font formatting
// within the context of a displayed string. An example where it is used
// is when displaying an Enigma string in FCCtrlTextEditor.
constexpr double kDisplayPercentForFixedFontSize = 1.1;
 
class FCFontInfo : public __FCBase
{
#if FXT_VERSION >= FINALEVERSION_25
        EnigmaFontName  _nameUTF16;     /* 64-bit version of the data. */
#else
    EFONTNAME           _name;          /* Should NOT be used on Finale 25 or later. */
#endif
    EFONTID         _fontid;        /* The internal font ID. This is not
                                     document independent, but can be used for
                                     some cases when the exact font ID is
                                     required within the document. Currently the Framework
                                     hardly uses it and gets the internal font number with
                                     GetIDByName if it needs it.*/
    double                      _size;          /* Although Finale itself doesn't support fractional points,
                                     support it here. The FCCtrlCanvas supports it. */
    FLAG_16                     _styles;
private:
        const static FCString DefaultFontName;
public:
    const char* ClassName() const override { return "FCFontInfo"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FONTINFO; }
 
    enum ENIGMASTYLES
    {
        ENIGMASTYLE_PLAIN = FONT_EFX_PLAIN,
 
        ENIGMASTYLE_BOLD = FONT_EFX_BOLD,
 
        ENIGMASTYLE_ITALIC = FONT_EFX_ITALIC,
 
        ENIGMASTYLE_UNDERLINE = FONT_EFX_UNDERLINE,
 
        ENIGMASTYLE_STRIKEOUT = FONT_EFX_STRIKEOUT,
 
        ENIGMASTYLE_ABSOLUTE = FONT_EFX_ABSOLUTE,
 
        ENIGMASTYLE_HIDDEN = FONT_EFX_HIDDEN
    };
    
        FCFontInfo();
 
    FCFontInfo(const FCString& name, double size, FLAG_16 enigmastyles = ENIGMASTYLE_PLAIN);
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static FCFontInfo* FCFontInfo_Lua(void* ptr, lua_State *L);
#endif // PDK_FRAMEWORK_LUAFRIENDLY_CPP
    
    FCFontInfo(const ETextStyle& style);
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int FCFontInfo_tostring(lua_State* L);
#endif
 
    static fourbyte GetSystemTextEncoding();
 
 
        void CopyFrom(const FCFontInfo* pInfo);
    
    FCFontInfo* CreateCopy()
    {
        FCFontInfo* pCopy = new FCFontInfo();
        pCopy->CopyFrom(this);
        return pCopy;
    }
    
#ifdef PDK_FRAMEWORK_PREFS
    /* NOTE! These 2 declarations are not type safe, since this declaration is in ff_base.h */
    
    bool LoadFontPrefs(int prefsID);
    
    bool SaveFontPrefs(int prefsID);
 
#endif /* PDK_FRAMEWORK_PREFS*/
 
    int GetSize() const { return static_cast<int>(_size); }
    
    double GetSizeFloat() const
    {        
        return _size;
    }
 
#if FXT_VERSION < FINALEVERSION_25
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    void GetNameParam(const EFONTNAME* pName) { strcpy((char*)pName, (const char*)_name); }
#endif
#endif
    
    void GetNameString(FCString* pString) const;
 
    std::string GetName() const;
 
    EFONTID GetIDByName() const;
    
    [[deprecated]]EFONTID GetNameByID() const
    { return GetIDByName(); }
    
    
    FLAG_16 GetEnigmaStyles() const { return _styles; }
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool MakeEnigmaString(FCString* pString, FCString* pFontTagString = NULL);
 
    FCString* CreateEnigmaString(FCString* pFontTagString = NULL);
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
private:
    luabridge::RefCountedPtr<FCString>CreateEnigmaString_GC(FCString* pFontTagString)
    { return makeLuaSharedPtr(CreateEnigmaString(pFontTagString)); }
public:
    static int CreateEnigmaString_CFunc(lua_State* L)
    {
        return _CFunctionOneOptionalParameter<FCFontInfo, luabridge::RefCountedPtr<FCString>, FCString*, &FCFontInfo::CreateEnigmaString_GC>(L, nullptr);
    }
#endif
 
    void MakeEnigmaStyleString(FCString* pString);
 
    void MakeEnigmaSizeString(FCString* pString);
 
    FCString* CreateEnigmaStyleString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateEnigmaStyleString_GC()
    { return makeLuaSharedPtr(CreateEnigmaStyleString()); }
#endif
 
    bool ParseEnigmaCommand(FCString* pString);
 
#endif  /* PDK_FRAMEWORK_ENIGMASTRINGS */
 
    void ParseEnigmaFont(const EEnigmaFont* pEnigmaFont)
    {
        SetEnigmaStyles(pEnigmaFont->efx);
        SetSize(pEnigmaFont->size);
        SetNameByID(pEnigmaFont->font);
    }
 
    void SetEnigmaStyles(FLAG_16 fontstyles) { _styles = fontstyles; }
    
    FCString* CreateDescription() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDescription_GC()
    { return makeLuaSharedPtr(CreateDescription()); }
#endif
 
#if FXT_VERSION < FINALEVERSION_25
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    void SetName( const EFONTNAME* pName) { strcpy((char*)_name, (const char*)pName); }
#endif
#endif
 
    void SetName(const std::string& pszName);
    
    EFONTID GetFontID() const { return _fontid; }
    
    void SetFontID(EFONTID fontID) { _fontid = fontID; }
 
    void SetNameString(const FCString& value);
 
    void SetNameByID(EFONTID id);
 
    void SetSize(int fontsize) { _size = static_cast<double>(fontsize); }
        
    void SetSizeFloat(double fontsize) { _size = fontsize; }
 
    void SetAbsolute(bool state) { Set16BitFlag(&_styles, FONT_EFX_ABSOLUTE, state); }
 
    void SetStrikeOut(bool state) { Set16BitFlag(&_styles, FONT_EFX_STRIKEOUT, state); }
 
    void SetBold(bool state) { Set16BitFlag(&_styles, FONT_EFX_BOLD, state); }
 
    void SetHidden(bool state) { Set16BitFlag(&_styles, FONT_EFX_HIDDEN, state); }
 
    void SetItalic(bool state) { Set16BitFlag(&_styles, FONT_EFX_ITALIC, state); }
 
    void SetUnderline(bool state) { Set16BitFlag(&_styles, FONT_EFX_UNDERLINE, state); }
 
    void SetPlain() { _styles = 0; }
 
    bool IsName(const char* pszTestName) const;
    
    bool IsNameString(const FCString& pTestName) const;
 
    bool IsPlain() { return (_styles == 0); }
 
    bool GetBold() const { return GetBitFlag(_styles, FONT_EFX_BOLD); }
 
    bool GetItalic() const { return GetBitFlag(_styles, FONT_EFX_ITALIC); }
 
    bool GetUnderline() const { return GetBitFlag(_styles, FONT_EFX_UNDERLINE); }
 
    bool GetStrikeOut() const { return GetBitFlag(_styles, FONT_EFX_STRIKEOUT); }
 
    bool GetAbsolute() const { return GetBitFlag(_styles, FONT_EFX_ABSOLUTE); }
 
    bool GetHidden() const { return GetBitFlag(_styles, FONT_EFX_HIDDEN); }
 
    bool GetIsSMuFLFont() const
    {
#if FXT_VERSION >= FINALEVERSION_27_1
        return FX_IsSMuFLFont(GetIDByName());
#else
        return false;
#endif
    }
    
    bool IsMacSymbolFont() const;
 
    bool IsIdenticalTo(const FCFontInfo& compareWith) const;
 
    bool MakeDefaultMusicFont();
    
    double CalcAverageRomanCharacterWidthEVPUs() const;
    
    double CalcAverageRomanCharacterWidthPoints() const
    {
        return CalcAverageRomanCharacterWidthEVPUs() / 4.0;
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override;
#endif
};
 
 
class FCEnigmaTextStyle : public __FCBase
{
    FCFontInfo _font;
    EColor _color{}; // not currently used
    fourbyte _tracking{};
    Evpu32 _baselineshift{};
    Evpu32 _superscript{};
    
public:
    const char* ClassName() const override { return "FCEnigmaTextStyle"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ENIGMATEXTSTYLE; }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    static FCEnigmaTextStyle* FCEnigmaTextStyle_Lua(void* ptr, lua_State* L)
    {
        return _OneOptionalParamLuaConstructor<FCEnigmaTextStyle, const FCFontInfo&>(ptr, L);
    }
#endif
 
    FCEnigmaTextStyle() : _font() {}
    
    FCEnigmaTextStyle(const FCFontInfo& font) : _font()
    {
        _font.CopyFrom(&font);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCEnigmaTextStyle(const ETextStyle& ts) : _font(ts)
    {
        _color = ts.color;
        _tracking = ts.tracking;
        _baselineshift = ts.baselineShift;
        _superscript = ts.superscript;
    }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    FCFontInfo* GetFont() { return &_font; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const FCFontInfo* GetFont() const { return &_font; }
#endif
    
    fourbyte GetInterletterSpacing() const { return _tracking; }
    
    Evpu32 GetBaselineShift() const { return _baselineshift; }
    
    Evpu32 GetSuperscript() const { return _superscript; }
    
    void SetInterletterSpacing(fourbyte value) { _tracking = value; }
    
    void SetBaselineShift(Evpu32 value) { _baselineshift = value; }
    
    void SetSuperscript(Evpu32 value) { _superscript = value; }
};
 
 
class FCStrings;
class FCCategoryDef;
class FCRange;
 
const eUniChar16 UTF16_HIGH_SURROGATE_MASK = 0xD800;
const eUniChar16 UTF16_LOW_SURROGATE_MASK = 0xDC00;
 
class FCString : public __FCBase
{
        // use _fcStringChar instead of eUniChar16 so that C++ debuggers
        // will display the buffers as strings.
        using _fcStringChar = WINCODE(WCHAR) MACCODE(char16_t);
        static_assert(sizeof(_fcStringChar) == sizeof(eUniChar16), "FCString internal _fcStringChar must match sizeof(eUniChar16).");
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        int _length;
        int _storagelength;         // Maximum characters that can fit in the storage
        _fcStringChar* _pStorage;   /* The main string buffer (UTF16) for Unicode.
                                     * The contents MUST be 0-terminated (since
                                     * some APIs require it)! */
        mutable char* _pTempCBuffer;  // Used for GetCString
        mutable char* _pTempCUTF8Buffer;  // Used for GetCStringUTF8
    
#if OPERATING_SYSTEM == MAC_OS
        mutable void* _nsstringobject;  /* A retained NSString* object for GetNSString() */
#endif
 
        void _DeleteStorage();
 
        void _ExpandStorageIfNecessary(int minimumlength);
 
        bool _SetFinalePath(FinPath pathconstant);
 
        void __init()
        {
            _length = 0;
            _storagelength = 0;
            _pStorage = NULL;
            _pTempCBuffer = NULL;
            _pTempCUTF8Buffer = NULL;
#if OPERATING_SYSTEM == MAC_OS
            _nsstringobject = nullptr;
#endif
            Clear();
        }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
#ifdef PDK_FRAMEWORK_TINYXML
    void StoreToXML(tinyxml2::XMLElement* pParentNode) override {
        StoreXML_StringAttribute(pParentNode, "FCString", this);
    }
 
    /* \brief Virtual method that reads the string object data. This method is
     * only called passively by the collection load feature.
     *
     * This method requires the <b>PDK_FRAMEWORK_TINYXML</b> define. */
    bool ReadFromXML(tinyxml2::XMLElement* pParentNode) override
    {
        return ReadXML_StringAttribute(pParentNode, "FCString", this);
    }
#endif
    
    static bool _IsHighSurrogate(eUniChar16 value)
    {
        return (value & 0xFC00) == UTF16_HIGH_SURROGATE_MASK;
    }
    
    static bool _IsLowSurrogate(eUniChar16 value)
    {
        return (value & 0xFC00) == UTF16_LOW_SURROGATE_MASK;
    }
    
    bool _GetCodePointRange(FCRange *pRange) const;
 
public:
    const char* ClassName() const override { return "FCString"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STRING; }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    static FCString* FCString_Lua(void* ptr, lua_State* L)
    {
        return _OneOptionalParamLuaConstructor<FCString, const char *>(ptr, L);
    }
#endif
 
    FCString() : __FCBase()
    {
        __init();
    }
    
    FCString(const char* pszCString) : __FCBase()
    {
        __init();
        SetUTF8String(pszCString);      // SetUTF8String falls back to platform encoding if UTF8 doesn't work, but we should try UTF8 first.
    }
 
    FCString(const eUniChar16* pszCString) : __FCBase()
    {
        __init();
        SetUnicodeString(pszCString);
    }
 
    FCString(const _fcStringChar* pszCString) : __FCBase()
    {
        __init();
        SetUnicodeString(reinterpret_cast<const eUniChar16 *>(pszCString));
    }
 
    virtual ~FCString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int FCString_tostring(lua_State* L)
    {
       FCString* pThis = luabridge::Stack<FCString*>::get(L, 1) LB3(.value());
       std::string s = std::string(pThis->ClassName()) + ": " + pThis->GetUTF8String();
       luabridge::Stack<std::string>::push(L, s).throw_on_error();
       return 1;
    }
#endif
    
    FCString(const FCString &src)
    {
        __init();
        SetString(&src); //note: SetString checks for self-assignment
    }
    
    FCString &operator=(const FCString &src)
    {
        // do NOT call __init() here because this-> points to a constructed FCString
        // and we need to let SetString() release the old memory.
        SetString(&src); //note: SetString checks for self-assignment
        return *this;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool operator==(const FCString &src) const
    { return (0 == this->Compare(src)); }
    template<typename T> // if we ever overload operator==(), this template picks up the overload as well
    bool operator!=(T src) const
    { return ! (*this == src); }
    
    const _fcStringChar* GetOSUnicodeString() const { return _pStorage; }
    
    const std::basic_string_view<eUniChar16> _GetBasicStringView() const
    { return std::basic_string_view<eUniChar16>(_GetUnicodeBuffer(), GetLength()); }
    
    static const eUniChar16 emptyUniCharStr[];
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    void AppendCharacter(eUniChar32 character);
 
    void AppendString(const FCString* pOtherString);
    
    void AppendCString(const char* pOtherString);
  
#if defined(PDK_FRAMEWORK_LUAFRIENDLY) || defined(DOXYGEN_SHOULD_IGNORE_THIS)
    void AppendLuaString(const char* pOtherString);
#endif
 
    void AppendInteger(int value);
 
    void AppendFloat(double value);
 
    void AppendEOL() { AppendCString(GetEOL()); }
 
    void AssureEndingPathDelimiter()
    {
                if (IsEmpty()) return;
#if OPERATING_SYSTEM == WINDOWS
        if (!EndsWith("\\") && !EndsWith("/")) AppendCString("\\");
#else
        if (!EndsWith("/")) AppendCString("/");
#endif
    }
    
    bool EncodeFromMacRoman();
    
    bool EncodeToMacRoman();
 
    bool SplitAt(int splitpointindex, FCString* pFirstString, FCString* pSecondString, bool includesplitposchar) const
    {
        /* Make sure the 0-based index position is valid */
        if (splitpointindex < -1) return false;
        if (splitpointindex >= GetLength()) return false;
        if ((pFirstString) && (pFirstString == pSecondString))
        {
            /* Reference to same destination object is not allowed */
            return false;
        }
        if (pFirstString && pSecondString)
        {
            /* Don't allow copying to "this" if both substrings are used */
            if (pFirstString == this) return false;
            if (pSecondString == this) return false;
        }
        if (pFirstString)
        {
            pFirstString->SetString(this);
            /* Check state of includesplitposchar, to decide if the
             split point should be included or not. */
            const int splitoffset = includesplitposchar ? 1 : 0;
            // ignore return value here, because TruncateAt returns false if there is nothing to truncate,
            // but we do not care about that. We have already checked for the other conditions that might
            // cause TruncateAt to fail.
            pFirstString->TruncateAt((std::max)(0, splitpointindex + splitoffset));
        }
        if (pSecondString)
        {
            pSecondString->SetString(this);
            if (splitpointindex >= 0)
                pSecondString->DeleteCharactersAt(0, splitpointindex + 1);
        }
        return true;
    }
    
    bool SplitToPathAndFile(FCString* pPathPart, FCString* pFilePart) const
    {
#if OPERATING_SYSTEM == WINDOWS
        // Little known fact: Windows recognizes either forward or back slash as a path delimiter.
        int pos = (std::max)(FindLast("/"), FindLast("\\"));        
#else
        int pos = FindLast("/");
#endif
        return SplitAt(pos, pPathPart, pFilePart, true);
    }
 
    void SetUserPath();
 
    void SetUserOptionsPath();
 
    void SetPluginsFolderPath() {  _SetFinalePath(FinPath_PluginDir); }
 
    void SetMusicFolderPath() { _SetFinalePath(FinPath_MusicDir); }
 
    void SetLibFolderPath() { _SetFinalePath(FinPath_LibDir); }
 
    void SetBackupFolderPath() { _SetFinalePath(FinPath_BackupDir); }
 
    void SetAutoSaveFolderPath() { _SetFinalePath(FinPath_AutoSaveDir); }
 
    void SetTemplateFolderPath() { _SetFinalePath(FinPath_TemplateDir); }       
 
    void SetTempFolderPath() { _SetFinalePath(FinPath_TempFilesDir); }
        
    void SetFontAnnotationFolderPath() { _SetFinalePath(FinPath_FontAnnotationDir); }
 
    void SetDocStylesFolderPath() { _SetFinalePath(FinPath_DocStylesDir); }
        
    void SetPercussionTypesFilePath() 
    {
        _SetFinalePath(FinPath_PercNoteTypesFile);
        Replace("\\\\", "\\");
    }
 
#if FXT_VERSION >= FINALEVERSION_2012
    void SetPreferencesFolderPath() { _SetFinalePath(FinPath_PreferencesDir); }
#endif
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    void SetRunningLuaFolderPath(lua_State *L);
#else
    void SetRunningLuaFolderPath();
#endif
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    void SetRunningLuaFilePath(lua_State *L);
#else
    void SetRunningLuaFilePath();
#endif
 
        
    void Clear() { SetUnicodeString(emptyUniCharStr); }
 
    int Compare(const FCString& value) const
    {
        const size_t maxSize = (std::max)(GetLength(), value.GetLength());
        return std::char_traits<_fcStringChar>::compare(_pStorage, value._pStorage, maxSize);
    }
 
    int CompareNoCase(const FCString& value) const
    {
        /* Please note!!! For some reason, _stricmp/strcasecmp don't
         * work correctly. It seems to hang under certain circumstances
         * on both platforms. */
        FCString string1, string2;
        string1.SetString(this);
        string2.SetString(&value);
        string1.ToLowerCase();
        string2.ToLowerCase();        
        return string1.Compare(string2);
    }
 
    bool ContainsString(const FCString& pSubString) const;
 
    [[deprecated]] bool ContainsCString(const char* pszSubString) const
    {
        FCString substring;
        substring.SetCString(pszSubString);
        return ContainsString(substring);
    }
 
    bool ContainsStringFrom(const FCString& pSubString, int startindex) const;
 
    [[deprecated]]bool ContainsCStringFrom(const char* pszSubString, int startindex) const
    {
        FCString substring;
        substring.SetCString(pszSubString);
        return ContainsStringFrom(substring, startindex);
    }
 
    int CalcStringPos(const FCString& subString) const
    {
                /* This method can't be size_t, since it must be able to return -1! */
        return CalcStringPosFrom(subString, 0);
    }
    
    int CalcLastStringPos(const FCString& subString) const
    {
        auto pos = _GetBasicStringView().rfind(subString._GetBasicStringView());
        if (pos == std::basic_string_view<eUniChar16>::npos)
            return -1;
        return static_cast<int>(pos);
    }
 
    [[deprecated]]int CalcCStringPos([[maybe_unused]]const FCString* pSubString, const char* pszSubString) const
    {
                /* This method can't return size_t, since it must be able to return -1! */
        FCString substring;
        substring.SetCString(pszSubString);
        return CalcStringPos(substring);
    }
 
    int CalcStringPosFrom(const FCString& subString, int startindex) const
    {
        /* This method can't return size_t, since it must be able to return -1! */
        auto pos = _GetBasicStringView().find(subString._GetBasicStringView(), static_cast<size_t>(startindex));
        if (pos == std::basic_string_view<eUniChar16>::npos)
            return -1;
        return static_cast<int>(pos);
    }
 
    [[deprecated]]int CalcCStringPosFrom(const char* pszSubString, int startindex) const
    {
                /* This method can't be size_t, since it must be able to return -1! */
        FCString substring;
        substring.SetCString(pszSubString);
        return CalcStringPosFrom(substring, startindex);
    }
 
#if OPERATING_SYSTEM == MAC_OS
    void ConvertToPascal(Str255& pascalString);
    
    void _SetCFURLRefPath(CFURLRef cfurl);
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    /* For internal use only. Converts a file path to CFURLRef */
    CFURLRef _GetPathCFURLRef() const;
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
#endif
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool ContainsEnigmaTextInsert(bool only_file_info_inserts = true) const;
 
    FCStrings* CreateEnigmaComponents() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCStrings> CreateEnigmaComponents_GC() const
    { return makeLuaSharedPtr(CreateEnigmaComponents()); }
#endif
 
    FCStrings* CreateEnigmaStrings(bool include_non_commands = false) const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCStrings> CreateEnigmaStrings_GC(bool include_non_commands) const
    { return makeLuaSharedPtr(CreateEnigmaStrings(include_non_commands)); }
#endif
#endif
 
    FCFontInfo* CreateLastFontInfo() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateLastFontInfo_GC() const
    { return makeLuaSharedPtr(CreateLastFontInfo()); }
#endif
 
    FCStrings* CreateParsedStrings(const char* pszSeparators) const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCStrings> CreateParsedStrings_GC(const char* pszSeparators) const
    { return makeLuaSharedPtr(CreateParsedStrings(pszSeparators)); }
#endif
   
    FCStrings* CreateRows() const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCStrings> CreateRows_GC() const
    { return makeLuaSharedPtr(CreateRows()); }
#endif
    
    bool DeleteCodePointAt(int index)
    { return DeleteCodePointsAt(index, 1); }
 
    bool DeleteCodePointsAt(int index, int count);
    
    bool DeleteCharacterAt(int index)
    { return DeleteCharactersAt(index, 1); }
 
    bool DeleteCharactersAt(int index, int count);
 
    void ExtractFileExtension()
    {
        int index = (int) GetLength() - 1;
        int count = 0;
        while (index >= 0)
        {
            eUniChar16 currentchar = GetCharacterAt(index);
            if (currentchar == '.')
            {
                FCString newstring;
                index ++;
                while (index < GetLength())
                {
                    newstring.AppendCharacter(GetCharacterAt(index));
                    index ++;
                }
                SetString(&newstring);
                return;
            }
            if (currentchar == '/') break;
            if (currentchar == '\\') break;
            index --;
            count ++;
        }
        Clear();
    }
 
    int FindFirst(const char* pszSubStr) const
    {
        twobyte firstchar = *pszSubStr;
        if (!firstchar) return -1;
        for (int i = 0; i < GetLength(); i++)
        {
            twobyte character = this->GetCharacterAt(i);
            if (character == firstchar)
            {
                int j = 1;
                bool identical = true;
                while (pszSubStr[j])
                {
                    twobyte testchar = pszSubStr[j];
                    if (this->GetCharacterAt(i + j) != testchar)
                    {
                        identical = false;
                        break;
                    }
                    j++;
                }
                if (identical) return i;
            }
        }
        return -1;
    }
 
    int FindLast(const char* pszSubStr) const
    {
        twobyte firstchar = *pszSubStr;
        if (!firstchar) return -1;
        int substrlength = (int) strlen(pszSubStr);
 
        for (int i = (int) (GetLength() - substrlength); i >= 0; i--)
        {
            twobyte character = this->GetCharacterAt(i);
            if (character == firstchar)
            {
                int j = 1;
                bool identical = true;
                while (pszSubStr[j])
                {
                    twobyte testchar = pszSubStr[j];
                    if (this->GetCharacterAt(i + j) != testchar)
                    {
                        identical = false;
                        break;
                    }
                    j++;
                }
                if (identical) return i;
            }
        }
        return -1;
    }
 
 
#ifdef PDK_FRAMEWORK_FORMAT
    int FormatCStringArgs(const char *fmt, va_list args);
    
    int FormatCString(const char *fmt, ...);
 
        int FormatString(FCString *fmt, ...);
#endif
 
    void FormatCharacterNumber(eUniChar32 character);
    
    const char* GetCString() const;
 
    const char* GetLuaString() const; // the Lua connector uses _CFunctionProxyGetter with this function
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int GetLuaString_CFunc(lua_State *L)
    {
        return _CFunctionProxyGetter<FCString, const char *, &FCString::GetLuaString>(L);
    }
#endif
 
    const char* GetUTF8String() const;
        
    bool CopyToUnicodeBuffer(eUniChar16 *pBuffer, int maxbufferlen = 0) const;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    UTRANSID _StartFinaleEdit() const;
    
    /* \brief For internal use only! Returns the internal UTF-16 buffer for the string. */
    eUniChar16* _GetUnicodeBuffer() const;
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
#if OPERATING_SYSTEM == MAC_OS
    void* GetNSString() const;
    
    void SetNSString(void* pNSString);
#endif
    
    int GetInteger(int index = 0) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    static int GetInteger_CFunc(lua_State* L)
    {
        return _CFunctionOneOptionalParameter<FCString, int, int, &FCString::GetInteger>(L, 0);
    }
#endif
    
    int GetHex() const;
 
    double GetFloat(int index = 0) const;
 
    eUniChar16 GetCharacterAt(int index) const;
    
    std::pair<eUniChar32, int> GetCodePointAt(int index) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    static int GetCodePointAt_CFunc(lua_State* L)
    {
        // argument 1 is `this`
        const FCString& selfStr = luabridge::Stack<const FCString&>::get(L, 1) LB3(.value());
        int index = luabridge::Stack<int>::get(L, 2) LB3(.value());
        auto [codepoint, nextIndex] = selfStr.GetCodePointAt(index);
        luabridge::Stack<eUniChar32>::push(L, codepoint) LB3(.throw_on_error());
        luabridge::Stack<int>::push(L, nextIndex) LB3(.throw_on_error());
        return 2;
    }
#endif
 
    int GetLength() const { return _length; }
 
    const char* GetEOL() const;
 
    [[deprecated]]void Insert(const char* pszString, int insertindex = 0);
 
    void InsertString(const FCString* pString, int insertindex = 0);
 
    bool IsDigit(int index) const;
 
    bool IsAllDigits() const;
 
    bool IsNumber() const;
 
    [[deprecated]]bool IsEqualCString(const char* pszString) const;
 
    bool IsEqual(const char* pszString) const { return IsEqualString(pszString); }
 
    bool IsEqualString(const FCString& value) const { return value == *this; };
 
    bool IsCharacter(int index, eUniChar32 character) const;
 
    bool IsCharacters(int index, const char *pChars) const;
 
    bool IsEmpty() const { return (GetLength() == 0); }
 
    bool IsWhitespace(int index) const;
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool IsEnigmaCommand() const
    {
        if (!IsCharacters(0, "^")) return false;
        if (IsCharacters(1, "^")) return false;
        return true;
    }
 
    bool IsEnigmaFont() const;
 
    bool IsEnigmaFileInfoTitle() const;
 
    bool IsEnigmaFileInfoSubtitle() const;
 
    bool IsEnigmaFileInfoComposer() const;
 
    bool IsEnigmaFileInfoArranger() const;
 
    bool IsEnigmaFileInfoLyricist() const;
 
    bool IsEnigmaFileInfoCopyright() const;
 
    bool IsEnigmaTextInsert(bool only_file_info_inserts = true) const;
#endif
 
#if OPERATING_SYSTEM == WINDOWS
    bool LoadResource(int resourceID, HINSTANCE dllinstance = 0);
#endif
#if OPERATING_SYSTEM == MAC_OS
    bool LoadResource(const char* resourceID,
                        const char* pszResourceFileName = NULL,
                        const char* pszTableName = NULL);
#endif
 
#if OPERATING_SYSTEM == WINDOWS
    static int LoadIntegerResource(int resourceID, int defaultValue, HINSTANCE dllinstance = 0);
#endif
#if OPERATING_SYSTEM == MAC_OS
    static int LoadIntegerResource(const char* resourceID,
                                   int defaultValue,
                                   const char* pszResourceFileName = NULL,
                                   const char* pszTableName = NULL);
#endif
 
    bool MakeSubString(int startindex, int substringlength, FCString* pDestinationString); // no `const` because pDestinationString can be this
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool ReplaceCategoryFonts(FCCategoryDef* pCategoryDef, int fontmode, bool replacefonttag);
#endif
 
 
    void SetCString(const char* pszBuffer, int maxchars = -1);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
        void _SetWCHARString(const WCHAR* pCharBuffer);
#endif
#endif
 
    void SetLuaString(const char* pszBuffer) { SetUTF8String(pszBuffer); }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int SetLuaString_CFunc(lua_State *L)
    {
        return _CFunctionProxySetter<FCString, const char *, &FCString::SetLuaString>(L);
    }
#endif
    
    void SetUTF8String(const char* pszBuffer);
 
    void SetCharacterAt(int index, eUniChar16 newcharacter);
 
    void SetUnicodeString(const eUniChar16 *pChar, int maxchars = -1);
 
    void SetInteger(int i);
 
    void SetHex(int number, int bitwidth);
    
    void SetFloat(double f);
 
#ifdef PDK_FRAMEWORK_PREFS
    void SetMeasurement(double value, twobyte unit);
    
    double GetMeasurement(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) unit) const;
#endif  /* #ifdef PDK_FRAMEWORK_PREFS */
 
    void SetString(const FCString* pString);
 
    FCString* CreateCopy();
 
    bool SetCharacterUpperCase(int index);
    
    void SetCurrentTime()
    {
        time_t     now = time(0);
        struct tm  tstruct;
        char       buf[80];
        tstruct = *localtime(&now);
        strftime(buf, sizeof(buf), "%X", &tstruct);
        SetCString(buf);
    }
 
    bool Replace(const char* pszSource, const char* pszReplacement);
 
    bool EndsWith(const char* pszString) const;
 
    bool EndsWithString(const FCString* pString) const;
 
    bool StartsWith(const char* pszString) const;
 
    bool StartsWithString(const FCString* pString) const;
 
    void ToUnicode(eUniChar16* pBuffer, int maxsize) const
    {
        int len = GetLength();
        if (len > maxsize - 1) len = maxsize - 1;
        for (int i = 0; i < len; i++) pBuffer[i] = GetCharacterAt(i);
        pBuffer[len] = 0;
    }
 
    void ToLowerCase();
 
    void ToUpperCase();
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool TrimEnigmaTags();
#endif
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool TrimEnigmaFontTags();
#endif
 
    void TrimWhitespace();
 
    void TrimLinefeed();
 
 
        bool TruncateAt(int newlength) 
    {
        if (newlength < 0 || newlength >= GetLength()) return false;
        _length = newlength;
        _pStorage[_length] = 0;  /* Make sure there's a NULL termination in the unicode buffer */
        return true;
    }
    
    bool TruncateEnd(int count)
    {
        if (count < 1) return false;
        return TruncateAt(GetLength() - count);
    }
 
    void TruncateWidth(int maxlength, int prefixchars)
    {
        if (_length <= maxlength) return;
        if (prefixchars + 3 > maxlength) return;
        if (prefixchars < -1) return;
        FCString resultstring;
        for (int i = 0; i < prefixchars; i++)
        {
            resultstring.AppendCharacter(this->GetCharacterAt(i));
        }
        resultstring.AppendCString("...");
        int startindex = _length - maxlength + prefixchars + 3;
        for (int i = startindex; i < _length; i++)
        {
            resultstring.AppendCharacter(this->GetCharacterAt((int) i));
        }
        this->SetString(&resultstring);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS      
        static EVERSION _GetFinPathVersion();
 
        bool MakeSpecFromFilePath(void *pFinPathSpec, EVERSION convertversion) const;
 
        bool MakeFullFilePath(const void* pFinPathSpec, EVERSION convertversion);
 
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS    */
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutInt("Length: ", (int) _length);
        DebugOutInt("Storage length: ", (int) _storagelength);
        DebugOutPtr("_pStorage: ", _pStorage);
        DebugOutString("String contents: ", GetCString());
    }
#endif
 
};
 
 
 
class FCSettingsPair : public __FCBase
{
    FCString _keystring;
    FCString _valuestring;
public:
    const char* ClassName() const override { return "FCSettingsPair"; }
 
    FCSettingsPair(FCString* pLeftString, FCString* pRightString) : __FCBase()
    {
        _keystring.SetString(pLeftString);
        _keystring.TrimWhitespace();
        _valuestring.SetString(pRightString);
        _valuestring.TrimWhitespace();
    }
 
    FCString* GetKeyString() { return &_keystring; }
 
    FCString* GetValueString() { return &_valuestring; }
 
    void SetValueString(FCString* pString) { _valuestring.SetString(pString); }
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutString("Key: ", GetKeyString());
        DebugOutString("Value: ", GetValueString());
    }
#endif
};
 
 
#ifdef PDK_FRAMEWORK_ENTRIES
class FCNoteEntry;
#endif
 
class FCCell;
 
class FCCellMetrics : public __FCBase
{
    bool _loaded;
 
    EMeasureMetrics2009a _metrics;
    
    // This value remains global because it is a global condition in Finale. Whichever concurrently
    // running script sets it, the next internal call to metrics will rebuild them.
    static bool _metricsshouldupdate;
    
public:
    const char* ClassName() const override { return "FCCellMetrics"; }
 
    FCCellMetrics() : __FCBase()
    {
        memset(&_metrics, 0, sizeof(_metrics));
        _loaded = false;
    }
 
    virtual ~FCCellMetrics()
    {
        FreeMetrics();
    }
 
    static void MarkMetricsForRebuild() { _metricsshouldupdate = true; }
 
    bool LoadAtCell(FCCell* pCell);
 
#ifdef PDK_FRAMEWORK_ENTRIES
    bool LoadAtEntry(FCNoteEntry* pEntry);
#endif
 
    Int100 GetHorizontalStretch() const
    {
        return _metrics.measMetrics.horzPercent;
    }
 
    Evpu32 GetTopStafflinePos() const
    {
        return _metrics.measMetrics.fipTopStaffLine;
    }
 
    Evpu32 GetBottomStafflinePos() const
    {
        return _metrics.measMetrics.fipBottom;
    }
 
    Evpu32 GetReferenceLinePos() const
    {
        return _metrics.measMetrics.fipTop;
    }
    
    Int100 GetStaffScaling() const
    {
        return _metrics.measMetrics.lperc;
    }
 
    Int100 GetSystemScaling() const
    {
        return _metrics.measMetrics.percent;
    }
 
    int GetAttachmentCount() const
    {
        return _metrics.attachCount;
    }
 
    int GetMusicStartPos() const
    {
        return _metrics.measMetrics.meposadj;
    }
 
    int GetLeftEdge() const
    {
        return _metrics.leftEdge;
    }
 
    int GetWidth() const
    {
        return _metrics.measMetrics.mewidth;
    }
 
    int GetMusicWidth() const
    {
        return _metrics.measMetrics.scalewidth;
    }
 
    int GetFrontRepeatWidth() const
    {
        return _metrics.measMetrics.frontRepWidth;
    }
 
    int GetBackRepeatWidth() const
    {
        return _metrics.measMetrics.backRepWidth;
    }
 
    int GetRightBarlineWidth() const
    {
        return _metrics.measMetrics.barWidth;
    }
    
    int GetStaffSystem() const
    {
        return _metrics.measMetrics.ssys;
    }
 
    Evpu32 GetSystemTopPos() const
    {
        return _metrics.measMetrics.ssysTop;
    }
 
    Evpu32 GetSlotNumber() const
    {
        return _metrics.measMetrics.slot;
    }
 
    bool GetAttachment(__FCBaseData* pBaseDataObject, fourbyte the_id, EAttachment* pAttachment, bool stop = false)
    {
        if (_metrics.attachCount == 0) return false;
        for (int i = 0; i < _metrics.attachCount; i++)
        {
            EAttachment* pTest = &_metrics.pAttach[i];
            if (pTest->tag != pBaseDataObject->Tag()) continue;            
            if (pTest->id != the_id) continue;
            if (stop)
            {
                if (!GetBitFlag(pTest->flags, EATTACH_STOP_SHAPE)) continue;
            }
            memcpy(pAttachment, pTest, sizeof(EAttachment));
            return true;
        }
        return false;
    }
 
    void FreeMetrics();
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutInt("Horizontal stretch: ", GetHorizontalStretch());
    }
#endif
};
 
 
#ifdef PDK_FRAMEWORK_ENTRIES
class FCEntryMetrics : public __FCBase
{
        bool _directaccess;  /* If true, Load() and FreeMetrics() will not work. The data was copied through _EnableDirectAccessMode(). */
        ENTNUM _directaccess_entnum;    /* The connected entry ID in direct access mode */
 
    bool _loaded;
    EEntryMetrics2009a _metrics2009a;
#if FXT_VERSION >= FINALEVERSION_2014
    EEntryMetrics2014 _metrics2014;
#endif
        
    // This value remains global because it is a global condition in Finale. Whichever concurrently
    // running script sets it, the next internal call to metrics will rebuild them.
    static bool _updatemetrics;
 
    EVERSION _VersionToUse() const;
 
    EEntryMetrics2009a* _GetBasicMetricsPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
            return (EEntryMetrics2009a*) &_metrics2014;
        else
#endif
            return (EEntryMetrics2009a*) &_metrics2009a;
 
    }
public:
    const char* ClassName() const override { return "FCEntryMetrics"; }
 
    FCEntryMetrics();
        
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        /* For internal use only. If this method is used, it should be called immediatelly after the constructor. */
        void _EnableDirectAccessMode(EEntryMetrics2014* pMetrics, ENTNUM entrynumber);
 
        /* For internal use only. Only used in direct access mode. */
        ENTNUM _GetConnectedEntryNumber() { return _directaccess_entnum; }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    virtual ~FCEntryMetrics()
    {
        FreeMetrics();
    }
 
    static void MarkMetricsForRebuild() { _updatemetrics = true; }
 
    bool Load(const FCNoteEntry* pEntry);
    
    int CalcLeftmostNotePosition();
    
    int GetAttachmentCount() const
    {
        return _GetBasicMetricsPtr()->attachCount;
    }
 
    bool GetAttachment(__FCBaseData* pBaseDataObject, fourbyte the_id, EAttachment* pAttachment, bool stop = false)
    {        
        if (_GetBasicMetricsPtr()->attachCount == 0) return false;
        for (int i = 0; i < _GetBasicMetricsPtr()->attachCount; i++)
        {
            EAttachment* pTest = &_GetBasicMetricsPtr()->pAttach[i];
            if (pTest->tag != pBaseDataObject->Tag()) continue;            
            if (pTest->id != the_id) continue;
            if (stop)
            {
                if (!GetBitFlag(pTest->flags, EATTACH_STOP_SHAPE)) continue;
            }
            memcpy(pAttachment, pTest, sizeof(EAttachment));
            return true;
        }
        return false;
    }
 
 
    int GetTopPosition() const
    {
        if (_GetBasicMetricsPtr()->headRect.top > _GetBasicMetricsPtr()->stemRect.top) return _GetBasicMetricsPtr()->headRect.top;
        return _GetBasicMetricsPtr()->stemRect.top;
    }
 
    int GetBottomPosition() const
    {
        if (_GetBasicMetricsPtr()->headRect.bottom < _GetBasicMetricsPtr()->stemRect.bottom) return _GetBasicMetricsPtr()->headRect.bottom;
        return _GetBasicMetricsPtr()->stemRect.bottom;
    }
 
    int GetStemBottomPosition() const
    {
        return _GetBasicMetricsPtr()->stemRect.bottom;
    }
 
    int GetStemTopPosition() const
    {
        return _GetBasicMetricsPtr()->stemRect.top;
    }
 
    int GetLeftPosition() const
    {
        return _GetBasicMetricsPtr()->headRect.left;
    }
 
    int GetRightPosition() const
    {
       return _GetBasicMetricsPtr()->headRect.right;
    }
 
    int GetStemLeftPosition() const
    {
        return _GetBasicMetricsPtr()->stemRect.left;
    }
 
    int GetStemRightPosition() const
    {
       return _GetBasicMetricsPtr()->stemRect.right;
    }
 
    int GetLastDotPosition() const
    {
        return _GetBasicMetricsPtr()->lastDot;
    }
 
    int GetFirstAccidentalPosition() const
    {
        return _GetBasicMetricsPtr()->firstAcci;
    }
 
    FLAG_32 GetEntryFlags()
    {
        return _GetBasicMetricsPtr()->entryFlags;
    }
 
    ENoteMetrics* FindNoteMetrics(twobyte noteID);
 
#if FXT_VERSION >= FINALEVERSION_2014
    ENoteMetrics2014* FindNoteMetrics2014(twobyte noteID);
#endif
 
    int GetNoteCount() const
    {
        return _GetBasicMetricsPtr()->numNotes;
    }
 
    int GetNoteLeftPosition(int index) const;
    
    int GetNoteWidth(int index) const;
    
    int GetNoteCenterVerticalPos(int index) const;
    
    eNoteID GetNoteID(int index) const;
 
    JWERECT* GetStemRect()
    {
        if (!_loaded) return NULL;
        return &_GetBasicMetricsPtr()->stemRect;
    }
 
    JWERECT* GetNoteheadRect()
    {
        if (!_loaded) return NULL;
        return &_GetBasicMetricsPtr()->headRect;
    }
 
    void FreeMetrics();
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();       
    }
#endif
};
#endif
 
 
 
class FCArticulationDef;
 
class FCTextMetrics : public __FCBase
{
#if FXT_VERSION >= FINALEVERSION_25
    ETextMetrics _textMetrics;
#endif
public:
 
    FCTextMetrics() : __FCBase() {}
    
    bool LoadString(const FCString* pText, const FCFontInfo* pFont, double percent);
    
    bool LoadSymbol(eUniChar16 symbolchar, FCFontInfo* pFont, double percent);
    
    bool LoadArticulation(FCArticulationDef* pArticDef, bool flipped, double percent);
    
    void CopyFrom(FCTextMetrics* pTextMetrics);
    
    double GetAdvanceWidthPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.width;
#else
        return 0;
#endif
    }
    
    double GetLeftPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.left;
#else
        return 0;
#endif
    }
    
    double GetRightPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.right;
#else
        return 0;
#endif
    }
    
    double GetTopPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.top;
#else
        return 0;
#endif
    }
    
    double GetBottomPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.bottom;
#else
        return 0;
#endif
    }
    
    double GetAdvanceWidthEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eWidth;
#else
        return 0;
#endif
    }
    
    double GetLeftEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eLeft;
#else
        return 0;
#endif
    }
    
    double GetRightEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eRight;
#else
        return 0;
#endif
    }
    
    double GetTopEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eTop;
#else
        return 0;
#endif
    }
    
    double GetBottomEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eBottom;
#else
        return 0;
#endif
    }
    
    double CalcHeightPoints() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetTopPoints()-GetBottomPoints();
#else
        return 0;
#endif
    }
    
    double CalcWidthPoints() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetRightPoints()-GetLeftPoints();
#else
        return 0;
#endif
    }
    
    double CalcHeightEVPUs() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetTopEVPUs()-GetBottomEVPUs();
#else
        return 0;
#endif
    }
    
    double CalcWidthEVPUs() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetRightEVPUs()-GetLeftEVPUs();
#else
        return 0;
#endif
    }
    
    const char* ClassName() const override { return "FCTextMetrics"; }
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutFloat("Advance Width: ", GetAdvanceWidthPoints());
        DebugOutFloat("Left: ", GetLeftPoints());
        DebugOutFloat("Right: ", GetRightPoints());
        DebugOutFloat("Top: ", GetTopPoints());
        DebugOutFloat("Bottom: ", GetBottomPoints());
        
        DebugOutFloat("Advance Width EVPU: ", GetAdvanceWidthEVPUs());
        DebugOutFloat("Left EVPU: ", GetLeftEVPUs());
        DebugOutFloat("Right EVPU: ", GetRightEVPUs());
        DebugOutFloat("Top EVPU: ", GetTopEVPUs());
        DebugOutFloat("Bottom EVPU: ", GetBottomEVPUs());
    }
#endif
};
 
 
class FCNumber : public __FCBase
{
        int _intvalue;
        double _floatvalue;
    public:
        const char* ClassName() const override { return "FCNumber"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_NUMBER; }
 
        FCNumber(double value) : __FCBase()
        {
            /* A separate int and double curbs precision issues that cause unexpected rounding near integers. */
            _intvalue = static_cast<int>(value);
            _floatvalue = value;
        }
 
        void SetInt(int value)
        {
            _intvalue = value;
            _floatvalue = static_cast<double>(value);
        }
    
        void SetFloat(double value)
        {
            _intvalue = static_cast<int>(value);
            _floatvalue = value;
        }
 
        int GetInt() const { return _intvalue; }
    
        double GetFloat() const { return _floatvalue; }
 
    
#ifdef PDK_FRAMEWORK_DEBUG
        void DebugDump() override
        {
            __FCBase::DebugDump();
            DebugOutFloat("Floating value", _floatvalue);
            DebugOutInt("Integer value: ", _intvalue);
        }
#endif
};
 
 
class FCPoint : public __FCBase
{
    double _x;
    double _y;
public:
    const char* ClassName() const override { return "FCPoint"; }
    
    FCPoint(double x, double y) : __FCBase(), _x(x), _y(y) {}
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int FCPoint_tostring(lua_State* L)
    {
        FCPoint* pThis = luabridge::Stack<FCPoint*>::get(L, 1) LB3(.value());
        FCString strX; strX.SetMeasurement(pThis->GetX(), UNIT_EVPUS);
        FCString strY; strY.SetMeasurement(pThis->GetY(), UNIT_EVPUS);
        std::string s = std::string(pThis->ClassName()) + ": (" + strX.GetLuaString() + ", " + strY.GetLuaString() + ")";
        luabridge::Stack<std::string>::push(L, s).throw_on_error();
        return 1;
    }
#endif
    
    void SetX(double value) { _x = value; }
 
    void SetY(double value) { _y = value; }
 
    double GetX() const { return _x; }
 
    double GetY() const { return _y; }
 
    void MoveX(double value) { _x += value; }
 
    void MoveY(double value) { _y += value; }
};
 
 
 
class FCDocument;
 
class FCPrintSettings : public __FCBase
{
    FinPrintSettings _settings;
public:
    const char* ClassName() const override { return "FCPrintSettings"; }
 
    enum PRINTODDEVENMODES
    {
        PRINTODDEVEN_ALL = 0,
 
        PRINTODDEVEN_ODD = 1,
 
        PRINTODDEVEN_EVEN = 2
    };
 
    FCPrintSettings() : __FCBase()
    {
        _settings.copies = 1;
        _settings.startPage = 1;
        _settings.endPage = 1000;
    }
 
    /* Getters */
 
    twobyte GetCopyCount() const { return _settings.copies; }
 
    bool GetColor() const { return _settings.bPrintColor != 0; }
 
    twobyte GetStartPage() const { return _settings.startPage; }
 
    twobyte GetEndPage() const { return _settings.endPage; }
 
    bool GetReverse() const { return _settings.reverse != 0; }
 
    bool GetDrawCropMarks() const { return _settings.cropMarks != 0; }
 
    bool GetDrawRegistrationMarks() const { return _settings.regMarks != 0; }
 
    bool GetDrawFileName() const { return _settings.regFileName != 0; }
 
    bool GetTile() const { return _settings.tile != 0; }
 
    twobyte GetLayoutCount() const { return _settings.nUp; }
 
    Evpu32 GetTileOverlap() const { return _settings.userOverlap; }
 
    bool GetFitWithinMargins() const { return _settings.bFitWithinMargins != 0; }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PRINTODDEVENMODES
#else
    twobyte
#endif
    GetOddEvenMode() const { return (PRINTODDEVENMODES) _settings.oddEven; }
 
    const char* GetPageRangeString() const
    {
        return _settings.pageRangeString;
    }
 
    /* Setters */
 
    void SetCopyCount(twobyte copies)
    {
        if (copies < 0) return;
        if (copies > 100) return;
        _settings.copies = copies;
    }
 
    void SetColor(bool state) { _settings.bPrintColor = state; }
 
    void SetStartPage(twobyte startpage)
    {
        if (startpage < 1) return;
        _settings.startPage = startpage;
    }
 
    void SetEndPage(twobyte endpage)
    {
        if (endpage < 1) return;
        _settings.endPage = endpage;
    }
 
    void SetReverse(bool state) { _settings.reverse = state; }
 
    void SetDrawCropMarks(bool state) { _settings.cropMarks = state; }
 
    void SetDrawRegistrationMarks(twobyte state) { _settings.regMarks = state; }
 
    void SetDrawFileName(bool state) { _settings.regFileName = state; }
 
    void SetTile(bool state) { _settings.tile = state; }
 
    void SetLayoutCount(twobyte count)
    {
        switch (count) {
            case 0:
            case 1:
            case 2:
            case 4:
                _settings.nUp = count;
                break;
            default:
                break;
        }
    }
 
    void SetTileOverlap(Evpu32 value)
    {
        if (value < 0) return;
        _settings.userOverlap = value;
    }
 
    void SetFitWithinMargins(bool state) { _settings.bFitWithinMargins = state; }
 
    void SetOddEvenMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
            PRINTODDEVENMODES
#else
            twobyte
#endif
    value
    )
    {
        switch (value)
        {
            case PRINTODDEVEN_ALL:
            case PRINTODDEVEN_EVEN:
            case PRINTODDEVEN_ODD:
                _settings.oddEven = value;
                break;
            default:
                break;
        }
    }
 
    void SetPageRangeString(const char* pszString)
    {
        if (!pszString) return;
        strncpy(_settings.pageRangeString, pszString, sizeof(_settings.pageRangeString));
        _settings.pageRangeString[sizeof(_settings.pageRangeString) - 1] = 0;
    }
 
 
    /* Misc methods */
 
    bool PrintCurrent();
 
    bool PrintDocument(FCDocument* pDocument);
};
 
 
 
 
class FCSystemGlyphInfo : public __FCBase
{
    ufourbyte _glyphnumber;  /* The glyph number that should be loaded. */
    float _height, _width, _left, _bottom;
    float _maxascent, _maxdescent;
public:
    FCSystemGlyphInfo() : __FCBase()
    {
        _glyphnumber = 0;
        _height = _width = 0;
        _left = _bottom = 0;
        _maxascent = _maxdescent = 0;
    };
    
    bool LoadInfo(FCFontInfo* pFontInfo, ufourbyte glyphno);
    
    void _SetHeight(float h) { _height = h; }
    
    void _SetWidth(float w) { _width = w; }
    
    void _SetLeft(float l) { _left = l; }
    
    void _SetBottom(float b) { _bottom = b; }
    
    void _SetMaxAscent(float b) { _maxascent = b; }
    
    void _SetMaxDescent(float b) { _maxdescent = b; }
    
    /***********/
    /* GETTERS */
    /***********/
    
    ufourbyte GetGlyphNumber() { return _glyphnumber; }
    
    float GetWidth() { return _width; }
    
    float GetHeight() const { return _height; }
    
    float GetLeft() const { return _left; }
    
    float GetBottom() const { return _bottom; }
    
    float GetRight() const { return _left+_width; }
    
    float GetTop() const { return _bottom+_height; }
    
    float GetMaxAscent() { return _maxascent; }
    
    float GetMaxDescent() { return _maxdescent; }
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutHex("Glyph Number: ", GetGlyphNumber());
        DebugOutFloat("Width: ", GetWidth());
        DebugOutFloat("Height: ", GetHeight());
        DebugOutFloat("Left: ", GetLeft());
        DebugOutFloat("Bottom: ", GetBottom());
        DebugOutFloat("Max Ascender: ", GetMaxAscent());
        DebugOutFloat("Max Descender: ", GetMaxDescent());
    }
#endif
};
 
 
class FCFontDialog : public __FCBase
{
    FCUI* _pUI;
    FCFontInfo* _pUserFontInfo;
    FCString _samplestring;
    bool _usesizes;
    bool _usestyles;
    
public:
    const char* ClassName() const override { return "FCFontDialog"; }
 
    FCFontDialog(FCUI* pUI, FCFontInfo* pFontInfo) : __FCBase()
    {
        _pUI = pUI;
        _pUserFontInfo = pFontInfo;
        _usesizes = true;
        _usestyles = true;
    }
    
    /* GETTERS */
    
    bool GetUseSizes() const { return _usesizes; }
    
    bool GetUseStyles() const { return _usestyles; }
    
    FCFontInfo* GetFontInfo() const { return _pUserFontInfo; }
    
    void GetSampleString(FCString* pString)
    {
        if (!pString) return;
        pString->SetString(&_samplestring);
    }
    
    /* SETTERS */
    
    void SetUseSizes(bool state)  { _usesizes = state; }
    
    void SetUseStyles(bool state) { _usestyles = state; }
    
    void SetFontInfo(FCFontInfo* pFontInfo) { _pUserFontInfo = pFontInfo; }
    
    void SetSampleString(FCString* pString) { _samplestring.SetString(pString); }
    
    bool Execute();
};
 
class FCRange : public __FCBase
{
private:
    int _start;
    int _length;
    
public:
    const char* ClassName() const override { return "FCRange"; }
 
    FCRange(int start = 0, int length = 0) : __FCBase(), _start(start), _length(length) {}
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static FCRange* FCRange_Lua(void* ptr, lua_State *L)
    {
        const int numArgs = lua_gettop(L);
        const int start = (numArgs <= 2) ? 0 : luabridge::Stack<int>::get(L, 2) LB3(.value());
        const int length = (numArgs <= 3) ? 0 : luabridge::Stack<int>::get(L, 3) LB3(.value());;
        return new(ptr) FCRange(start, length);
    }
#endif
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int FCRange_tostring(lua_State* L)
    {
        FCRange* pThis = luabridge::Stack<FCRange*>::get(L, 1) LB3(.value());
        std::string s = std::string(pThis->ClassName()) + ": (" + std::to_string(pThis->GetStart()) + ", " + std::to_string(pThis->GetLength()) + ")";
        luabridge::Stack<std::string>::push(L, s).throw_on_error();
        return 1;
    }
#endif
 
    int GetStart() const { return _start; }
    
    int GetLength() const { return _length; }
    
    int GetEnd() const { return _start + _length; }
 
    void SetStart(int val) { _start = val; }
    
    void SetLength(int val) { _length = val; }
};
 
#endif  /* _FF_BASE_H */