ff_details.h

/*
 * File:   ff_details.h
 * Author: Jari Williamsson
 *
 * Created on den 17 april 2011, 12:17
 */

#ifndef FF_DETAILS_H
#define FF_DETAILS_H

class __FCDetail : public __FCBaseData
{
public:
    __FCDetail() : __FCBaseData() {}

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    CMPER _GetCmper2() { return _dataid.detail.cmper2; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
};

class __FCNoInciDetail : public __FCDetail
{
    virtual bool LoadFirst() { return false; }
public:
    __FCNoInciDetail() : __FCDetail() {}

    bool Load(CMPER cmper1, CMPER cmper2);

    bool SaveNew(CMPER cmper1);

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCDetail::DebugDump();
        DebugOutDigit("cmper1: ", _dataid.detail.cmper1);
        DebugOutDigit("cmper2: ", _dataid.detail.cmper2);
    }
#endif
};


class FCGroup : public __FCNoInciDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGroupSpec _groupspec;
protected:

    virtual EVERSION EnigmaVersion();

    virtual bool LoadFirst()
    {
       _dataid.detail.cmper1 = 0;
       _dataid.detail.cmper2 = 0;
       _dataid.detail.inci = 0;
       return LoadNext();
    }

    virtual EXTAG Tag()
    {
        return dt_GroupSpec;
    }

    virtual int DataSizeLoad()
    {
        return sizeof (EDTGroupSpec);
    }

    virtual void* Allocate()
    {
        return (void*) &_groupspec;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_groupspec, ((FCGroup*) pSource)->_GetGroupSpec(), sizeof (_groupspec));
        _datablock = &_groupspec;
        _loadedsize = sizeof (_groupspec);
    }

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

    void _SetAbbreviatedNameID(CMPER value)
    {
        _groupspec.abrvNameID = value;
    }

    void _SetFullNameID(CMPER value)
    {
        _groupspec.fullNameID = value;
    }

#endif

public:

        enum FCGROUP_BRACKETS
        {
                GRBRAC_NONE = BRACKET_NONE,

                GRBRAC_PLAIN = BRACKET_PLAINBRAC,

                GRBRAC_CHORUS = BRACKET_CHORUSBRAC,

                GRBRAC_PIANO = BRACKET_PIANOBRAC,

                GRBRAC_REVERSECHORUS = BRACKET_REVCHORUSBRAC,

                GRBRAC_REVERSEPIANO = BRACKET_REVPIANOBRAC,

                GRBRAC_CURVEDCHORUS = BRACKET_CURVECHORUSBRAC,

                GRBRAC_REVERSECURVEDCHORUS = BRACKET_REVCURVECHORUSBRAC,

                GRBRAC_DESK = BRACKET_DESKBRAC,

                GRBRAC_REVERSEDESK = BRACKET_REVDESKBRAC
        };


#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGroupSpec* _GetGroupSpec()
    {
        return &_groupspec;
    }
#endif

    enum GROUPSTAFFHIDES    
    {
        GROUPSTAFFHIDE_NORMAL = 0,

        GROUPSTAFFHIDE_ALLEMPTY,

        GROUPSTAFFHIDE_NEVER
    };

    enum GROUPBARLINESTYLES
    {
        GROUPBARLINESTYLE_ONLYON = 0,

        GROUPBARLINESTYLE_ONLYBETWEEN,

        GROUPBARLINESTYLE_THROUGH
    };


    virtual const char* ClassName() { return "FCGroup"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_GROUP; }

    FCGroup() : __FCNoInciDetail()
    {
        memset(&_groupspec, 0, sizeof (_groupspec));
        _datablock = &_groupspec;
        _loadedsize = sizeof (_groupspec);
    }

    int CalcStaffIndex(twobyte staff);

    int CalcStaffSpan();

    bool ContainsStaff(twobyte staff);

    FCString* CreateAbbreviatedNameString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateAbbreviatedNameString_GC();
#endif

    FCString* CreateFullNameString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateFullNameString_GC();
#endif

#ifdef PDK_FRAMEWORK_ENIGMASTRINGS

    FCString* CreateTrimmedFullNameString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateTrimmedFullNameString_GC();
#endif
#endif

#ifdef PDK_FRAMEWORK_ENIGMASTRINGS

    FCString* CreateDisplayFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateDisplayFullNameString_GC();
#endif
#endif

    CMPER GetAbbreviatedNameID() { return _groupspec.abrvNameID; }

    bool GetFullNameExpandSingle() const
    {
        return GetBitFlag(_groupspec.auxflag, GROUP_AUX_EXPAND_FULL);
    }

    bool GetAbbreviatedNameExpandSingle() const
    {
        return GetBitFlag(_groupspec.auxflag, GROUP_AUX_EXPAND_ABRV);
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
        FCGROUP_BRACKETS
#else
        twobyte
#endif
                GetBracketStyle() const
    {           
#if FXT_VERSION >= FINALEVERSION_2014
                return (FCGROUP_BRACKETS)_groupspec.bracket.bracID;
#else
#ifdef __OBJC__
                return (FCGROUP_BRACKETS)_groupspec.bracket.bracID;
#else
                return (FCGROUP_BRACKETS)_groupspec.bracket.id;
#endif
#endif
    }

    Evpu16 GetBracketHorizontalPos() const
    {
        return _groupspec.bracket.bracpos;
    }

    Evpu16 GetBracketVerticalTopPos() const
    {
        return _groupspec.bracket.bractop;
    }

    Evpu16 GetBracketVerticalBottomPos() const
    {
        return _groupspec.bracket.bracbot;
    }

    bool GetBracketSingleStaff() const
    {
        return GetBitFlag(_groupspec.bracket.flag, BRACKET_BRACKET_ON_SINGLE);
    }

    twobyte GetEndStaff() const { return _groupspec.endInst; }

    CMPER GetFullNameID() { return _groupspec.fullNameID; }

    bool GetUseFullNamePositioning() const { return GetBitFlag(_groupspec.flag, GROUP_FULLNAME_INDIVPOS); }

    bool GetUseAbbreviatedNamePositioning() const { return GetBitFlag(_groupspec.flag, GROUP_ABRVNAME_INDIVPOS); }

    Evpu16 GetFullNameHorizontalOffset() const { return _groupspec.fullNameXadj; }

    Evpu16 GetAbbreviatedNameHorizontalOffset() const { return _groupspec.abrvNameXadj; }

    Evpu16 GetFullNameVerticalOffset() const { return _groupspec.fullNameYadj; }

    Evpu16 GetAbbreviatedNameVerticalOffset() const { return _groupspec.abrvNameYadj; }

    twobyte GetStartStaff() const { return _groupspec.startInst; }

    twobyte GetItemID() { return _dataid.detail.cmper2; }

    twobyte GetBarlineStyle() const
    {
        return (_groupspec.flag & GROUP_BARLINEBITS) >> 6;
    }

    bool GetBarlineUse() const
    {
        return GetBitFlag(_groupspec.flag, GROUP_OWN_BARLINE);
    }

    twobyte GetBarlineShapeID() const {
        if (GetBarlineStyle() != BARLINE_CUSTOM) return 0;
        return _groupspec.custombarshape;
    }


#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPSTAFFHIDES
#else
    int
#endif
    GetEmptyStaffHide() const
    {
        if (GetBitFlag(_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY))
            return GROUPSTAFFHIDE_ALLEMPTY;
        if (GetBitFlag(_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER))
            return GROUPSTAFFHIDE_NEVER;
        return GROUPSTAFFHIDE_NORMAL;
    }

    bool GetShowGroupName() const
    {
        return !GetBitFlag(_groupspec.flag, GROUP_HIDE_NAME);
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPBARLINESTYLES
#else
    int
#endif
    GetDrawBarlineMode() const
    {
        switch (_groupspec.flag & GROUP_BARLINE_STYLE)
        {
            case GROUP_GROUP_BARLINES:
                return GROUPBARLINESTYLE_THROUGH;
                break;
            case GROUP_MENSURSTRICHE:
                return GROUPBARLINESTYLE_ONLYBETWEEN;
            default:
                return GROUPBARLINESTYLE_ONLYON;
        }
    }

    FLAG_16 GetFullNameJustify() const
    {
        return (_groupspec.flag & GROUP_JUSTIFY_FULL);
    }

    FLAG_16 GetAbbreviatedNameJustify() const
    {
        return ((_groupspec.flag & GROUP_JUSTIFY_ABRV) >> 3);
    }

    FLAG_16 GetFullNameAlign() const
    {
        return (_groupspec.auxflag & GROUP_AUX_HALIGN_FULL);
    }

    FLAG_16 GetAbbreviatedNameAlign() const
    {
        return (_groupspec.auxflag & GROUP_AUX_HALIGN_ABRV) >> 2;
    }

    bool HasFullName() { return (GetFullNameID() != 0); }

    bool HasAbbreviatedName() { return (GetAbbreviatedNameID() != 0); }


#if FXT_VERSION >= FINALEVERSION_2011

    twobyte GetEndMeasure() const { return _groupspec.endMeas; }

    twobyte GetStartMeasure() const { return _groupspec.startMeas; }

    void SetEndMeasure(twobyte value) { _groupspec.endMeas = value; }

    void SetStartMeasure(twobyte value) { _groupspec.startMeas = value; }
#endif

    void SetStartStaff(twobyte staffno) { _groupspec.startInst = staffno; }

    void SetEndStaff(twobyte staffno) { _groupspec.endInst = staffno; }

    bool SaveNewAbbreviatedNameBlock(FCString *pString);

    bool SaveNewFullNameBlock(FCString *pString);

    void SetUseFullNamePositioning(bool state) { Set16BitFlag(&_groupspec.flag, GROUP_FULLNAME_INDIVPOS, state); }

    void SetUseAbbreviatedNamePositioning(bool state) { Set16BitFlag(&_groupspec.flag, GROUP_ABRVNAME_INDIVPOS, state); }

    void SetFullNameHorizontalOffset(Evpu16 value) { _groupspec.fullNameXadj = value; }

    void SetAbbreviatedNameHorizontalOffset(Evpu16 value) { _groupspec.abrvNameXadj = value; }

    void SetFullNameVerticalOffset(Evpu16 value) { _groupspec.fullNameYadj = value; }

    void SetAbbreviatedNameVerticalOffset(Evpu16 value) { _groupspec.abrvNameYadj = value; }

    void SetBarlineStyle(twobyte barline)
    {
        _groupspec.flag &= ~GROUP_BARLINEBITS;
        _groupspec.flag |= (barline << 6);
    }

    void SetBarlineUse(bool value)
    {
        Set16BitFlag(&_groupspec.flag, GROUP_OWN_BARLINE, value);
    }

    void SetBarlineShapeID(twobyte shapeID) {
        _groupspec.custombarshape = shapeID;
    }

    void SetEmptyStaffHide(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPSTAFFHIDES
#else
    int
#endif
    value
    )
    {
        switch (value)
        {
            case GROUPSTAFFHIDE_ALLEMPTY:
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY, true);
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER, false);
                break;
            case GROUPSTAFFHIDE_NEVER:
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY, false);
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER, true);
                break;
            default:
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY, false);
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER, false);
                break;
        }        
    }

    void SetShowGroupName(bool state)
    {
        Set16BitFlag(&_groupspec.flag, GROUP_HIDE_NAME, !state);
    }

    void SetDrawBarlineMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPBARLINESTYLES
#else
    int
#endif
    value)
    {
        switch (value)
        {
            case GROUPBARLINESTYLE_THROUGH:
                _groupspec.flag &= ~GROUP_BARLINE_STYLE;
                _groupspec.flag |= GROUP_GROUP_BARLINES;
                break;
            case GROUPBARLINESTYLE_ONLYBETWEEN:
                _groupspec.flag &= ~GROUP_BARLINE_STYLE;
                _groupspec.flag |= GROUP_NORMAL_BARLINES;
                break;
            case GROUPBARLINESTYLE_ONLYON:
                _groupspec.flag &= ~GROUP_BARLINE_STYLE;
                _groupspec.flag |= GROUP_MENSURSTRICHE;
                break;
        }       
    }

    void SetFullNameJustify(FLAG_16 value)
    {
        value &= 0x07;
        _groupspec.flag &= ~GROUP_JUSTIFY_FULL;
        _groupspec.flag |= value;
    }

    void SetAbbreviatedNameJustify(FLAG_16 value)
    {
        value &= 0x07;
        _groupspec.flag &= ~GROUP_JUSTIFY_ABRV;
        _groupspec.flag |= (value << 3);
    }


    void SetFullNameAlign(FLAG_16 value)
    {
        value &= 0x03;
        _groupspec.flag &= ~GROUP_AUX_HALIGN_FULL;
        _groupspec.flag |= value;
    }

    void SetAbbreviatedNameAlign(FLAG_16 value)
    {
        value &= 0x03;
        _groupspec.flag &= ~GROUP_AUX_HALIGN_ABRV;
        _groupspec.flag |= (value << 2);
    }

    void SetFullNameExpandSingle(bool state)
    {
        Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_EXPAND_FULL, state);
    }

    void SetAbbreviatedNameExpandSingle(bool state)
    {
        Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_EXPAND_ABRV, state);
    }

    void SetBracketStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                FCGROUP_BRACKETS
#else
                twobyte
#endif
                bracketid
                )
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _groupspec.bracket.bracID = bracketid;
#else
#ifdef __OBJC__
        _groupspec.bracket.bracID = bracketid;
#else
        _groupspec.bracket.id = bracketid;
#endif
#endif
    }

    void SetBracketHorizontalPos(Evpu16 value)
    {
        _groupspec.bracket.bracpos = value;
    }

    void SetBracketVerticalTopPos(Evpu16 value)
    {
        _groupspec.bracket.bractop = value;
    }

    void SetBracketVerticalBottomPos(Evpu16 value)
    {
        _groupspec.bracket.bracbot = value;
    }

    void SetBracketSingleStaff(bool state)
    {
        Set16BitFlag(&_groupspec.bracket.flag, BRACKET_BRACKET_ON_SINGLE, state);
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciDetail::DebugDump();
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
        FCString *pString = CreateTrimmedFullNameString();
        DebugOutString("Full Name: ", pString);
        delete pString;
#endif
        DebugOutDigit("Start staff: ", GetStartStaff());
        DebugOutDigit("End staff: ", GetEndStaff());
#if FXT_VERSION >= FINALEVERSION_2011
        DebugOutDigit("Start measure: ", GetStartMeasure());
        DebugOutDigit("End measure: ", GetEndMeasure());
#endif
    }
#endif
};



#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "pragma_align_begin.h"
struct __EDTCellClefInfo
{
    twobyte clefinfoID;
    twobyte eduvalue;
    twobyte percent;
    twobyte unknown;
    twobyte AAAA;
    twobyte BBBB;
    twobyte CCCC;
    twobyte DDDD;
    twobyte EEEE;
    twobyte FFFF;
};
#include "pragma_align_end.h"

const EXTAG __dt_CellClefInfo = MAKEEXTAG(edDetail,'G','F');

#endif



#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "pragma_align_begin.h"
struct __EDTBaseline
{
        fourbyte offset;                        /* In Evpu32 */
        twobyte lyricNumber;            /* Not 1-1 with tag like pre-2006 */
        twobyte AAAA;
        twobyte BBBB;
};
#include "pragma_align_end.h"

const EXTAG __dt_ExprBaselineAboveAdjust2007    = MAKEEXTAG(edDetail,'X','a');
const EXTAG __dt_ExprBaselineBelowAdjust2007    = MAKEEXTAG(edDetail,'X','b');
const EXTAG __dt_ChordBaselineAdjust2007                = MAKEEXTAG(edDetail,'C','l');
const EXTAG __dt_FretboardBaselineAdjust2007    = MAKEEXTAG(edDetail,'G','l');
const EXTAG __dt_VerseBaselineAdjust2007                = MAKEEXTAG(edDetail,'b','v');
const EXTAG __dt_ChorusBaselineAdjust2007       = MAKEEXTAG(edDetail,'b','c');
const EXTAG __dt_SectionBaselineAdjust2007      = MAKEEXTAG(edDetail,'B','S');

const EXTAG __dt_ExprBaselineAbove      = MAKEEXTAG(edDetail,'X','A');
const EXTAG __dt_ExprBaselineBelow      = MAKEEXTAG(edDetail,'X','B');
const EXTAG __dt_ChordBaseline          = MAKEEXTAG(edDetail,'C','L');
const EXTAG __dt_FretboardBaseline      = MAKEEXTAG(edDetail,'G','L');
const EXTAG __dt_VerseBaseline2006      = MAKEEXTAG(edDetail,'B','v');
const EXTAG __dt_ChorusBaseline2006     = MAKEEXTAG(edDetail,'B','c');
const EXTAG __dt_SectionBaseline2006    = MAKEEXTAG(edDetail,'B','s');
#endif

class FCBaseline : public __FCDetail
{
public:
    enum BASELINEMODES
    {
        BASELINEMODE_UNDEFINED = 0,

        BASELINEMODE_EXPRESSIONABOVE = 1,

        BASELINEMODE_EXPRESSIONBELOW = 2,

        BASELINEMODE_CHORD = 3,

        BASELINEMODE_FRETBOARD = 4,

        BASELINEMODE_LYRICSVERSE = 5,

        BASELINEMODE_LYRICSCHORUS = 6,

        BASELINEMODE_LYRICSSECTION = 7
    };


#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    __EDTBaseline _baseline;
    BASELINEMODES _mode;
    bool _globalscope;   /* Internal flag to indicate which type of tag that
                         * should be used. */


    virtual EVERSION EnigmaVersion() { return FINALEVERSION_2010; }

    virtual EXTAG Tag();

    virtual int DataSizeLoad() { return sizeof (_baseline); }

    virtual void* Allocate() { return (void*) &_baseline; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        FCBaseline* pSourceObject = (FCBaseline*) pSource;
        memcpy(&_baseline, pSourceObject->_GetBaseline(), sizeof (_baseline));
        _datablock = &_baseline;
        _loadedsize = sizeof (_baseline);
        _globalscope = pSourceObject->GetGlobalScope();
        _mode = (BASELINEMODES) pSourceObject->GetMode();
    }

    virtual __FCBaseData* CreateObject()
    {
        return new FCBaseline();
    }   
#endif

public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    __EDTBaseline* _GetBaseline() { return &_baseline; }

    virtual bool LoadFirst() { return false; }
#endif

    virtual const char* ClassName() { return "FCBaseline"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_BASELINE; }

    
    FCBaseline() : __FCDetail()
    {
        memset(&_baseline, 0, sizeof (_baseline));
        _datablock = &_baseline;
        _loadedsize = sizeof (_baseline);
        _mode = BASELINEMODE_UNDEFINED;
        _globalscope = false;
    }

    Evpu16 GetVerticalOffset() const { return _baseline.offset; }

    twobyte GetLyricNumber() const;

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    GetMode() const { return _mode; }

    eSsys GetSystem() const
    {
        if (GetGlobalScope()) return 0;
        return _dataid.detail.cmper1;
    }

    bool GetGlobalScope() const { return _globalscope; }

    eStaff GetStaff() const
    {        
        return _dataid.detail.cmper2;
    }

    void SetVerticalOffset(Evpu16 value) { _baseline.offset = value; }

    void SetLyricNumber(twobyte number)
    {
        if (number < 1) return;
        _baseline.lyricNumber = number;
    }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void _SetFullMode(BASELINEMODES mode, bool globalscope)
    {
        _mode = mode;
        _globalscope = globalscope;
    }
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case BASELINEMODE_UNDEFINED:
            case BASELINEMODE_EXPRESSIONABOVE:
            case BASELINEMODE_EXPRESSIONBELOW:
            case BASELINEMODE_CHORD:
            case BASELINEMODE_FRETBOARD:
            case BASELINEMODE_LYRICSVERSE:
            case BASELINEMODE_LYRICSCHORUS:
            case BASELINEMODE_LYRICSSECTION:
                _mode = (BASELINEMODES) mode;
                break;
        }
    }

    bool Load(eSsys systemno, eStaff staffno, twobyte inci);
    
    bool SaveNew(eSsys systemno, eStaff staffno);
    
    bool SaveAs(eSsys systemno, eStaff staffno, twobyte inci);

    bool LoadForStaff(eSsys systemno, eStaff staffno);

    bool LoadDefaultForMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case BASELINEMODE_LYRICSVERSE:
            case BASELINEMODE_LYRICSCHORUS:
            case BASELINEMODE_LYRICSSECTION:
                return false;
            default:
                break;
        }
        _SetFullMode((BASELINEMODES) mode, true);
        return Load(0, 0, 0);
    }

    bool LoadDefaultForLyricNumber(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
        mode,
        twobyte lyricno
    )
    {
        if (lyricno < 1) return false;
        switch (mode)
        {
            case BASELINEMODE_LYRICSVERSE:
            case BASELINEMODE_LYRICSCHORUS:
            case BASELINEMODE_LYRICSSECTION:
                break;
            default:
                return false;
        }
        _SetFullMode((BASELINEMODES) mode, true);
        twobyte tryinci = 0;
        while (Load(0, 0, tryinci))
        {
            if (GetLyricNumber() == lyricno) return true;
            tryinci ++;
        }
        return false;
    }

    virtual bool Save()
    {
        if (_mode == BASELINEMODE_UNDEFINED) return false;
        return __FCDetail::Save();
    }

    static Evpu16 CalcTotalOffset(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode,
    eSsys system,
    eStaff staff
    );

    static Evpu16 CalcTotalOffsetForLyricNumber(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode,
    eSsys system,
    eStaff staff,
    int lyricno
    );
};


#endif  /* FF_DETAILS_H */