HOM_ChannelList.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.
 *
 * COMMENTS:
 */

#ifndef __HOM_ChannelList_h__
#define __HOM_ChannelList_h__

#include "HOM_API.h"
#include "HOM_ChannelPrim.h"
#include "HOM_Defines.h"
#include "HOM_Geometry.h"
#include "HOM_GUDetailHandle.h"
#include "HOM_Module.h"
#include "HOM_Errors.h"
#include "HOM_ElemPtr.h"
#include "HOM_PtrOrNull.h"
#include "HOM_Parm.h"
#include "HOM_SopNode.h"

#include <UT/UT_StringMap.h>

#include <string>
#include <vector>

SWIGOUT(%feature("notabstract") HOM_ChannelList;)
SWIGOUT(%rename(ChannelList) HOM_ChannelList;)

class HOM_API HOM_ChannelList
{
public:
#ifdef SWIG
%extend
{
    HOM_ChannelList()
    { 
        return new HOM_ChannelList();
    }
}
#else
    HOM_ChannelList();

    UT_NON_COPYABLE(HOM_ChannelList);
#endif
    virtual ~HOM_ChannelList();

    std::string __repr__();

    bool operator==(
            const HOM_ChannelList& p) const;
    bool operator==(
            HOM_PtrOrNull<HOM_ChannelList> p);
    bool operator!=(
            HOM_PtrOrNull<HOM_ChannelList> p);

    void clear();

    std::vector<HOM_ElemPtr<HOM_Parm> > parms();
    std::vector<HOM_ElemPtr<HOM_Parm> > selected();
    std::vector<HOM_ElemPtr<HOM_Parm> > deselected();
    std::vector<HOM_ElemPtr<HOM_Parm> > pinned();
    std::vector<HOM_ElemPtr<HOM_Parm> > unpinned();
    std::vector<HOM_ElemPtr<HOM_Parm> > selectedValue();
    std::vector<HOM_ElemPtr<HOM_Parm> > deselectedValue();

    SWIGOUT(%kwargs addParm;)
    void addParm(HOM_Parm &parm,
        bool selected=true,
        bool pinned=false,
        bool valueselected=false);

    SWIGOUT(%kwargs addPath;)
    void addPath(const std::string &path,
        bool selected=true,
        bool pinned=false,
        bool valueselected=false);

    void remove(HOM_Parm &parm);

    void select(HOM_Parm &parm);
    void deselect(HOM_Parm &parm);

    void pin(HOM_Parm &parm);
    void unpin(HOM_Parm &parm);

    void selectValue(HOM_Parm &parm);
    void deselectValue(HOM_Parm &parm);

    SWIGOUT(%kwargs addParms;)
    void addParms(const std::vector<HOM_Parm*> &parms,
        bool selected=true,
        bool pinned=false,
        bool valueselected=false);

    SWIGOUT(%kwargs addPaths;)
    void addPaths(const std::vector< std::string > &paths,
        bool selected=true,
        bool pinned=false,
        bool valueselected=false);

    void remove(const std::vector<HOM_Parm*> &parms);

    void select(const std::vector<HOM_Parm*> &parms);
    void deselect(const std::vector<HOM_Parm*> &parms);

    void pin(const std::vector<HOM_Parm*> &parms);
    void unpin(const std::vector<HOM_Parm*> &parms);

    void selectValue(const std::vector<HOM_Parm*> &parms);
    void deselectValue(const std::vector<HOM_Parm*> &parms);

    bool contains(HOM_Parm &parm);
    bool isSelected(HOM_Parm &parm);
    bool isPinned(HOM_Parm &parm);
    bool isValueSelected(HOM_Parm &parm);

    SWIGOUT(%kwargs addNodeGeometryChannels;)
    std::string addNodeGeometryChannels(HOM_SopNode &node,
            const std::string &pattern = "",
            bool selected = true,
            bool pinned = false,
            bool valueselected = false);

    SWIGOUT(%kwargs addGeometryChannels;)
    std::string addGeometryChannels(HOM_Geometry &geometry,
            std::string collection_name = "",
            const std::string &pattern = "",
            bool selected = true,
            bool pinned = false,
            bool valueselected = false);

    std::vector<HOM_ElemPtr<HOM_ChannelPrim>> geometryChannels(
            const std::string &collection_name);

    std::vector<std::string> geometryChannelCollectionNames();

    void removeGeometryChannels(const std::string &collection_name);

    void selectGeometryChannel(const std::string &collection_name,
            const std::string &channel = "");
    void deselectGeometryChannel(const std::string &collection_name,
            const std::string &channel = "");

    void pinGeometryChannel(const std::string &collection_name,
            const std::string &channel = "");
    void unpinGeometryChannel(const std::string &collection_name,
            const std::string &channel = "");

    void selectGeometryChannelValue(const std::string &collection_name,
            const std::string &channel = "");
    void deselectGeometryChannelValue(const std::string &collection_name,
            const std::string &channel = "");

    bool containsGeometryChannel(const std::string &collection_name,
            const std::string &channel = "");

    bool isGeometryChannelSelected(const std::string &collection_name,
            const std::string &channel);
    bool isGeometryChannelPinned(const std::string &collection_name,
            const std::string &channel);
    bool isGeometryChannelValueSelected(const std::string &collection_name,
            const std::string &channel);

    SWIGOUT(%warnfilter(321) filter;)
    std::string filter();
    bool keepSelection();
    bool enableFilter();
    bool filterTranslates();
    bool filterRotates();
    bool filterScales();

    void setFilter(const std::string pattern);

    void setKeepSelection(bool value);
    void setEnableFilter(bool value);
    void setFilterTranslates(bool value);
    void setFilterRotates(bool value);
    void setFilterScales(bool value);

    SWIGOUT(%kwargs asCode;)
    std::string asCode(const std::string &var_name="chanlist");

    SWIGOUT(%ignore ChannelInfo;)
    struct ChannelInfo
    {
        ChannelInfo()
        : selected(true)
        , pinned(false)
        , selectedvalue(false)
        {}

        ChannelInfo(
            const std::string &n,
            bool s=true,
            bool p=false,
            bool v=false)
        : name( n )
        , selected(s)
        , pinned(p)
        , selectedvalue(v)
        {}

        bool operator==(
            const ChannelInfo& p) const
        {
            return
                name == p.name &&
                selected == p.selected &&
                pinned == p.pinned &&
                selectedvalue == p.selectedvalue
            ;
        }

        std::string name;
        bool selected;
        bool pinned;
        bool selectedvalue;
    };

    SWIGOUT(%ignore GeometryCollectionInfo;)
    struct GeometryCollectionInfo
    {
        GeometryCollectionInfo()
            : myGeometry(nullptr), myNodeId(-1), myPattern("")
        {
        }

        GeometryCollectionInfo(
                HOM_GUDetailHandle *geometry,
                int node_id,
                const UT_StringHolder &pattern)
            : myGeometry(geometry)
            , myNodeId(node_id)
            , myPattern(pattern)
        {
        }

        ~GeometryCollectionInfo() = default;

        SWIGOUT(%ignore operator=;)
        UT_NON_COPYABLE(GeometryCollectionInfo);

        GeometryCollectionInfo(GeometryCollectionInfo &&other) = default;
        GeometryCollectionInfo &operator=(GeometryCollectionInfo &&other) = default;

        UT_UniquePtr<HOM_GUDetailHandle> myGeometry;
        int myNodeId;

        UT_StringHolder myPattern;

        std::vector<ChannelInfo> myChannels;
    };

    SWIGOUT(%ignore geometryCollections;)
    UT_StringMap<GeometryCollectionInfo> &geometryCollections();

private:
    size_t find(const  std::string &n);
    ChannelInfo *findGeometryChannel(
            const UT_StringHolder &collection_name,
            const UT_StringHolder &name);

    std::vector< ChannelInfo > myChannels;

    UT_StringMap<GeometryCollectionInfo> myGeometryCollections;

    std::string myFilter;
    bool myFilterT;
    bool myFilterR;
    bool myFilterS;
    bool myEnableFilter;
    bool myKeepSelection;
};

#endif