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

#endif


class FCPart : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
private:
    __XEDTPartDef _partdata;
    FCString _astring;
    EPARTID _partid;
    EDOCID _documentid;
    EPARTID _previouspart;

    virtual EXTAG Tag() { return MAKEEXTAG(edOther,'p','D'); }

    virtual int DataSizeLoad() { return sizeof(_partdata); }
    virtual void* Allocate() { return (void*) &_partdata; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_partdata, ((FCPart*)pSource)->_GetDataPtr(), sizeof(_partdata));
        _datablock = &_partdata;
        _loadedsize = sizeof(_partdata);
    }

    virtual __FCBaseData* CreateObject()
    {
        return new FCPart();
    }
    
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

public:
    enum PREDEFINED_PARTIDS {
        PARTID_SCORE = 0,

        PARTID_CURRENT = -1,
        
        PARTID_UNKNOWN = -2     
    };
public:

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

    FCString* CreateCustomTextString_GC();
#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); }
    
    virtual bool IsIdentical(__FCBase* pCompareObject) {
        if (!__FCBase::IsIdentical(pCompareObject)) return false;
        FCPart* pComparePart = (FCPart*) pCompareObject;
        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

    virtual void DebugDump() {
        __FCBase::DebugDump();
        DebugOutDigit("Part ID: ", GetID());
        FCString astring;
        GetName(&astring);
        DebugOutString("Part name: ", astring.GetCString());
    }
#endif
};

class FCParts : public __FCCollection {
public:
    FCParts() : __FCCollection()
    {        
    }

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



#endif  /* FF_PARTS_H */