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_Defines.h"
#include "HOM_Module.h"
#include "HOM_Errors.h"
#include "HOM_ElemPtr.h"
#include "HOM_PtrOrNull.h"
#include "HOM_Parm.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();
#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(%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");

private:
    size_t find(const  std::string &n);

    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;
    };
    std::vector< ChannelInfo > myChannels;
    std::string myFilter;
    bool myFilterT;
    bool myFilterR;
    bool myFilterS;
    bool myEnableFilter;
    bool myKeepSelection;
};

#endif