PRM/PRM_ScriptPage.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:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        PRM_ScriptPage.h ( PRM Library, C++)
 *
 * COMMENTS:    A page of scripted parameters.  These pages are used to define
 *              the folder tabs for each page in a std. switcher.
 */

#ifndef __PRM_ScriptPage__
#define __PRM_ScriptPage__

#include "PRM_API.h"
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>

#define ISERROR(msg)    { is.error(msg); return 0; }
#define ISWARNING(msg)  { is.warning(msg); }

class DS_Stream;
class PRM_ScriptParm;
class PRM_Template;
class PRM_ScriptImports;
class PRM_SpareData;

class PRM_API PRM_ScriptPage {
public:
             PRM_ScriptPage();
    virtual ~PRM_ScriptPage();

    enum {
        PRM_SCRIPT_RMAN         = 0x01, // RenderMan style command script
        PRM_SCRIPT_SHELL        = 0x02, // Shell style command script
        PRM_SCRIPT_VEX          = 0x04, // Vex style command script
        PRM_SCRIPT_INVISIBLE    = 0x08, // This group of parms is invisible
        PRM_SCRIPT_INVISIBLETAB = 0x10  // This page of parms is invisible
    };

    /// normally, we are parsing the whole stream & thus expect the opening
    /// brace.  However, a derived Reader might want to read some meta data,
    /// then hand off to us, in which case expect_open_brace will be false.
    int                  parse(DS_Stream &is,
                               bool expect_open_brace,
                               PRM_ScriptParm *group_owner_parm,
                               bool parsing_import);

    void                 appendScriptParms(
                                        UT_PtrArray<PRM_ScriptParm *> &parms);

    const char          *getToken() const       { return myToken; }
    void                 setToken(const char *token) { myToken = token; }
    const char          *getLabel() const       { return myLabel; }
    const char          *getDefault() const     { return myDefault; }
    PRM_ScriptParm      *getParm(int i)         { return myParms(i); }
    int                  getParmEntries() const { return myParms.entries(); }
    bool                 getBaseParm() const    { return myBaseParm; }
    bool                 getTabBreak() const    { return myTabBreak; }
    PRM_SpareData       *getSpareData(bool create=false);
    void                 enforceOptions();

    // Set the default if there is no default defined...
    void                 setEmptyDefault(const char *str)
                         {
                             if (!myDefault.isstring())
                                 myDefault.harden(str);
                         }

    void                 setFlag(unsigned flag)         { myFlag |= flag; }
    void                 clearFlag(unsigned flag)       { myFlag &= ~flag; }
    unsigned             getFlag(unsigned bit) const    { return myFlag & bit;}

    // By default, this will simply return the number of parameters in my page
    virtual int          countParameters();

    // Gets the actual number of templates required by this page, including
    // all pages within pages and so on.
    int                  computeTemplateSize();
    // Fills an array of PRM_Templates from all our parms. The size of the
    // array must be at least computeTemplateSize() + 1. By passing in a
    // non-zero idx starting value the templates from this page can be
    // appended after some existing templates.
    void                 fillTemplate(PRM_Template *array, int &idx,
                                      PRM_ScriptImports *&imports);
    void                 fillTemplate(PRM_Template *array, int &idx,
                                      PRM_ScriptImports *&imports,
                                      int nest_level, int switcher_idx,
                                      int folder);

    /// a list of tokens not handled by PRM_ScriptPage, but which may be
    /// handled by my subclasses or should at least be ignored without
    /// generating an error
    static const char            *theTokens[];
    
    /// an entry in theNumParms corresponds with one in theTokens.  if the
    /// entry is nonnegative, it specifies the number of arguments expected by
    /// the token.  Negative values indicate tokens that take brace-enclosed
    /// blocks.
    static int                    theNumParms[];

protected:
    virtual PRM_ScriptParm      *newParm();
    virtual PRM_ScriptPage      *newImportPage();
    virtual int                  parseHelp(DS_Stream &is, UT_String &help);
    virtual int                  handleUnknown(DS_Stream &is, UT_String &token);
    int                          parseImport(DS_Stream &is);
    void                         processImportPage(PRM_ScriptPage *page);
    int                          parseAttribute(DS_Stream &is);

    UT_String                            myToken;
    UT_String                            myLabel;
    UT_String                            myDefault;
    UT_String                            myImportSource;
    UT_String                            myImportToken;
    UT_String                            myImportMask;
    bool                                 myImportEnable;
    UT_PtrArray<PRM_ScriptParm *>        myParms;
    PRM_ScriptImports                   *myImports;
    bool                                 myBaseParm;
    bool                                 myTabBreak;
    PRM_SpareData                       *mySpareData;
    unsigned                             myFlag;

};

#endif

---