HOM_viewportVisualizers.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_viewportVisualizers_h__
#define __HOM_viewportVisualizers_h__

#include "HOM_API.h"
#include "HOM_Errors.h"
#include "HOM_ElemPtr.h"
#include "HOM_EnumModules.h"

#include <string>
#include <vector>

class HOM_GeometryViewport;
class HOM_Node;
class HOM_ViewportVisualizer;
class HOM_ViewportVisualizerType;

SWIGOUT(%rename(viewportVisualizers) HOM_viewportVisualizers;)

class HOM_API HOM_viewportVisualizers
{
public:
    virtual ~HOM_viewportVisualizers()
    {}

    virtual std::string __repr__() = 0;

    SWIGOUT(%kwargs visualizers;)
    virtual std::vector<HOM_ElemPtr<HOM_ViewportVisualizer> > visualizers(
        HOM_EnumValue &category=HOM_viewportVisualizerCategory::Common, 
        HOM_Node *node=NULL) = 0;

    SWIGOUT(%newobject createVisualizer;)
    SWIGOUT(%kwargs createVisualizer;)
    virtual HOM_ViewportVisualizer *createVisualizer(
        HOM_ViewportVisualizerType *type,
        HOM_EnumValue &category=HOM_viewportVisualizerCategory::Common, 
        HOM_Node *node=NULL) = 0;

    SWIGOUT(%newobject copyVisualizer;)
    SWIGOUT(%kwargs copyVisualizer;)
    virtual HOM_ViewportVisualizer *copyVisualizer(
        HOM_ViewportVisualizer *source) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_ViewportVisualizerType> > types() = 0;

    SWIGOUT(%warnfilter(321) type;)
    SWIGOUT(%newobject type;)
    virtual HOM_ViewportVisualizerType *type(const char *name) = 0;

    SWIGOUT(%kwargs isCategoryActive;)
    virtual bool isCategoryActive(
        HOM_EnumValue &category, HOM_Node *node=NULL, 
        HOM_GeometryViewport *viewport=NULL) = 0;
    SWIGOUT(%kwargs setIsCategoryActive;)
    virtual void setIsCategoryActive(
        bool on, HOM_EnumValue &category, HOM_Node *node=NULL,
        HOM_GeometryViewport *viewport=NULL) = 0;

    SWIGOUT(%newobject visualizerBySessionId;)
    virtual HOM_ViewportVisualizer *visualizerBySessionId(int session_id) = 0;

    SWIGOUT(%ignore addOpaqueEventCallback;)
    virtual void addOpaqueEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            void *py_callback,
            HOM_EnumValue &category,
            HOM_Node *node) = 0;
    SWIGOUT(%ignore removeOpaqueEventCallback;)
    virtual void removeOpaqueEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            void *py_callback,
            HOM_EnumValue &category,
            HOM_Node *node) = 0;
    SWIGOUT(%kwargs removeAllEventCallbacks;)
    virtual void removeAllEventCallbacks(
            HOM_EnumValue &category=HOM_viewportVisualizerCategory::Common,
            HOM_Node *node=NULL) = 0;
    SWIGOUT(%ignore opaqueEventCallbacks;)
    virtual std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
        opaqueEventCallbacks(
            HOM_EnumValue &category,
            HOM_Node *node) = 0;

#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs addEventCallback;)
    void addEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            InterpreterObject callback,
            HOM_EnumValue &category=HOM_viewportVisualizerCategory::Common,
            HOM_Node *node=NULL)
    { self->addOpaqueEventCallback(event_types, callback, category, node); }

    SWIGOUT(%kwargs removeEventCallback;)
    void removeEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            InterpreterObject callback,
            HOM_EnumValue &category=HOM_viewportVisualizerCategory::Common,
            HOM_Node *node=NULL)
    { self->removeOpaqueEventCallback(event_types, callback, category, node); }

    SWIGOUT(%kwargs removeEventCallback;)
    std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
        eventCallbacks(
            HOM_EnumValue &category=HOM_viewportVisualizerCategory::Common,
            HOM_Node *node=NULL)
    {
        std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
            opaque_callbacks(self->opaqueEventCallbacks(category, node));

        std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
            callbacks;
        for (int i=0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back(std::make_pair(
                opaque_callbacks[i].first,
                (InterpreterObject)opaque_callbacks[i].second));
        return callbacks;
    }
}
#endif
};

#endif