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>
 
// Structs removed from oldpdkstructs.h in F27 pdk
#if FXT_VERSION > FINALEVERSION_26_3
#if OPERATING_SYSTEM == WINDOWS
#include "pragma_align_begin.h"
class FinPathSpec2009
{
// 3/27/02 RES: Yeah, I know: should be private with accessors. But because this
// file is shared with the PDK, I wanted the class to be self-contained here in
// its declaration, and I didn't want to created new dependencies by cluttering
// it with estrncpy()s and the like.
public:
    ECHAR path[ MAX_PATHNAME_LENGTH ];
 
    FinPathSpec2009()
    {
        for ( int i = 0; i < sizeof(this->path); i++ )
            this->path[i] = 0;
    }
    ~FinPathSpec2009() {}
};
#include "pragma_align_end.h"
#endif // OPERATING_SYSTEM == WINDOWS
 
// CFC 03/30/2016: Support for FinPathSpec2012 has been removed from versions of Finale after 2014.5.
 
#if OPERATING_SYSTEM == WINDOWS
#include "pragma_align_begin.h"
class FinPathSpec2012
{
    // 3/27/02 RES: Yeah, I know: should be private with accessors. But because this
    // file is shared with the PDK, I wanted the class to be self-contained here in
    // its declaration, and I didn't want to created new dependencies by cluttering
    // it with estrncpy()s and the like.
public:
    WCHAR path[ MAX_PATHNAME_LENGTH ];
    
    FinPathSpec2012()
    {
        // 6/27/13 mdg: GCC complains about the use of DIM with this->path,
        // so since we share with the PDK, use the dimension_of code directly.
        // 3/14/02 RES: could use memset(), but didn't want to make this file
        // dependent on any system files
        for ( int i = 0; i < sizeof(this->path) / sizeof(this->path[0]); i++ )
            this->path[i] = 0;
    }
    ~FinPathSpec2012() {}
};
#include "pragma_align_end.h"
#endif // OPERATING_SYSTEM == WINDOWS
#endif // FXT_VERSION > FINALEVERSION_26_3
 
 
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(const 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:
    const char* ClassName() const override { return "FCTextFileUTF8Stream"; }
 
#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)
    {
    }
 
    FCString* ReadString() override;
    
    bool WriteStrings(FCStrings *pStrings) override;
    
    bool WriteText(FCString *pString) override;
};
 
 
class FCPercussionNoteType : public __FCBase
{
    int _instrumentID;
    int _parentinstrumentID;
    int _defaultstaffpos;
    int _generalMIDI;
    int _groupID;
    int _copies;
    bool _copygroup;
    FCString _name;
public:
    const char* ClassName() const override { return "FCPercussionNoteType"; }
 
    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) const { return (FCPercussionNoteType*) __FCCollection::GetItemAt(index); }
 
    bool IsLoaded() { return _loaded; }
};
 
 
#endif
 
#endif  /* FF_STREAM_H */