GB/GB_Group.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
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Group definition for GB_Element types (C++)
 *
 * COMMENTS:
 *
 */

#ifndef __GB_Group_h__
#define __GB_Group_h__

#include "GB_API.h"
#include <UT/UT_LinkList.h>
#include <UT/UT_String.h>
#include "GB_BaseGroup.h"
#include "GB_Element.h"
#include "GB_GroupList.h"

class   GB_ElementTree;

class GB_API GB_Group : public GB_BaseGroup 
{
public:
     GB_Group(  GB_GroupList *o, const char *name, int hidden,
                unsigned short type = GBGROUP);
    ~GB_Group();

    unsigned     getOffset() const      { return myOffset; }
    unsigned     getMask() const        { return myMask; }
    void         setMask(unsigned o, unsigned m) { myOffset = o; myMask = m; }

    // Find out if we contain mixed elements.
    int          isMixed(void) const;

    int          contains(const GB_Element *it) const;
    int          containsMix(const GB_Element *it, 
                             const GB_Element *sec) const;

    int          contains(const GB_Element &it) const
                        { return contains(&it); }
    int          containsMix(const GB_Element &it,const GB_Element &sec) const
                        { return containsMix(&it, &sec); }

    int          contains(unsigned int i) const
                        { return contains(myOwner->element((int)i)); }


    // The version that doesn't take an order flag leaves the group
    // in whatever ordered state it currently is in.
    void         add(GB_Element *it, int order);
    void         add(GB_Element *it);
    void         addMix(GB_Element *it, GB_Element *sec);

    void         add(GB_Element &it, int order) 
                        {add(&it, order);}
    void         add(GB_Element &it) 
                        {add(&it);}
    void         addMix(GB_Element &it, GB_Element &sec) 
                        {addMix(&it, &sec);}
    void         addMix(unsigned int num, unsigned int sec);

    void         add(unsigned int num, int order) 
                        {add(myOwner->element((int)num), order);}
    void         add(unsigned int num)
                        {add(myOwner->element((int)num));}

    void         toggle(GB_Element *it);
    void         toggleMix(GB_Element *it, GB_Element *sec);

    void         toggle(GB_Element &it)
                        {toggle(&it);}
    void         toggleMix(GB_Element &it, GB_Element &sec)
                        {toggleMix(&it, &sec);}

    void         toggle(unsigned int num)
                        {toggle(myOwner->element((int)num));}

    void         remove(GB_Element *it);
    void         removeMix(GB_Element *it, GB_Element *sec);


    void         remove(GB_Element &it)
                        {remove(&it);}
    void         removeMix(GB_Element &it, GB_Element &sec)
                        {removeMix(&it, &sec);}

    void         remove(unsigned int num)
                        {remove(myOwner->element((int)num));}

    // Both methods return the number of elements in the group. The first one
    // looks only at the non-mixed elements, while the second looks at the 
    // mixed ones _as well_ (not only at the mixed ones).
    // NOTE: These calls are O(N) for unordered groups (N = number of entities)
    virtual unsigned entries() const    { return myOwner->entries(*this); }
    unsigned         entriesMix() const { return myOwner->entriesMix(*this); }

    virtual int      isEmpty() const    { return myOwner->isEmpty(*this); }
    int              isEmptyMix() const { return myOwner->isEmptyMix(*this); }

    virtual void     clearEntries(void) { myOwner->clearEntries(*this); }
    void             setEntries()       { myOwner->setEntries(*this); }
    void             toggleEntries()    { myOwner->toggleEntries(*this); }

                 // Set my flags to be the flags of the group passed to me
    void         setFlags(const GB_Group *grp)
                 { myOwner->assignEqual(*this, *grp); }


    GB_Group             *prev() { return (GB_Group*)UT_LinkNode::prev();}
    GB_Group             *next() { return (GB_Group*)UT_LinkNode::next();}
    const GB_Group       *prev() const
                            { return (const GB_Group*)UT_LinkNode::prev(); }
    const GB_Group       *next() const
                            { return (const GB_Group*)UT_LinkNode::next(); }

    virtual int           save(ostream &os, int binary) const
                          { return myOwner->save(*this, os, binary); }
    virtual bool          load(UT_IStream &is)
                          { return myOwner->load(*this, is); }

    GB_Group    &operator       |=(const GB_Group &d)
                 { myOwner->orEqual(*this, d); return *this; }
    GB_Group    &operator       &=(const GB_Group &d)
                 { myOwner->andEqual(*this, d); return *this; }
    GB_Group    &operator       -=(const GB_Group &d)
                 { myOwner->minusEqual(*this, d); return *this; }
    GB_Group    &operator       ^=(const GB_Group &d)
                 { myOwner->xorEqual(*this, d); return *this; }
    GB_Group    &operator        =(const GB_Group &d)
                 { myOwner->assignEqual(*this, d); return *this; }

    // order methods

    GB_ElementTree      *ordered(void) const    { return myTree; }
    GB_ElementTree      *ordered(int yesno);

    void                 setName(const char *n) { myOwner->rename(n, *this); myName.harden(n); }

private:

    GB_ElementTree      *myTree;
    GB_GroupList        *myOwner;
    unsigned             myOffset, myMask;
};

class GB_API GB_PointGroup : public GB_Group
{
public:
     GB_PointGroup(GB_GroupList *o, const char *name, int hidden)
        : GB_Group(o, name, hidden, GBPOINTGROUP) {}
    ~GB_PointGroup() {}
};

class GB_API GB_PrimitiveGroup : public GB_Group
{
public:
     GB_PrimitiveGroup(GB_GroupList *o, const char *name, int hidden)
        : GB_Group(o, name, hidden, GBPRIMITIVEGROUP) {}
    ~GB_PrimitiveGroup() {}
};

#endif

---