CL/CL_ClipIO.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 * 
 * Produced by:
 *      Luke Moore
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        CL_ClipIO.h
 *
 * COMMENTS:
 *      This singleton object stores a set of clip reader and clip writer
 *      objects.  When told to read or write a clip file, it choses which
 *      reader or writer to use based on the file extension.
 */

#ifndef __CL_ClipIO_h__
#define __CL_ClipIO_h__

#include "CL_API.h"
#include <UT/UT_SortedSymbolTable.h>
class CL_Clip;
class CL_ClipReader;
class CL_ClipWriter;

class CL_API CL_ClipIO
{
public:
    // Use this static method to access the clipIO singleton object.
    static CL_ClipIO &inst()
    {
        static bool created = false;
        static CL_ClipIO clip_io;
        if (!created)
        {
            created = true;
            // Note that registerClipHandlers() will eventually call inst()
            // when the handlers register themselves.  That's okay, since
            // we've set created to true.
            clip_io.registerClipHandlers();
        }
        return clip_io;
    }

    // These methods read a clip from a file or write a clip to a file.
    // If the clip could not be read/written, false will be returned.
    bool readClip(const char *file_name, CL_Clip &clip);
    bool writeClip(const char *file_name, const CL_Clip &clip);

    // Note that the extension starts with ".".
    bool canReadFileType(const char *extension);
    bool canWriteFileType(const char *extension);

    // These methods return information about which file extensions are
    // supported for reading and writing.
    int getNumReadableExtensions() const
        { return myClipReaders.entries(); }
    const char *getReadableExtension(int index) const
        { return myClipReaders.getSymbol(index); }
    int getNumWritableExtensions() const
        { return myClipWriters.entries(); }
    const char *getWritableExtension(int index) const
        { return myClipWriters.getSymbol(index); }

    // Clip readers and writers register themselves by calling these methods.
    // This class assumes that readers and writers are never deleted.  Note
    // that the extension begins with a dot, like it does in UT_IOTable.
    void registerClipReader(const char *extension,
                            CL_ClipReader &clip_reader);
    void registerClipWriter(const char *extension,
                            CL_ClipWriter &clip_writer);

protected:

    bool findReader(const char* symbol, UT_Thing* datap) const;

private:
    CL_ClipIO();
    void registerClipHandlers();

    UT_SortedSymbolTable myClipReaders;
    UT_SortedSymbolTable myClipWriters;
};

// These functions are called from shared objects/dll's to register readers
// and writers.
extern "C" {
    DLLEXPORT extern void CLregisterClipReader(void *);
    DLLEXPORT extern void CLregisterClipWriter(void *);
}

#endif

---