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 */

#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
#define _LUACODE(x) x
#define _ENUMCODE(x)
#endif
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
#define _LUACODE(x)
#define _ENUMCODE(x) x
#endif


/* Forward declararations of some required classes. */
class FCString;
class FCUI;
class FCNumbers;

class __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_ALLOTMENT,
                FCID_ARTICULATION,
                FCID_ARTICULATIONDEF,
                FCID_BACKWARDREPEAT,
                FCID_BASELINE,
                FCID_BEAMMOD,
                FCID_BEATCHARTELEMENT,
                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_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_KEYSIGNATURE,
                FCID_LAYERPREFS,
                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_PERCUSSIONNOTEMOD,
                FCID_PIANOBRACEPREFS,
                FCID_PLAYBACKPREFS,
        FCID_RAWTEXT,
                FCID_REPEATPREFS,
                FCID_SECONDARYBEAMBREAKMOD,
                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() { return FCID_UNKNOWN; }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY
#ifndef DOXYGEN_SHOULD_IGNORE_THIS      

        int _Lua_GetClassID() { 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() { return "__FCBase"; }
    
    __FCBase()
    {
        _UserData = NULL;
        _UserData2 = NULL;
    }

    /* 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 DebugMsgDigit(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 DebugOutDigit(const char* pszPrefixText, int i);

    static void DebugOutFloat(const char* pszPrefixText, float 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; }

    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(__FCBase* pCompareObject) 
        { 
                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(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(tinyxml2::XMLElement* pParentNode) { return false; }
#endif
};

class __FCBaseData : public __FCBase {
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EXTAG _customtag;
#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:

        virtual const PDKFRAMEWORK_CLASSID GetClassID() = 0; /* Force all inherited class to have this method implementation */
    
    EDOCID GetConnectedDocID() const
    {
        return _connecteddocID;
    }
    
    bool VerifyConnectedDocID();
    
    virtual EXTAG Tag() = 0;

    virtual EVERSION EnigmaVersion() { return FXT_VERSION; }

    virtual int DataSizeLoad() = 0;

    virtual int DataSizeSave();


    virtual const char* ClassName() { 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() { 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; }

    __FCBaseData* CreateClone();

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCBase::DebugDump();
        DebugOutPtr("Data block: ", _datablock);
        DebugOutDigit("Loaded size: ", (int) _GetLoadedSize());
    }

    virtual void DebugDataDump()
    {
        __FCBase::DebugDataDump();
        if (_datablock) DebugOutBlock(_datablock, 0, _GetLoadedSize());
    }

    virtual void DebugDataByteArrayDump()
    {
        __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];
            sprintf(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];
                sprintf(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

    FCNumbers* CreateRawDataDump_GC();
#endif

};


class __FCInci : public __FCBaseData
{
public:
    virtual const char* ClassName() { return "__FCInci"; }

    bool Load(CMPER cmper, twobyte inci);
};


class FCString;

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. */
    float                       _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:
    virtual const char* ClassName() { return "FCFontInfo"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_FONTINFO; }

        FCFontInfo();

    static fourbyte GetSystemTextEncoding();


        void CopyFrom(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*/

    twobyte GetSize() const { return (twobyte) _size; }
    
    float 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;

    const char* GetName() const;

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

    FCString* CreateEnigmaString_GC(FCString* pFontTagString = NULL);
#endif

    void MakeEnigmaStyleString(FCString* pString);

    void MakeEnigmaSizeString(FCString* pString);

    FCString* CreateEnigmaStyleString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateEnigmaStyleString_GC();
#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; }

#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 char* pszName);
    
    void SetFontID(EFONTID fontID);

    void SetNameString( FCString* pString );

    void SetNameByID(twobyte id);

    void SetSize(twobyte fontsize) { _size = (twobyte) fontsize; }
        
    void SetSizeFloat(float 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);
    
    bool IsNameString(FCString* pTestName);

    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 IsIdenticalTo(FCFontInfo* pCompareWith);

    void MakeDefaultMusicFont();

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump();
#endif
};




class FCStrings;
class FCCategoryDef;

class FCString : public __FCBase
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        int _length;
        int _storagelength;   // Maximum characters that can fit in the storage
        eUniChar16* _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
    void* _nsstringobject;  /* A retained NSString* object for GetNSString() */
#endif

        void _DeleteStorage();

        void _ExpandStorageIfNecessary(int minimumlength);

        bool _SetFinalePath(FinPath pathconstant);

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */


#ifdef PDK_FRAMEWORK_TINYXML

    virtual void StoreToXML(tinyxml2::XMLElement* pParentNode) {
        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. */
    virtual bool ReadFromXML(tinyxml2::XMLElement* pParentNode)
    {
        return ReadXML_StringAttribute(pParentNode, "FCString", this);
    }
#endif

public:
    virtual const char* ClassName() { return "FCString"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STRING; }


    FCString() : __FCBase()
    {
        _length = 0;
        _storagelength = 0;
        _pStorage = NULL;
        _pTempCBuffer = NULL;
        _pTempCUTF8Buffer = NULL;
#if OPERATING_SYSTEM == MAC_OS
        /* Mac - Cocoa */
        _nsstringobject = 0;
#endif
        Clear();
    }

    FCString(const char* pszCString) : __FCBase()
    {
        _length = 0;
        _storagelength = 0;
        _pStorage = NULL;
        _pTempCBuffer = NULL;
        _pTempCUTF8Buffer = NULL;
#if OPERATING_SYSTEM == MAC_OS
        /* Mac - Cocoa */
        _nsstringobject = 0;
#endif
        Clear();
        SetCString(pszCString);
    }

    FCString(const eUniChar16* pszCString) : __FCBase()
    {
        _length = 0;
        _storagelength = 0;
        _pStorage = NULL;
        _pTempCBuffer = NULL;
        _pTempCUTF8Buffer = NULL;
#ifdef PDK_FRAMEWORK_COCOA
        _nsstringobject = 0;
#endif
        Clear();
        SetUnicodeString(pszCString);
    }


    virtual ~FCString();

        static const eUniChar16 emptyUniCharStr[];

    void AppendCharacter(eUniChar16 character);

    void AppendString(FCString* pOtherString);

    void AppendCString(const char* pOtherString);
  
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    void AppendLuaString(const char* pOtherString);
#endif

    void AppendInteger(int value);

    void AppendFloat(float value);

    void AppendEOL() { AppendCString(GetEOL()); }

    void AssureEndingPathDelimiter()
    {
                if (IsEmpty()) return;
#if OPERATING_SYSTEM == WINDOWS
    if (!EndsWith("\\")) AppendCString("\\");
#else
    if (!EndsWith("/")) AppendCString("/");
#endif
    }

    bool SplitAt(int splitpointindex, FCString* pFirstString, FCString* pSecondString, bool includesplitposchar)
    {
        /* Make sure the 0-based index position is valid */
        if (splitpointindex < 0) 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. */
            int splitoffset = 0;
            if (includesplitposchar) splitoffset = 1;
            pFirstString->TruncateAt(splitpointindex + splitoffset);
        }
        if (pSecondString)
        {
            pSecondString->SetString(this);
            pSecondString->DeleteCharactersAt(0, splitpointindex + 1);
        }
        return true;
    }
    
    bool SplitToPathAndFile(FCString* pPathPart, FCString* pFilePart)
    {
#if OPERATING_SYSTEM == WINDOWS
        int pos = FindLast("\\");
#else
        int pos = FindLast("/");
#endif
        return SplitAt(pos, pPathPart, pFilePart, true);
    }

    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

    
    void SetRunningLuaFolderPath();

    void SetRunningLuaFilePath();

        
    void Clear() { SetCString(""); }

    int Compare(FCString* pString2)
    {
        return strcmp(this->GetCString(), pString2->GetCString());
    }

    int CompareNoCase(FCString* pString2)
    {
        /* Please note!!! For some reason, _stricmp/strcasecmp don't
         * work correctly. It seems to hang under certain circumstances
         * on both platforms. */
        if (!pString2) return 1;
        FCString string1, string2;
        string1.SetString(this);
        string2.SetString(pString2);
        string1.ToLowerCase();
        string2.ToLowerCase();        
        return strcmp(string1.GetCString(), string2.GetCString());
    }

    bool ContainsString(FCString* pSubString);

    bool ContainsCString(const char* pszSubString)
    {
        FCString substring;
        substring.SetCString(pszSubString);
        return ContainsString(&substring);
    }

    bool ContainsStringFrom(FCString* pSubString, int startindex);

    bool ContainsCStringFrom(const char* pszSubString, int startindex)
    {
        FCString substring;
        substring.SetCString(pszSubString);
        return ContainsStringFrom(&substring, startindex);
    }

    int CalcStringPos(FCString* pSubString)
    {
                /* This method can't be size_t, since it must be able to return -1! */
        return CalcStringPosFrom(pSubString, 0);
    }

    int CalcCStringPos(FCString* pSubString, const char* pszSubString)
    {
                /* This method can't be size_t, since it must be able to return -1! */
        FCString substring;
        substring.SetCString(pszSubString);
        return CalcStringPos(&substring);
    }

    int CalcStringPosFrom(FCString* pSubString, int startindex);

    int CalcCStringPosFrom(const char* pszSubString, int startindex)
    {
                /* 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(void* cfurl);
    
    /* For internal use only. Converts a file path to CFURLRef */
    void* _GetPathCFURLRef();
#endif

#ifdef PDK_FRAMEWORK_ENIGMASTRINGS

    bool ContainsEnigmaTextInsert(bool only_file_info_inserts = true);

    FCStrings* CreateEnigmaComponents();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCStrings* CreateEnigmaComponents_GC();
#endif

    FCStrings* CreateEnigmaStrings(bool include_non_commands = false);

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCStrings* CreateEnigmaStrings_GC(bool include_non_commands);
#endif
#endif

    FCFontInfo* CreateLastFontInfo();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFontInfo* CreateLastFontInfo_GC();
#endif

    FCStrings* CreateParsedStrings(const char* pszSeparators);

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCStrings* CreateParsedStrings_GC(const char* pszSeparators);
#endif
   
    FCStrings* CreateRows();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCStrings* CreateRows_GC();
#endif
    
    bool DeleteCharacterAt(int index);

    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 ++;
            if (count > 7) break;
        }
        Clear();
    }

    int FindFirst(const char* pszSubStr)
    {
        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)
    {
        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 FormatCString(const char *fmt, ...);

        int FormatString(FCString *fmt, ...);
#endif

    void FormatCharacterNumber(eUniChar16 character);
    
    const char* GetCString() const;

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    const char* GetLuaString() const;
#endif
    
    const char* GetUTF8String() const;
        
    bool CopyToUnicodeBuffer(eUniChar16 *pBuffer, int maxbufferlen = 0) const;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    UTRANSID _StartFinaleEdit();
    
    /* \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();
    
    void SetNSString(void* pNSString);
#endif
    
    int GetInteger(int index = 0);
    
    int GetHex();

    float GetFloat(int index = 0);

    eUniChar16 GetCharacterAt(int index);

    int GetLength() const { return _length; }

    const char* GetEOL() const;

    void Insert(const char* pszString, int insertindex = 0);

    void InsertString(FCString* pString, int insertindex = 0);

    bool IsDigit(int index);

    bool IsAllDigits();

    bool IsNumber();

    bool IsEqualCString(const char* pszString);

    bool IsEqual(const char* pszString) { return IsEqualCString(pszString); }

    bool IsEqualString(FCString* pString);

    bool IsCharacter(int index, eUniChar16 character);

    bool IsCharacters(int index, const char *pChars);

    bool IsEmpty() { return (GetLength() == 0); }

    bool IsWhitespace(int index);

#ifdef PDK_FRAMEWORK_ENIGMASTRINGS

    bool IsEnigmaCommand()
    {
        if (!IsCharacters(0, "^")) return false;
        if (IsCharacters(1, "^")) return false;
        return true;
    }

    bool IsEnigmaFont();

    bool IsEnigmaFileInfoTitle();

    bool IsEnigmaFileInfoSubtitle();

    bool IsEnigmaFileInfoComposer();

    bool IsEnigmaFileInfoArranger();

    bool IsEnigmaFileInfoLyricist();

    bool IsEnigmaFileInfoCopyright();

    bool IsEnigmaTextInsert(bool only_file_info_inserts = true);
#endif

#if OPERATING_SYSTEM == WINDOWS
     bool LoadResource(int resourceID, HINSTANCE dllinstance = 0);
#else
     bool LoadResource(const char* resourceID,
                        const char* pszResourceFileName = NULL,
                        const char* pszTableName = NULL);
#endif

     bool MakeSubString(int startindex, int substringlength, FCString* pDestinationString);

#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(WCHAR* pCharBuffer);
#endif
#endif

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    void SetLuaString(const char* pszBuffer) { SetUTF8String(pszBuffer); }
#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(float f);

#ifdef PDK_FRAMEWORK_PREFS

    void SetMeasurement(float value, twobyte unit);
    
    float GetMeasurement(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte)
                         unit);
#endif  /* #ifdef PDK_FRAMEWORK_PREFS */

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

    bool StartsWith(const char* pszString);

    bool StartsWithString(FCString* pString);

    void ToUnicode(eUniChar16* pBuffer, int maxsize)
    {
        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 >= 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);

        bool MakeFullFilePath(const void* pFinPathSpec, EVERSION convertversion);

#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS    */

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCBase::DebugDump();
        DebugOutDigit("Length: ", (int) _length);
        DebugOutDigit("Storage length: ", (int) _storagelength);
        DebugOutPtr("_pStorage: ", _pStorage);
        DebugOutString("String contents: ", GetCString());
    }
#endif

};



class FCSettingsPair : public __FCBase
{
    FCString _keystring;
    FCString _valuestring;
public:
    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
    virtual void DebugDump()
    {
        __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;
    
    static bool _metricsshouldupdate;
public:
    virtual const char* ClassName() { 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;
    }
    
    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
    virtual void DebugDump()
    {
        __FCBase::DebugDump();
        DebugOutDigit("Horizontal stretch: ", GetHorizontalStretch());
    }
#endif
};


#ifdef PDK_FRAMEWORK_ENTRIES

class FCEntryMetrics : public __FCBase
{
    bool _loaded;
    EEntryMetrics2009a _metrics2009a;
#if FXT_VERSION >= FINALEVERSION_2014
    EEntryMetrics2014 _metrics2014;
#endif
        
    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:
    virtual const char* ClassName() { return "FCEntryMetrics"; }

    FCEntryMetrics();

    virtual ~FCEntryMetrics()
    {
        FreeMetrics();
    }

    static void MarkMetricsForRebuild() { _updatemetrics = true; }

    bool Load(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 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);
    
    int GetNoteWidth(int index);

    ERECT* GetStemRect()
    {
        if (!_loaded) return NULL;
        return &_GetBasicMetricsPtr()->stemRect;
    }

    ERECT* GetNoteheadRect()
    {
        if (!_loaded) return NULL;
        return &_GetBasicMetricsPtr()->headRect;
    }

    void FreeMetrics();

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCBase::DebugDump();       
    }
#endif
};
#endif


class FCArticulationDef;

class FCTextMetrics : public __FCBase
{
#if FXT_VERSION >= FINALEVERSION_25
    ETextMetrics _textMetrics;
#endif
public:
    FCTextMetrics() : __FCBase() {}
    
    bool LoadString(FCString* pText, FCFontInfo* pFont, float percent);
    
    bool LoadSymbol(eUniChar16 symbolchar, FCFontInfo* pFont, float percent);
    
    bool LoadArticulation(FCArticulationDef* pArticDef, bool flipped, float percent);
    
    void CopyFrom(FCTextMetrics* pTextMetrics);
    
    float GetAdvanceWidthPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.width;
#else
        return 0;
#endif
    }
    
    float GetLeftPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.left;
#else
        return 0;
#endif
    }
    
    float GetRightPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.right;
#else
        return 0;
#endif
    }
    
    float GetTopPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.top;
#else
        return 0;
#endif
    }
    
    float GetBottomPoints() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.bottom;
#else
        return 0;
#endif
    }
    
    float GetAdvanceWidthEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eWidth;
#else
        return 0;
#endif
    }
    
    float GetLeftEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eLeft;
#else
        return 0;
#endif
    }
    
    float GetRightEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eRight;
#else
        return 0;
#endif
    }
    
    float GetTopEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eTop;
#else
        return 0;
#endif
    }
    
    float GetBottomEVPUs() const {
#if FXT_VERSION >= FINALEVERSION_25
        return _textMetrics.eBottom;
#else
        return 0;
#endif
    }
    
    float CalcHeightPoints() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetTopPoints()-GetBottomPoints();
#else
        return 0;
#endif
    }
    
    float CalcWidthPoints() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetRightPoints()-GetLeftPoints();
#else
        return 0;
#endif
    }
    
    float CalcHeightEVPUs() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetTopEVPUs()-GetBottomEVPUs();
#else
        return 0;
#endif
    }
    
    float CalcWidthEVPUs() {
#if FXT_VERSION >= FINALEVERSION_25
        return GetRightEVPUs()-GetLeftEVPUs();
#else
        return 0;
#endif
    }
    
    virtual const char* ClassName() { return "FCTextMetrics"; }
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __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;
        float _floatvalue;
    public:
        virtual const char* ClassName() { return "FCNumber"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_NUMBER; }

        FCNumber(float value) : __FCBase()
        {
            /* Better to have this float, since that would support both float and int. */
            _intvalue = (int) value;
            _floatvalue = value;
        }

        void SetInt(int value)
        {
            _intvalue = value;
            _floatvalue = (float) value;
        }
    
        void SetFloat(float value)
        {
            _intvalue = (int) value;
            _floatvalue = value;
        }

        int GetInt() const { return _intvalue; }
    
        float GetFloat() const { return _floatvalue; }

    
#ifdef PDK_FRAMEWORK_DEBUG
        virtual void DebugDump()
        {
            __FCBase::DebugDump();
            DebugOutDigit("Integer value: ", _intvalue);
        }
#endif
};


class FCPoint : public __FCBase
{
    float _x;
    float _y;
public:
    FCPoint(float x, float y) : __FCBase()
    {
        _x = x;
        _y = y;
    }

    void SetX(float value) { _x = value; }

    void SetY(float value) { _y = value; }

    float GetX() const { return _x; }

    float GetY() const { return _y; }

    void MoveX(float value) { _x += value; }

    void MoveY(float value) { _y += value; }
};



class FCDocument;

class FCPrintSettings : public __FCBase
{
    FinPrintSettings _settings;
public:

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



#endif  /* _FF_BASE_H */