HOM_LopViewportOverrides.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:
 *      Class used to create a block for editing the session layer on a
 *      LOP Network.
 */

#ifndef __HOM_LopViewportOverrides_h__
#define __HOM_LopViewportOverrides_h__

#include "HOM_API.h"
#include "HOM_Errors.h"
#include "HOM_Geometry.h"
#include "HOM_GUDetailHandle.h"
#include "HOM_Matrix4.h"
#include "HOM_Vector3.h"
#include "HOM_Module.h"
#include <UT/UT_Map.h>

class HOM_LopSelectionRule;

SWIGOUT(%rename(LopViewportOverrides) HOM_LopViewportOverrides;)

SWIGOUT(%feature("notabstract") HOM_LopViewportOverrides;)
class HOM_API HOM_LopViewportOverrides
{
public:
#ifdef SWIG
%extend
{
    HOM_LopViewportOverrides()
    { return HOM().newLopViewportOverrides(); }
}
#else
    HOM_LopViewportOverrides()
    { HOM_CONSTRUCT_OBJECT(this) }
    HOM_LopViewportOverrides(const HOM_LopViewportOverrides &)
    { HOM_CONSTRUCT_OBJECT(this) }
    virtual ~HOM_LopViewportOverrides()
    { HOM_DESTRUCT_OBJECT(this) }
#endif

    // Let swig know we're overriding __repr__ for this class so it doesn't
    // provide its own __repr__.
    virtual std::string __repr__() = 0;

    virtual HOM_LopViewportOverrides *__enter__() = 0;

    virtual void setDrawMode(HOM_LopSelectionRule *prims,
            const char *drawmode) = 0;
    virtual void setActive(HOM_LopSelectionRule *prims, bool active) = 0;
    virtual void setVisible(HOM_LopSelectionRule *prims, bool visible) = 0;
    virtual HOM_Geometry *setXforms(
            const std::vector<std::string> &selected_paths,
            bool global_xform,
            const HOM_Matrix4 &handle_xform,
            const HOM_Matrix4 &pivot_xform,
            bool set_pivot_on_primary_prim,
            HOM_Geometry &delta) = 0;
    virtual void setSelectable(HOM_LopSelectionRule *prims,
            bool active, bool solo = false) = 0;
    virtual void setSoloLights(HOM_LopSelectionRule *prims = nullptr) = 0;
    virtual void addSoloLights(HOM_LopSelectionRule *prims) = 0;
    virtual void removeSoloLights(HOM_LopSelectionRule *prims) = 0;
    SWIGOUT(%ignore opaqueSoloLights;)
    virtual void *opaqueSoloLights() = 0;
    virtual void setSoloGeometry(HOM_LopSelectionRule *prims = nullptr) = 0;
    virtual void addSoloGeometry(HOM_LopSelectionRule *prims) = 0;
    virtual void removeSoloGeometry(HOM_LopSelectionRule *prims) = 0;
    SWIGOUT(%ignore opaqueSoloGeometry;)
    virtual void *opaqueSoloGeometry() = 0;
    virtual void showPurpose(HOM_LopSelectionRule *prims,
            const char *purpose) = 0;
    virtual void setDisplayOpacity(
            HOM_LopSelectionRule *prims, float opacity) = 0;

    SWIGOUT(%kwargs clear;)
    virtual void clear(HOM_EnumValue *layer_id = nullptr,
            const char *from_prim = nullptr) = 0;

    virtual HOM_BinaryString dumps() = 0;
    virtual void loads(HOM_BinaryString overrides_str) = 0;

    SWIGOUT(%ignore opaqueLayer;)
    virtual void *opaqueLayer() = 0;
    SWIGOUT(%ignore opaqueStage;)
    virtual void *opaqueStage() = 0;

    SWIGOUT(%ignore opaqueExit;)
    virtual void opaqueExit() = 0;

#ifdef SWIG
%extend
{
    InterpreterObject layer()
    { return HOMincRef((InterpreterObject)self->opaqueLayer()); }
    InterpreterObject stage()
    { return HOMincRef((InterpreterObject)self->opaqueStage()); }
    InterpreterObject soloLights()
    { return HOMincRef((InterpreterObject)self->opaqueSoloLights()); }
    InterpreterObject soloGeometry()
    { return HOMincRef((InterpreterObject)self->opaqueSoloGeometry()); }

    // We can ignore the type, value, and traceback Python objects.
    SWIGOUT(virtual void __exit__(
            InterpreterObject type, InterpreterObject value, 
            InterpreterObject traceback)
    { self->opaqueExit(); };)
}
#endif

};

#endif