PRM/PRM_DisableList.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_DisableList.h ( PRM Library, C++)
 *
 * COMMENTS:    Disable information based on a disable when string.
 */

#ifndef __PRM_DisableList__
#define __PRM_DisableList__

#include "PRM_API.h"
#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_StringArray.h>

class PRM_API PRM_DisableInfo
{
public:
                                 PRM_DisableInfo()
                                 { }
                                ~PRM_DisableInfo()
                                 { }

    // Create a new instance of the disable information for parameters
    // contained within multi-parms.
    PRM_DisableInfo             *instance(UT_IntArray &idx);

    const PRM_DisableInfo       &operator=(const PRM_DisableInfo &src)
                                 {
                                     myControlParms = src.myControlParms;
                                     myControlValues = src.myControlValues;
                                     myTestOperators = src.myTestOperators;

                                     return *this;
                                 }

    void                         clear()
                                 {
                                     myControlParms.clear();
                                     myControlValues.clear();
                                     myTestOperators.resize(0);
                                 }
    void                         addInfo(const char *parm,
                                         const char *value,
                                         const char *testoperator)
                                 {
                                    myControlParms.append(parm);
                                    myControlValues.append(value);
                                    myTestOperators.append(testoperator);
                                 }

    const UT_StringArray        &getControlParms() const
                                 { return myControlParms; }
    const UT_StringArray        &getControlValues() const
                                 { return myControlValues; }
    const UT_StringArray        &getTestOperators() const
                                 { return myTestOperators; }

private:
    UT_StringArray               myControlParms;
    UT_StringArray               myControlValues;
    UT_StringArray               myTestOperators;
};

class PRM_API PRM_DisableList
{
public:
                                 PRM_DisableList();
    explicit                     PRM_DisableList(const char *disable);
                                ~PRM_DisableList();

    // Create a new disable list for use within multi-parms.  Since the disable
    // information may be dependent on the index of the multiparm, we need to
    // replace any #'s in the disable info's with the actual index.
    PRM_DisableList             *instance(UT_IntArray &idx);

    int                          entries() const;
    const PRM_DisableInfo       *operator()(int index) const;
    const PRM_DisableList       &operator=(const PRM_DisableList &src);

    void                         clear();
    PRM_DisableInfo             *addInfo();

    void                         getStringFromList(UT_String &str) const;
    void                         getStringFromList(UT_String &str,
                                    const UT_StringArray &validparms) const;
    bool                         setListFromString(const char *disable,
                                    UT_String &error);

    // Verifies the provided string is in proper disable format.
    // Proper format is:
    // All non-whitespace is enclosed in { }.
    // Each { or } has whitespace seperating it from its neighbours.
    // Inside brackets, each parm name has a value paired to it.
    // All open quotes have matching close quotes.
    static bool                  verifyDisableString(const char *disable,
                                    UT_String &error);

    static bool                  isValidOperator(const char *testoperator);

private:
    void                         getStringFromList(UT_String &str,
                                    const UT_StringArray *validparms) const;

    UT_PtrArray<PRM_DisableInfo *>       myDisableInfos;
};

#endif

---