PRM_Callback.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.
 *
 * NAME:        PRM_Callback.h (PRM Library, C++)
 *
 * COMMENTS:
 */

#ifndef __PRM_CALLBACK_H_INCLUDED__
#define __PRM_CALLBACK_H_INCLUDED__

#include "PRM_API.h"

#include <UT/UT_Assert.h>
#include <SYS/SYS_Types.h>


class PRM_Template;
class UT_Options;

/// This is a callback function that can be used to modify data.
/// It is invoked when the user uses a parameter of type PRM_CALLBACK
/// (this might be a button, or a menu).
/// @param data     Pointer to the node it was called on
/// @param index    The index of the menu entry
/// @param time     Current evaluation time
/// @param tplate   Pointer to the PRM_Template of the parameter it was
///                 triggered for.
/// @return It should return 1 if you want the dialog to refresh
///         (ie if you changed any values) and 0 otherwise.
class PRM_Callback
{
public:
    typedef int (*PRM_Callback32)(void *data, int index, fpreal32 time,
                                  const PRM_Template *tplate);
    typedef int (*PRM_Callback64)(void *data, int index, fpreal64 time,
                                  const PRM_Template *tplate);
    typedef int (*PRM_CallbackOpt32)(void *data, int index, fpreal32 time,
                                     const PRM_Template *tplate,
                                     const UT_Options *options);
    typedef int (*PRM_CallbackOpt64)(void *data, int index, fpreal64 time,
                                     const PRM_Template *tplate,
                                     const UT_Options *options);

    PRM_Callback()
        : myTag(TagCallback64)
        , myCallback64(nullptr)
    {
    }
    PRM_Callback(int ptr)
        : PRM_Callback()
    {
        UT_ASSERT(ptr == 0);
    }
    PRM_Callback(long int ptr)
        : PRM_Callback()
    {
        UT_ASSERT(ptr == 0);
    }
    PRM_Callback(std::nullptr_t)
        : PRM_Callback()
    {
    }
    PRM_Callback(PRM_Callback32 cb)
        : myTag(TagCallback32)
        , myCallback32(cb)
    {
    }
    PRM_Callback(PRM_Callback64 cb)
        : myTag(TagCallback64)
        , myCallback64(cb)
    {
    }
    PRM_Callback(PRM_CallbackOpt32 cb)
        : myTag(TagCallbackOpt32)
        , myCallbackOpt32(cb)
    {
    }
    PRM_Callback(PRM_CallbackOpt64 cb)
        : myTag(TagCallbackOpt64)
        , myCallbackOpt64(cb)
    {
    }

    int operator()(void *data, int index, fpreal64 time,
                   const PRM_Template *tplate)
    {
        switch (myTag)
        {
            case TagCallback64:
                return myCallback64(data, index, time, tplate);
            case TagCallback32:
                return myCallback32(data, index, fpreal32(time), tplate);
            case TagCallbackOpt64:
                return myCallbackOpt64(data, index, time, tplate, nullptr);
            case TagCallbackOpt32:
                return myCallbackOpt32(data, index, fpreal32(time), tplate,
                                       nullptr);
        }
        UT_ASSERT(!"Invalid tag");
        return 0;
    }
    int operator()(void *data, int index, fpreal64 time,
                   const PRM_Template *tplate,
                   const UT_Options *options)
    {
        switch (myTag)
        {
            case TagCallback64:
                return myCallback64(data, index, time, tplate);
            case TagCallback32:
                return myCallback32(data, index, fpreal32(time), tplate);
            case TagCallbackOpt64:
                return myCallbackOpt64(data, index, time, tplate, options);
            case TagCallbackOpt32:
                return myCallbackOpt32(data, index, fpreal32(time), tplate,
                                       options);
        }
        UT_ASSERT(!"Invalid tag");
        return 0;
    }
    bool operator==(const PRM_Callback &other)
    {
        if (myTag != other.myTag)
            return false;
        switch (myTag)
        {
            case TagCallback64:
                return myCallback64 == other.myCallback64;
            case TagCallback32:
                return myCallback32 == other.myCallback32;
            case TagCallbackOpt64:
                return myCallbackOpt64 == other.myCallbackOpt64;
            case TagCallbackOpt32:
                return myCallbackOpt32 == other.myCallbackOpt32;
        }
        UT_ASSERT(!"Invalid tag");
        return false;
    }

    bool isNotNull() const
    {
        switch (myTag)
        {
            case TagCallback64:
                return myCallback64;
            case TagCallback32:
                return myCallback32;
            case TagCallbackOpt64:
                return myCallbackOpt64;
            case TagCallbackOpt32:
                return myCallbackOpt32;
        }
        UT_ASSERT(!"Invalid tag");
        return false;
    }
    bool isNull() const
    {
        return !isNotNull();
    }

private:
    enum
    {
        TagCallback64,
        TagCallback32,
        TagCallbackOpt64,
        TagCallbackOpt32
    }                       myTag;
    union
    {
        PRM_Callback64      myCallback64;
        PRM_Callback32      myCallback32;
        PRM_CallbackOpt64   myCallbackOpt64;
        PRM_CallbackOpt32   myCallbackOpt32;
    };
};

#endif // __PRM_CALLBACK_H_INCLUDED__