IFD/IFD_RenderStream.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:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        IFD_RenderStream.h ( IFD Library, C++)
 *
 * COMMENTS:    Creates a render stream.  The stream uses the Scene to query
 *              information about how the stream should behave (i.e. pipe to a
 *              command or write to a file, background rendering etc.)
 *
 *              The IFD_Output should simply create a stream when it needs one.
 *              A new stream should be created for each individual stream.  The
 *              stream should NOT be re-used.
 *
 *              The stream should NOT be deleted as this is handled
 *              automatically.  The stream should NOT be accessed after close()
 *              is called, except through the stream notification.
 *
 *              The stream gets its information by evaluating several render
 *              tags defined on the scene.  These tags are:
 *                  stream.filename     - The script file to generate
 *                  stream.command      - The command to run
 *                  stream.binary       - Whether the script should be binary
 *                  stream.background   - Whether to render in the background
 *                  stream.processgroup - Set to 1 if the renderer is RIB
 *                                        This tag is used by windows to set
 *                                        the appropriate flag when starting
 *                                        the render command.
 */

#ifndef __IFD_RenderStream__
#define __IFD_RenderStream__

#include "IFD_API.h"
#include <SYS/SYS_Types.h>
#include <iostream.h>
#include <UT/UT_String.h>
#include "IFD_StreamEvent.h"

class UT_WritePipe;
class UT_Signal;
class IFD_Scene;

class IFD_API IFD_RenderStream {
public:
     IFD_RenderStream();
    ~IFD_RenderStream();

    // Methods for iterating over the active list of render streams
    static IFD_RenderStream     *getStreamList();
    IFD_RenderStream            *getNext()       { return myNext; }
    const IFD_RenderStream      *getNext() const { return myNext; }

    bool         open(IFD_Scene &scene, fpreal now);
    bool         openCommand(IFD_Scene &scene, const char *cmd, fpreal now);
    bool         openScript(IFD_Scene &scene, const char *cmd, fpreal now);
    ostream     *getStream()    { return myStream; }
    bool         close();

    bool         isPipe() const { return myPipe != 0; }

    void         kill();
    void         pause();
    void         restart();

    int          getPid() const         { return myPid; }
    int          getExitStatus() const  { return myExitStatus; }

    const char  *getCommand() const     { return myCommand; }
    time_t       getStartTime() const   { return myStartTime; }
    bool         isPaused() const       { return myPaused; }
    bool         isDone() const         { return myDone; }
    time_t       getDuration() const;

    UT_NotifierImpl<IFD_StreamEvent &>
                        &getEventNotifier()     { return myEventNotifier; }

    static void          pruneList();

    // Sets whether or not finished jobs should be removed from the list.
    static void          setClearDoneFlag(bool cleardone);

    // Removes stream from the list but only if it is done.
    static void          removeStream(const IFD_RenderStream *stream);

private:

    // Called when a job is finished (either killed or terminated normally)
    void                 finishJob();

    UT_NotifierImpl<IFD_StreamEvent &>  myEventNotifier;
    IFD_RenderStream    *myPrev, *myNext;
    UT_WritePipe        *myPipe;
    UT_Signal           *mySignal;
    ostream             *myStream;
    UT_String            myCommand;
    time_t               myStartTime;
    int                  myPid;
    int                  myExitStatus;
    bool                 myPaused;
    bool                 myBackground;
    bool                 myDone;            // Job is finished.
    time_t               myDuration;        // Job duration.

    static bool          theClearDoneFlag;  // remove entry when job is done


};

#endif

---