ff_stream.h

/*
 * File:   ff_stream.h
 * Author: Jari Williamsson
 *
 * Created on den 23 mars 2012, 21:14
 *
 * Contains the stream classes for the Finale PDK Framework.
 *
 */

#ifndef FF_STREAM_H
#define FF_STREAM_H

#ifdef PDK_FRAMEWORK_STREAMS

#include <stdio.h>

class __FCBaseStream : public __FCBase
{
public:
    __FCBaseStream() : __FCBase() {}
};


class FCFileStream : public __FCBaseStream
{
#if (FXT_VERSION < FINALEVERSION_25 || OPERATING_SYSTEM == WINDOWS)
        FinPathSpec2009 _folderspec2009;
#if FXT_VERSION >= FINALEVERSION_2012
        FinPathSpec2012 _folderspec2012;
#endif
#endif
#if FXT_VERSION >= FINALEVERSION_2025
        FinPathSpec25 _folderspec2025;
#endif

    FCString        _folder;
    FCString        _filename;

protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FILE*           _pFile;
    bool _MakeFullPath(FCString* pString);
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
public:
        FCFileStream(
#if FXT_VERSION < FINALEVERSION_2012
                FinPathSpec2009* pFolder,
#elif FXT_VERSION < FINALEVERSION_25
                FinPathSpec2012* pFolder,
#else
                FinPathSpec25* pFolder,
#endif
                FCString* pFileName) :
                __FCBaseStream()
        {
                _folder.Clear();
#if (FXT_VERSION < FINALEVERSION_25 || OPERATING_SYSTEM == WINDOWS)
                switch (FCString::_GetFinPathVersion())
                {
                        case FINALEVERSION_2009:
                                memcpy(&_folderspec2009, pFolder, sizeof(_folderspec2009));
                                break;
#if FXT_VERSION >= FINALEVERSION_2012
                        case FINALEVERSION_2012:
                                memcpy(&_folderspec2012, pFolder, sizeof(_folderspec2012));
                                break;
#endif
#if FXT_VERSION >= FINALEVERSION_2025
                        case FINALEVERSION_2025:
                                memcpy(&_folderspec2025, pFolder, sizeof(_folderspec2025));
                                break;
#endif
                }
#else
                // For FinPathSpec25, use assign operator, not memcpy
                _folderspec2025 = *pFolder;
#endif        
        _filename.SetString(pFileName);
        _pFile = NULL;
    }

    FCFileStream(FCString* pFolder, FCString* pFileName) : __FCBaseStream()
    {
       _folder.SetString(pFolder);
#if FXT_VERSION < FINALEVERSION_25 || OPERATING_SYSTEM == WINDOWS
           switch (FCString::_GetFinPathVersion())
           {
           case FINALEVERSION_2009:
                   memset(&_folderspec2009, 0, sizeof(_folderspec2009));
                   break;
#if FXT_VERSION >= FINALEVERSION_2012
           case FINALEVERSION_2012:
                   memset(&_folderspec2012, 0, sizeof(_folderspec2012));
                   break;
#endif
#if FXT_VERSION >= FINALEVERSION_2025
           case FINALEVERSION_2025:
                   memset(&_folderspec2025, 0, sizeof(_folderspec2025));                   
                   break;
#endif
        }               
#else // Mac FXT_VERSION_25_BASE and greater
                _folderspec2025.finPathSpecType = 0;
                _folderspec2025.SetCFURLRef(NULL);
#endif
       _filename.SetString(pFileName);
       _pFile = NULL;
    }

    virtual ~FCFileStream()
    {
        if (_pFile) fclose(_pFile);
        _pFile = NULL;
    }

    FILE* _GetFILE() { return _pFile; }

    bool IsOpen() { return (_pFile != NULL); }

    bool OpenFile(
                WINCODE(WCHAR* pszMode)
                MACCODE(const char* pszMode)
                );

    virtual bool OpenRead() = 0;

    virtual bool OpenWrite() = 0;

    bool Close();

    void GetFullPath(FCString* pString)
    {
        if (!_MakeFullPath(pString)) pString->Clear();
    }
};


class FCTextFileStream : public FCFileStream
{
public:
#if FXT_VERSION < FINALEVERSION_2012
        FCTextFileStream(FinPathSpec2009* pFolder, FCString* pFileName) :
                FCFileStream(pFolder, pFileName) { }
#elif FXT_VERSION < FINALEVERSION_25
    FCTextFileStream(FinPathSpec2012* pFolder, FCString* pFileName) :
        FCFileStream(pFolder, pFileName) { }
#else
        FCTextFileStream(FinPathSpec25* pFolder, FCString* pFileName) :
                FCFileStream(pFolder, pFileName) { }
#endif

    FCTextFileStream(FCString* pFolder, FCString* pFileName) :
                FCFileStream(pFolder, pFileName)
    {
    }
    
    virtual bool OpenRead()
    {
        return this->OpenFile(
                        WINCODE(L"r")
                        MACCODE("r")
                        );
    }

    virtual bool OpenWrite()
    {
                return this->OpenFile(
                        WINCODE(L"w+")
                        MACCODE("w+")
                        );
    }

    virtual FCString* ReadString();

    FCStrings* ReadStrings();

    virtual bool WriteStrings(FCStrings *pStrings);

    virtual bool WriteText(FCString *pString);

    virtual bool WriteSettingsPairs(FCSettingsPairs* pPairs);
};

class FCTextFileUTF8Stream : public FCTextFileStream
{
public:
#if FXT_VERSION < FINALEVERSION_2012
    FCTextFileUTF8Stream(FinPathSpec2009* pFolder, FCString* pFileName) :
    FCTextFileStream(pFolder, pFileName) { }
#elif FXT_VERSION < FINALEVERSION_25
    FCTextFileUTF8Stream(FinPathSpec2012* pFolder, FCString* pFileName) :
    FCTextFileStream(pFolder, pFileName) { }
#else
    FCTextFileUTF8Stream(FinPathSpec25* pFolder, FCString* pFileName) :
    FCTextFileStream(pFolder, pFileName) { }
#endif
    
    
    FCTextFileUTF8Stream(FCString* pFolder, FCString* pFileName) :
                FCTextFileStream(pFolder, pFileName)
    {
    }

    virtual FCString* ReadString();
    
    virtual bool WriteStrings(FCStrings *pStrings);
    
    virtual bool WriteText(FCString *pString);
};


class FCPercussionNoteType : public __FCBase
{
    int _instrumentID;
    int _parentinstrumentID;
    int _defaultstaffpos;
    int _generalMIDI;
    int _groupID;
    int _copies;
    bool _copygroup;
    FCString _name;
public:
    FCPercussionNoteType() : __FCBase()
    {
        _instrumentID = 0;
        _parentinstrumentID = 0;
        _defaultstaffpos = 0;
        _generalMIDI = -1;
        _groupID = 0;
        _copies = 1;
        _copygroup = false;
    }

    void FormatName(FCString* pString, int orderid, int grouporderid);

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetName(FCString* pString) { _name.SetString(pString); }

    void _SetInstrumentID(int theID) { _instrumentID = theID; }
    void _SetParentInstrumentID(int theID) { _parentinstrumentID = theID; }
    void _SetDefaultStaffPos(int staffpos) { _defaultstaffpos = staffpos; }
    void _SetGeneralMIDI(int gmnote) { _generalMIDI = gmnote; }
    void _SetGroupID(int theID) { _groupID = theID; }
    void _SetCopies(int count) { _copies = count; }
    void _SetCopyGroup(bool state) { _copygroup = state; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

    int GetInstrumentID() const { return _instrumentID; }

    int GetParentInstrumentID() const { return _parentinstrumentID; }

    int GetDefaultStaffPos() const { return _defaultstaffpos; }

    int GetGeneralMIDI() const { return _generalMIDI; }

    int GetGroupID() const { return _groupID; }

    int GetCopies() const { return _copies; }

    bool GetCopyGroup() const { return _copygroup; }


    bool _IsValid()
    {
        if (_instrumentID == 0) return false;
        if (_groupID == 0) return false;
        if (_name.IsEmpty()) return false;
        return true;
    }
};

class FCPercussionNoteTypes : public __FCCollection
{
    bool _loaded;
public:
    FCPercussionNoteTypes() : __FCCollection()
    {
        _loaded = false;
    }

    bool FileIsAvailable();

    int LoadAll();

    FCPercussionNoteType* FindNoteType(FLAG_16 percnotetype);

    FCPercussionNoteType* GetItemAt(int index) { return (FCPercussionNoteType*) __FCCollection::GetItemAt(index); }

    bool IsLoaded() { return _loaded; }
};


#endif

#endif  /* FF_STREAM_H */