HOM_anim.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_anim_h__
#define __HOM_anim_h__

#include "HOM_API.h"
#include "HOM_BinaryString.h"
#include "HOM_Defines.h"
#include "HOM_Errors.h"
#include "HOM_ElemPtr.h"
#include <SYS/SYS_Types.h>
#include <map>
#include <string>
#include <vector>

class HOM_Bookmark;
class HOM_EnumValue;
class HOM_Geometry;
class HOM_Node;

SWIGOUT(%rename(anim) HOM_anim;)

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

    virtual std::string __repr__() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Bookmark> > bookmarks() = 0;

    /// Saves the current list of bookmarks to a file, returning true on success
    SWIGOUT(%kwargs saveBookmarks;)
    virtual bool saveBookmarks(
            const char *filename,
            const std::vector<HOM_Bookmark *> &bookmarks = {},
            bool include_temporary = false)
            = 0;
    /// Loads the current list of bookmarks from a file, returning true on
    /// success
    virtual bool loadBookmarks(
            const char *filename,
            bool remove_existing = true)
            = 0;

    SWIGOUT(%kwargs saveBookmarksToString;)
    virtual HOM_BinaryString saveBookmarksToString(
            const std::vector<HOM_Bookmark *> &bookmarks = {},
            bool include_temporary = false,
            bool binary = true)
            = 0;

    virtual bool loadBookmarksFromString(
            HOM_BinaryString data,
            bool remove_existing = true)
            = 0;

    /// Deletes all bookmarks (note that this will invalidate any existing hom
    /// Bookmark objects
    virtual void clearBookmarks() = 0;

    SWIGOUT(%newobject newBookmark;)
    SWIGOUT(%kwargs newBookmark;)
    virtual HOM_Bookmark *newBookmark(const char *name, int start, int end) = 0;

    SWIGOUT(%newobject bookmark;)
    SWIGOUT(%kwargs bookmark;)
    virtual HOM_Bookmark *bookmark(int64 bookmark_id) = 0;

    // This method is deprecated in favor of bookmark
    SWIGOUT(%newobject getBookmark;)
    SWIGOUT(%kwargs getBookmark;)
    virtual HOM_Bookmark *getBookmark(int64 bookmark_id)
    { return bookmark(bookmark_id); }

    virtual void removeBookmarks(
            const std::vector<HOM_Bookmark *> &bm) = 0;

    /// Write the scoped geometry channels back into the provided mutable
    /// geometry. If the channel_names list is non-empty, only extract the
    /// channels with those names. Otherwise, all channels in the collection
    /// will be written into the geometry.
    virtual void mergeGeometryChannels(
            const std::string &collection_name,
            HOM_Geometry &geometry,
            const std::vector<std::string> &channel_names = {}) = 0;

    // This method is deprecated in favor of mergeGeometryChannels
    virtual void getGeometryChannels(
            const std::string &collection_name,
            HOM_Geometry &geometry,
            const std::vector<std::string> &channel_names = {})
    { mergeGeometryChannels(collection_name, geometry, channel_names); }

    virtual void setGeometryChannels(
            const std::string &collection_name,
            HOM_Geometry &geometry,
            const std::vector<std::string> &channel_names) = 0;

    virtual void setGeometryChannelsFromPattern(
            const std::string &collection_name,
            HOM_Geometry &geometry,
            const std::string &pattern = "") = 0;

    /// Sets a pending key at the current frame for the specified geometry
    /// channel
    virtual void setGeometryChannelPending(
            const std::string &collection_name,
            const std::string &channel_name,
            HOM_OptionalDouble value) = 0;

    virtual bool isGeometryChannelPending(
            const std::string &collection_name,
            const std::string &channel_name) = 0;

    /// Returns whether or not the given geometry channel is currently pinned
    /// If the channel name is ommitted, returns whether or not the
    /// entire collection is pinned instead.
    virtual bool isGeometryChannelPinned(
            const std::string &collection_name,
            const std::string &channel_name = "") = 0;

    virtual std::vector<std::string> pinnedGeometryChannels(
            const std::string &collection_name) = 0;
    // This method is deprecated in favor of pinnedGeometryChannels
    virtual std::vector<std::string> getPinnedGeometryChannels(
            const std::string &collection_name)
    { return pinnedGeometryChannels(collection_name); }

    virtual void lockGeometryChannelCollection(
            const std::string &collection_name, bool lock) = 0;

    SWIGOUT(%ignore addOpaqueBookmarksChangedCallback;)
    virtual void addOpaqueBookmarksChangedCallback(void *py_callback) = 0;
    SWIGOUT(%ignore removeOpaqueBookmarksChangedCallback;)
    virtual void removeOpaqueBookmarksChangedCallback(void *py_callback) = 0;


    SWIGOUT(%ignore addOpaqueGeometryChannelsChangedCallback;)
    virtual bool addOpaqueGeometryChannelsChangedCallback(const std::string &collection_name, void *callback, bool on_mouse_up) = 0;
    SWIGOUT(%ignore removeOpaqueGeometryChannelsChangedCallback;)
    virtual bool removeOpaqueGeometryChannelsChangedCallback(const std::string &collection_name, void *callback, bool on_mouse_up) = 0;

#ifdef SWIG
%extend
{
    void addBookmarksChangedCallback(InterpreterObject callback)
    { self->addOpaqueBookmarksChangedCallback(callback); }

    void removeBookmarksChangedCallback(InterpreterObject callback)
    { self->removeOpaqueBookmarksChangedCallback(callback); }

    virtual bool addGeometryChannelsChangedCallback(const std::string &collection_name, InterpreterObject callback, bool on_mouse_up = true)
    { return self->addOpaqueGeometryChannelsChangedCallback(collection_name, callback, on_mouse_up); }

    virtual bool removeGeometryChannelsChangedCallback(const std::string &collection_name, InterpreterObject callback, bool on_mouse_up = true)
    { return self->removeOpaqueGeometryChannelsChangedCallback(collection_name, callback, on_mouse_up); }
}
#endif

    virtual HOM_EnumValue &slopeMode() = 0;
    virtual void setSlopeMode(HOM_EnumValue &mode) = 0;
};

#endif