ff_parts.h

/*
 * File:   ff_parts.h
 * Author: Jari Williamsson
 *
 * Created on den 22 mars 2011, 13:01
 */
 
#ifndef FF_PARTS_H
#define FF_PARTS_H
 
#include "ff_basecollection.h"
#include "ff_othercollection.h"
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
/* Undocumented - For internal use only */
#include "pragma_align_begin.h"
struct __XEDTPartDef
{
        CMPER nameID;                   // The EDTTextBlock2004 text block ID for the part's name.
        utwobyte partOrder;             // The unique order of the part that determines its tab
                            // order and position in the Edit Part submenu. (1-based)
        twobyte copies;         // The number of copies of the part to print.
        FLAG_16 flags;
        twobyte         m_nSmartMusicInst;      // The number of the SmartMusic instrument
                                    // to use for this part.
        twobyte         m_DefaultNameStaffOrGroup;      // Contains the cmper of the staff or
};
#include "pragma_align_end.h"
 
 
const EXTAG xot_PartDef = MAKEEXTAG(edOther,'p','D');
/* cmper = EPARTID; inci = 0 */
 
const FLAG_16 __PARTDEF_PRINTPART = 0x0001;
const FLAG_16 __PARTDEF_EXTRACTPART = 0x0002;
const FLAG_16 __PARTDEF_APPLYFORMAT = 0x0004;
const FLAG_16 __PARTDEF_NEEDS_RECALC = 0x0008;          /* Need to call recalc()
next time part is viewed */
const FLAG_16 __PARTDEF_NEEDS_SPACING = 0x0010;         /* Need to space music next
time part is viewed */
const FLAG_16 __PARTDEF_IS_NEW = 0x0020;
const FLAG_16 __PARTDEF_IS_MODIFIED = 0x0040;           /* A staff was added or
deleted. Apply part creation prefs
                                                // but don't do any other "New Part" stuff. */
const FLAG_16 __PARTDEF_NAMEISDEFAULT = 0x0080;         /* Part name is a default
                        staff or group name,
                                                e.g. [Staff 1] or [Group 1].  */
const FLAG_16 __PARTDEF_USE_AS_SMP_INST = 0x0100;       /* This part will be
        available as an item in SmartMusic's instrument list
                when the file is opened in SmartMusic.  */
const FLAG_16 __PARTDEF_UNLINK_INSTS            = 0x0200;               /* Part's instrument
settings are unlinked from the score's instrument settings. */
 
/* XEDTVoicingDef
 **
 ** VD other for voiced linked parts.
 **
*/
 
// *** voicingFlags definitions ****
const FLAG_16 __VOICING_ENABLED = 0x0004;                       // If not set, use all notes from source (score)
// staff else apply voicing rules below
 
//  VOICING_USE flags (mutually exclusive)
const FLAG_16 __VOICING_USE_SINGLELAYER = 0x0000;               // Use all notes from layer specified in 'layer'
const FLAG_16 __VOICING_USE_MULTILAYER = 0x0001;                // Use selected notes from multiple layers, depending on other flags.
// (reserving 0x0002 and 0x0003 for future expansion)
const FLAG_16 __VOICING_USEMASK = 0x0003;
 
//  VOICING_SINGLELAYER_ flags -- only apply if VOICING_USE_MULTILAYER selected
const FLAG_16 __VOICING_SINGLELAYER_ALL = 0x0000;               // If single layer, use all notes
const FLAG_16 __VOICING_SINGLELAYER_TOP = 0x0008;               // If single layer, use top note only
const FLAG_16 __VOICING_SINGLELAYER_BOT = 0x0010;               // If single layer, use bottom note only
const FLAG_16 __VOICING_SINGLELAYER_SELECT = 0x0018;                // If single layer, use selected notes
// (reserving 0x0020 for future expansion)
const FLAG_16 __VOICING_SINGLELAYER_MASK = 0x0038;              // Mask for above values -- AND to flags and right-shift by 3 to compare to above values
 
const FLAG_16 __VOICING_SINGLELAYER_SELECT_1ST = 0x0040;        // If single layer and VOICING_SINGLELAYER_SELECT, use 1st note
const FLAG_16 __VOICING_SINGLELAYER_SELECT_2ND = 0x0080;        // If single layer and VOICING_SINGLELAYER_SELECT, use 2nd note
const FLAG_16 __VOICING_SINGLELAYER_SELECT_3RD = 0x0100;        // If single layer and VOICING_SINGLELAYER_SELECT, use 3rd note
const FLAG_16 __VOICING_SINGLELAYER_SELECT_4TH = 0x0200;        // If single layer and VOICING_SINGLELAYER_SELECT, use 4th note
const FLAG_16 __VOICING_SINGLELAYER_SELECT_5TH = 0x0400;        // If single layer and VOICING_SINGLELAYER_SELECT, use 5th note
const FLAG_16 __VOICING_SINGLELAYER_SELECT_FROMBOTTOM = 0x2000; // If bit set, the above applies from bottom of entry, otherwise from top
const FLAG_16 __VOICING_SINGLELAYER_SELECT_SINGLENOTE = 0x1000; // If bit set, include single note passages in this part, regardless of above rules
 
#include "pragma_align_begin.h"
struct __XEDTVoicingDef
{
    FLAG_16 voicingFlags;       // see flag definitions, above
    eLayer singleLayer;         // Which single layer to take notes from, if VOICING_USE_SINGLELAYER is set, ignored otherwise
    eLayer multiLayer;          // Which layer to take notes from, if VOICING_USEMULTIPLELAYERS and multiple layers are present
private:
    twobyte AAAA;
    twobyte BBBB;
    twobyte CCCC;
    
public:
    __XEDTVoicingDef() : voicingFlags(0), singleLayer(0), multiLayer(0), AAAA(0), BBBB(0), CCCC(0) {}
};
#include "pragma_align_end.h"
 
const EXTAG xot_VoicingDef = MAKEEXTAG(edOther,'V','D');
/* cmper = inst ID (1-based), unshared and only in part, incident =  0 */
 
#endif
 
 
class FCPart : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
private:
    __XEDTPartDef _partdata;
    FCString _astring;
    EPARTID _partid;
    EDOCID _documentid;
    EPARTID _previouspart;
 
    EXTAG Tag() const override { return xot_PartDef; }
 
    int DataSizeLoad() const override { return sizeof(_partdata); }
    void* Allocate() override { return (void*) &_partdata; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_partdata, ((FCPart*)pSource)->_GetDataPtr(), sizeof(_partdata));
        _datablock = &_partdata;
        _loadedsize = sizeof(_partdata);
    }
 
    __FCBaseData* CreateObject() override
    {
        return new FCPart();
    }
    
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
public:
    enum PREDEFINED_PARTIDS {
        PARTID_SCORE = 0,
 
        PARTID_CURRENT = -1,
        
        PARTID_UNKNOWN = -2     
    };
public:
 
    const char* ClassName() const override { return "FCPart"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PART; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_partdata; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
    FCPart(EPARTID partid = PARTID_CURRENT) : __FCNoInciOther() {
        if (partid == PARTID_CURRENT) {
            partid = FX_GetCurrentPartID();
        }
        _partid = partid;
        _documentid = FX_GetCurrentEnigmaDocument();
        _previouspart = PARTID_UNKNOWN;
        memset(&_partdata, 0, sizeof(_partdata));
    }
 
    virtual ~FCPart() {
#ifdef PDK_FRAMEWORK_DIAGNOSE
        if (_previouspart != PARTID_UNKNOWN) {
            DebugOut("FCPart::SwitchTo() has been called without a FCPart::SwitchBack()!!!");
        }
#endif
    }    
 
    EPARTID GetID() const {
        return _partid;
    }
 
 
    FCString* CreateCustomTextString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateCustomTextString_GC()
    { return makeLuaSharedPtr(CreateCustomTextString()); }
#endif
 
    bool DeleteCustomText();
 
    bool SaveCustomTextString(FCString* pString);
 
 
    EDOCID GetDocumentID() const {
        return _documentid;
    }
 
    bool SetID(FCPart* pPart) {
        if (_previouspart != PARTID_UNKNOWN) return false;
        _partid = pPart->GetID();
        _documentid = FX_GetCurrentEnigmaDocument();
        _previouspart = PARTID_UNKNOWN;
        return true;
    }
 
    bool SwitchTo() {
        if (!IsCurrentDocument()) return false;
        if (_previouspart != PARTID_UNKNOWN) return false;
        _previouspart = FX_GetCurrentPartID();
        FX_SetCurrentPartID(_partid);
        return true;
    }
 
    bool SwitchBack()
    {
        if (_previouspart == PARTID_UNKNOWN) return false;
        if (!IsCurrentDocument()) return false;
        FX_SetCurrentPartID(_previouspart);
        _previouspart = PARTID_UNKNOWN;
        return true;
    }
 
    bool ViewInDocument() {
        if (!IsCurrentDocument()) return false;
        FX_SetCurrentPartInView(_partid);
        return true;
    }
 
    bool IsStaffIncluded(int staffno);    
 
    bool IsScore() {
        return GetID() == PARTID_SCORE;
    }
 
    bool IsPart() {
        return GetID() != PARTID_SCORE;
    }
 
 
    bool IsCurrent() {
        if (_partid != FX_GetCurrentPartID()) return false;
        if (!IsCurrentDocument()) return false;
        return true;
    }
 
    bool IsCurrentDocument() {
        return (_documentid == FX_GetCurrentEnigmaDocument());
    }
 
    bool HasCustomText() const { return (_partdata.nameID != 0); }
    
    bool IsIdentical(const __FCBase* pCompareObject) const override {
        if (!__FCBase::IsIdentical(pCompareObject)) return false;
        const FCPart* pComparePart = dynamic_cast<const FCPart*>(pCompareObject);
        if (!pComparePart) return false;
        if (GetID() != pComparePart->GetID()) return false;
        if (GetDocumentID() != pComparePart->GetDocumentID()) return false;
        return true;
    }
 
    bool SetCurrent()
    {
        if (_previouspart != PARTID_UNKNOWN) return false;
        _documentid = FX_GetCurrentEnigmaDocument();
        _partid = FX_GetCurrentPartID();
        _previouspart = PARTID_UNKNOWN;
        return true;
    }
 
    void GetName(FCString* pString);
 
    bool GetShouldPrint() const { return GetBitFlag(_partdata.flags, __PARTDEF_PRINTPART); }
 
    bool GetShouldExtract() const { return GetBitFlag(_partdata.flags, __PARTDEF_EXTRACTPART); }
 
    bool GetShouldUpdateLayout() const { return GetBitFlag(_partdata.flags, __PARTDEF_NEEDS_RECALC); }
 
    bool GetShouldUpdateSpacing() const { return GetBitFlag(_partdata.flags, __PARTDEF_NEEDS_SPACING); }
 
    bool GetUnlinkedInstrument() const { return GetBitFlag(_partdata.flags, __PARTDEF_UNLINK_INSTS); }
 
    utwobyte GetOrderID() const { return _partdata.partOrder; }
 
    twobyte GetPrintCopies() const { return _partdata.copies; }
    
    void SetShouldPrint(bool state) { Set16BitFlag(&_partdata.flags, __PARTDEF_PRINTPART, state); }
 
    void SetShouldExtract(bool state) { Set16BitFlag(&_partdata.flags, __PARTDEF_EXTRACTPART, state); }
 
    void SetShouldUpdateLayout(bool state) { Set16BitFlag(&_partdata.flags, __PARTDEF_NEEDS_RECALC, state); }
 
    void SetShouldUpdateSpacing(bool state) { Set16BitFlag(&_partdata.flags, __PARTDEF_NEEDS_SPACING, state); }
 
    void SetUnlinkedInstrument(bool state) { Set16BitFlag(&_partdata.flags, __PARTDEF_UNLINK_INSTS, state); }
 
    void SetOrderID(utwobyte idvalue) 
    {
        if (idvalue < 1) return;
        if (IsScore()) return;
        _partdata.partOrder = idvalue;
    }
 
    void SetPrintCopies(twobyte value) { _partdata.copies = value; }
 
    bool Print(FCPrintSettings* pSettings);
 
#ifdef PDK_FRAMEWORK_DEBUG
 
    void DebugDump() override {
        __FCBase::DebugDump();
        DebugOutInt("Part ID: ", GetID());
        FCString astring;
        GetName(&astring);
        DebugOutString("Part name: ", astring.GetCString());
    }
#endif
};
 
class FCParts : public __FCCollection {
public:
    FCParts() : __FCCollection()
    {        
    }
 
    const char* ClassName() const override {
        return "FCParts";
    }
 
    int LoadAll();
 
    int ForEachWithScope(FCIteratorHandler* pIterator);
 
    FCPart* GetCurrent();
 
    int GetCurrentIndex()
    {
        FCPart* pPart = GetCurrent();
        if (!pPart) return -1;
        return GetIndexOf(pPart);
    }
 
    FCPart* GetScore();
 
    static int CountPartsOnly()
    {
        return FX_CountParts();
    }
 
    FCPart* GetItemAt(int index) const { return (FCPart*) __FCCollection::GetItemAt(index); }
 
    void SortByOrderID();
 
    FCPart* FindPart(FCPart* pPartFind)
    {
        if (!pPartFind) return NULL;
        for (int i = 0; i < GetCount(); i++)
        {
            FCPart* pPart = GetItemAt(i);
            if (pPart->GetDocumentID() != pPartFind->GetDocumentID()) continue;
            if (pPart->GetID() != pPartFind->GetID()) continue;
            return pPart;
        }
        return NULL;
    }
 
        FCPart* FindID(EPARTID partid)
        {
                for (int i = 0; i < GetCount(); i++)
                {
                        FCPart* pPart = GetItemAt(i);                   
                        if (pPart->GetID() != partid) continue;
                        return pPart;
                }
                return NULL;
        }
 
    static bool GenerateParts()
    {
#if FXT_VERSION >= FINALEVERSION_26_1
        return FX_GenerateParts();
#else
        return false;
#endif
    }
};
 
 
class FCPartStaffVoicing : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
private:
    __XEDTVoicingDef _voicingdata;
 
    EXTAG Tag() const override { return xot_VoicingDef; }
 
    int DataSizeLoad() const override { return sizeof(_voicingdata); }
    void* Allocate() override { return _GetDataPtr(); }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCPartStaffVoicing * pSourceTyped = dynamic_cast<FCPartStaffVoicing *>(pSource);
        if (! pSourceTyped) return;
        memcpy(_GetDataPtr(), pSourceTyped->_GetDataPtr(), DataSizeLoad());
        _datablock = _GetDataPtr();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override
    {
        return new FCPart();
    }
    
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
public:
    enum PARTWILLDISPLAY {
        PARTDISP_ALLNOTES_IN_SINGLE_LAYER = 0,
 
        PARTDISP_SELECTED_NOTES_MULTIPLE_LAYERS = 1
    };
    
    enum VOICINGLAYERRULES {
        VOICINGLAYERRULE_ALL_NOTES = 0,
        
        VOICINGLAYERRULE_TOP_NOTE = 1,
        
        VOICINGLAYERRULE_BOTTOM_NOTE = 2,
        
        VOICINGLAYERRULE_SELECTED_NOTES = 3
    };
    
    enum VOICINGCOUNTNOTES {
        VCOUNTNOTES_FROM_THE_TOP = 1,
        
        VCOUNTNOTES_FROM_THE_BOTTOM = 2
    };
public:
 
    const char* ClassName() const override { return "FCPartStaffVoicing"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PARTSTAFFVOICING; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_voicingdata; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
    FCPartStaffVoicing() : __FCNoInciOther()
    {
        memset(&_voicingdata, 0, sizeof(_voicingdata));
    }
 
    bool GetIsVoicingEnabled() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_ENABLED);
    }
    
    void SetIsVoicingEnabled(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_ENABLED, value);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PARTWILLDISPLAY
#else
    int
#endif
    GetWillDisplay() const {
        return static_cast<PARTWILLDISPLAY>(_voicingdata.voicingFlags & __VOICING_USEMASK);
    }
 
    void SetWillDisplay(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PARTWILLDISPLAY
#else
    int
#endif
    value
    )
    {
        _voicingdata.voicingFlags &= ~__VOICING_USEMASK;
        _voicingdata.voicingFlags |= value;
    }
    
    int GetSingleLayerNumber() const {
        return _voicingdata.singleLayer + 1;
    }
    
    void SetSingleLayerNumber(int value) {
        _voicingdata.singleLayer = value - 1;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VOICINGLAYERRULES
#else
    int
#endif
    GetSingleLayerDisplayRule() const {
        return static_cast<VOICINGLAYERRULES>((_voicingdata.voicingFlags & __VOICING_SINGLELAYER_MASK) >> 3);
    }
 
    void SetSingleLayerDisplayRule(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VOICINGLAYERRULES
#else
    int
#endif
    value
    )
    {
        _voicingdata.voicingFlags &= ~__VOICING_SINGLELAYER_MASK;
        _voicingdata.voicingFlags |= value << 3;
    }
    
    int GetMultipleLayerNumber() const {
        return _voicingdata.multiLayer + 1;
    }
    
    void SetMultipleLayerNumber(int value) {
        _voicingdata.multiLayer = value - 1;
    }
    
    bool GetSingleLayerSelect1st() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_1ST);
    }
    
    void SetSingleLayerSelect1st(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_1ST, value);
    }
    
    bool GetSingleLayerSelect2nd() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_2ND);
    }
    
    void SetSingleLayerSelect2nd(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_2ND, value);
    }
    
    bool GetSingleLayerSelect3rd() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_3RD);
    }
    
    void SetSingleLayerSelect3rd(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_3RD, value);
    }
    
    bool GetSingleLayerSelect4th() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_4TH);
    }
    
    void SetSingleLayerSelect4th(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_4TH, value);
    }
    
    bool GetSingleLayerSelect5th() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_5TH);
    }
    
    void SetSingleLayerSelect5th(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_5TH, value);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VOICINGCOUNTNOTES
#else
    int
#endif
    GetCountNotesRule() const {
        if (GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_FROMBOTTOM))
            return VCOUNTNOTES_FROM_THE_BOTTOM;
        return VCOUNTNOTES_FROM_THE_TOP;
    }
 
    void SetCountNotesRule(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VOICINGCOUNTNOTES
#else
    int
#endif
    value
    )
    {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_FROMBOTTOM, value == VCOUNTNOTES_FROM_THE_BOTTOM);
    }
 
    bool GetIncludeSingleNotePassages() const {
        return GetBitFlag(_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_SINGLENOTE);
    }
    
    void SetIncludeSingleNotePassages(bool value) {
        Set16BitFlag(&_voicingdata.voicingFlags, __VOICING_SINGLELAYER_SELECT_SINGLENOTE, value);
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override {
        __FCNoInciOther::DebugDump();
    }
#endif
};
 
#endif  /* FF_PARTS_H */