GOP/GOP_Manager.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:
 *      George ElKoura
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 */

#ifndef __GOP_Manager_h__
#define __GOP_Manager_h__

#include "GOP_API.h"
#include <UT/UT_PtrArray.h>
#include "GOP_AdhocGroup.h"
#include "GOP_GroupParse.h"


class GB_BreakpointGroup;
class GB_EdgeGroup;
class GB_PointGroup;
class GB_PrimitiveGroup;
class GB_VertexGroup;
class GU_Detail;
class OP_Node;

class GOP_API GOP_Manager
{

public:
                         GOP_Manager (void) {};
    virtual             ~GOP_Manager (void);
        
    const GB_PrimitiveGroup     *parsePrimitiveGroups(const char *pat, 
                                              GU_Detail *pgdp = 0, 
                                              int numok = 1,
                                              int ordered = 1,
                                              bool strict = false,
                                              int prim_offset = 0);
    
    const GB_PointGroup         *parsePointGroups(const char *pat, 
                                              GU_Detail *pgdp = 0,
                                              int numok = 1,
                                              int ordered = 1,
                                              bool strict = false,
                                              int point_offset = 0);

    const GB_EdgeGroup          *parseEdgeGroups(const char *pat, 
                                                 GU_Detail *pgdp,
                                                 bool strict = true,
                                                 int prim_offset = 0,
                                                 int point_offset = 0);

    const GB_BreakpointGroup    *parseBreakpointGroups(const char *pat,
                                                 GU_Detail *pgdp,
                                                 bool strict = true,
                                                 int prim_offset = 0);

    const GB_VertexGroup        *parseVertexGroups(const char *pat,
                                                 GU_Detail *pgdp,
                                                 bool strict = true,
                                                 int prim_offset = 0);
    
    //
    // Similar to above, except the caller is free to modify its contents
    //

    GB_PrimitiveGroup   *parsePrimitiveGroupsCopy(const char *pat, 
                                                  GU_Detail *pgdp = 0, 
                                                  int numok = 1,
                                                  int ordered = 1,
                                                  bool strict = false);

    GB_PointGroup       *parsePointGroupsCopy(const char *pat, 
                                                  GU_Detail *pgdp = 0, 
                                                  int numok = 1,
                                                  int ordered = 1,
                                                  bool strict = false);

    GB_EdgeGroup        *parseEdgeGroupsCopy(const char *pat,
                                                  GU_Detail *pgdp);

    GB_BreakpointGroup  *parseBreakpointGroupsCopy(const char *pat,
                                                  GU_Detail *pgdp);

    GB_VertexGroup      *parseVertexGroupsCopy(const char *pat,
                                                  GU_Detail *pgdp);

    // Do the operation on a per group basis instead of unioning them together
    int                  parseEachGroup(const char *inpattern, 
                                        GroupOperation operation,
                                        void *data, int isPrim,OP_Node *opThis,
                                        GU_Detail *pgdp=0,
                                        int ordered = 1,
                                        bool strict = false,
                                        bool allow_adhoc = true);

    // Take an optional group and subdivide it into smaller groups as
    // input to operation
    void                 subdividePrimitiveGroup(GroupOperation operation,
                                                 const GB_PrimitiveGroup *g, 
                                                 void *data, int optype, 
                                                 int opstep,
                                                 const char *oplabel,
                                                 OP_Node *opThis,
                                                 GU_Detail *gdp=0);

    void                 subdivideMixPrimitiveGroup(GroupOperation operation,
                                                    const GB_PrimitiveGroup *g, 
                                                    void *data, int optype, 
                                                    int opstep,
                                                    const char *oplabel,
                                                    OP_Node *opThis,
                                                    GU_Detail *gdp=0);

    void                 subdividePointGroup(GroupOperation operation,
                                             const GB_PointGroup *group, 
                                             void *data, int optype, 
                                             int opstep, const char *oplabel,
                                             OP_Node *opThis,
                                             GU_Detail *gdp=0);

    void                 expandGroupNames(const char *pattern, 
                                          UT_String &outNames, 
                                          int isPrim, GU_Detail *gdp=0);

    // Create an ahdoc (internal) group and add it to the list of adhoc groups:
    GB_PrimitiveGroup   *createPrimitiveGroup(GU_Detail &gdp,
                                              const char *name = "adhoc");
    GB_PointGroup       *createPointGroup    (GU_Detail &gdp,
                                              const char *name = "adhoc");
    GB_EdgeGroup        *createEdgeGroup     (GU_Detail &gdp,
                                              const char *name = "adhoc");
    GB_BreakpointGroup  *createBreakpointGroup(GU_Detail &gdp,
                                              const char *name = "adhoc");
    GB_VertexGroup      *createVertexGroup   (GU_Detail &gdp,
                                              const char *name = "adhoc");

    // Remove an adhoc group or all adhocs from the list and delete them:
    int                  destroyAdhocGroup (const GB_BaseGroup *group);
    void                 destroyAdhocGroups(void);

    // This will destroy all the adhoc groups that match the given gdp.
    void                 destroyAdhocGroups(const GU_Detail *gdp);

    // Remove an adhoc group or all adhocs from the list.
    // Usually you want to call the destroy methods above to avoid headaches.
    int                  removeAdhocGroup (const GB_BaseGroup *group);
    void                 removeAdhocGroups(void);

    // TODO: These methods should only be called by the parsers... should we
    //       make it private and make them friends.  It doesn't really
    //       do any harm here though.
    void                 appendEdgeAdhocGroup(GU_Detail *gdp, 
                                              GB_BaseGroup *group, int isowner);
    void                 appendBreakpointAdhocGroup(GU_Detail *gdp, 
                                              GB_BaseGroup *group, int isowner);
    void                 appendVertexAdhocGroup(GU_Detail *gdp, 
                                              GB_BaseGroup *group, int isowner);
    void                 appendRegularAdhocGroup(GU_Detail *gdp, 
                                              GB_BaseGroup *group, int isowner);

    // Given a base name, create a unique group name from that.
    static const char   *getUniqueGroupName(const char *base);

private:
    void                 appendAdhocGroup(GOP_AdhocGroup *);

    UT_PtrArray<GOP_AdhocGroup *>    myGroupList;

};

#endif

---