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

#ifndef __OP_CommandManager__
#define __OP_CommandManager__

#include "OP_API.h"
#include "OP_Types.h"

#include <CMD/CMD_Manager.h>

class UT_WorkBuffer;
class OP_Node;
class PRM_Parm;
class CH_Channel;
class CH_ChannelRef;
class OP_GeometryChannels;

class OP_API OP_CommandManager: public CMD_Manager
{
public:
             OP_CommandManager(const char *appname);
            ~OP_CommandManager() override;


    bool    isChanRefValid( const CH_ChannelRef &chref) const override;

    /// The following methods are used to extract information from channel
    /// references.
    virtual void         getChRefData(const CH_ChannelRef &r, 
                                      OP_Node **pnode, CH_Channel **pchp, 
                                      PRM_Parm **ppparm, int *subindex) const;

    virtual OP_Node     *getChRefOpNode(const CH_ChannelRef &r) const;

    virtual int          getChRefParmIndex(
                            const CH_ChannelRef &r,
                            int *subindex) const;
    virtual PRM_Parm    *getChRefParm(
                            const CH_ChannelRef &r,
                            int *subindex) const;

    virtual PRM_Parm    *getChRefFullParm(const CH_ChannelRef &r) const;

    CH_Channel          *getChRefChannel(const CH_ChannelRef &r) const override;

    bool                 isOwnerExposed(const CH_ChannelRef &r) const override;

    void                 getChannelsWithNodeId(CH_ChannelList &chans,
                                               int node_id) const override;

    /// This method will return true if the channel reference r matches the
    /// pattern patt, or false otherwise.
    bool                 match(const CH_ChannelRef &r, const char *patt) const;


    /// The following methods are used to build channel references using,
    /// nodes, parms or channels.  The passed in channel reference r will
    /// be filled in with the appropriate data.
    /// Return true if success, false otherwise.
    bool                 buildChanRef(CH_ChannelRef &r,
                                      const CH_Channel *chp) const override;

    virtual bool         buildChanRef(CH_ChannelRef &r, 
                                               const OP_Node *node,
                                               const PRM_Parm *parm) const;

    virtual bool         buildChanRef(CH_ChannelRef &r, 
                                               const OP_Node &node,
                                               const char *channel_name) const;

    virtual bool         buildChanRef(CH_ChannelRef &r, 
                                               const OP_Node *node, 
                                               const PRM_Parm *parm, 
                                               int subindex) const;
    bool                 buildChanRef(CH_ChannelRef &r,
                                      const char *path) const override;


    /// Returns 0 if r1 and r2 are equal, -1 if r1 < r2 and 1 if r1 > r2
    int                  compareChanRefs(
                                const CH_ChannelRef &r1,
                                const CH_ChannelRef &r2) const override;

    /// Returns 0 if r1 and r2 are equal, -1 if r1 < r2 and 1 if r1 > r2
    int                  compareLayerRefs(
                                const CH_ChannelRef &r1,
                                const CH_ChannelRef &r2) const override;

    // Returns a full path from a given channel reference
    void                 getChanRefPath(
                                const CH_ChannelRef &r,
                                UT_String &path,
                                bool use_alias = false) const override;

    /// Returns Python code representing the list of channel references
    void                 getChanRefsPythonListCode(
                                        const CH_ChannelRefList &chanrefs,
                                        UT_WorkBuffer &result);

    /// Returns a list of unique nodes corresponding to the given channel ref
    /// list. The order of the nodes will match chanrefs.
    static void          getChRefUniqueNodes(const CH_ChannelRefList &chanrefs,
                                             UT_ValArray<OP_Node *> &nodes);

    // Query trust using the current operational context.
    bool                 inTrustedContextForNode(const OP_Node *node, int thread) const;
    bool                 inTrustedContextForNodeContents(
                                         const OP_Node *node, int thread) const;

    CH_ScriptAccessManager *getAccessManager(int thread) override;

    bool                 resolveChanRefExport(
                                const CH_ChannelRef& r,
                                CH_ChannelRef& out_export) override;

    bool                 getChannelAutoSelect(
                                const CH_ChannelRef &chref) const override;

    // Resolve channel labels and node path without exposing OP_Node*
    bool                 getChRefLabelForUI(
                                const CH_ChannelRef &r,
                                UT_String &ret) const override;
    bool                 getChRefAlias(
                                const CH_ChannelRef &r,
                                UT_String &ret) const override;
    bool                 getChRefNodePath(
                                const CH_ChannelRef &r,
                                UT_String &ret) const override;

    CH_Collection       *addGeometryChannelsCollection(
                                 const UT_StringHolder &name);

    void                 destroyGeometryChannelsCollection(
                                 const UT_StringHolder &name);

    OP_GeometryChannels *getGeometryChannelsCollection(
                                 const UT_StringHolder &name) const;

    // The following methods are used to
    // inform the OP_CommandManager that channels are being actively modified
    // (ie, handles are being dragged). This allows the
    // OP_CommandManger/OP_GeometryChannels to keep track of which
    // channels/collections have been changed, and trigger callbacks with
    // Finished/MouseUp notifications when endChannelChanges is called.
    // Note that a better way to handle this whole process would
    // be to pass START/UPDATE/END along with the channel changed CH_Event, so
    // that this can be handled at the OP_GeometryChannels setChanged level,
    // but this would be a larger project which can be revisited later.
    // This should be used anywhere channels are changed interactively,
    // including the AnimationEditor (SI_ChannelGraph) and AnimationToolbar
    void                 beginChannelChanges() override;
    void                 channelsChanged() override;
    void                 endChannelChanges() override;
    bool                 channelsBeingChanged() override;
    bool                 isHandlingChannelChanges()
                         { return myHandlingChannelChanges; }

    /// Mark a geometry channels collection as changed.
    /// beginChannelChanges must have been called previously.
    /// On the next call to endChannelChanges, "Finished" notifications
    /// will be sent out for all collections registered with this method.
    void                 geometryChannelsCollectionChanged(
                                 const UT_StringHolder &name);

    /// Register a new callback to notify of changes to geometry channels within
    /// a geometry channel collection
    int                  addGeometryChannelsChangedCallback(
                                 const UT_StringHolder &collection_name,
                                 OP_GeometryChannelsChangedCallback callback);

    /// Remove a geometry channels changed callback
    void                 removeGeometryChannelsChangedCallback(
                                 const UT_StringHolder &collection_name,
                                 int id);

private:
    // Keeps track of the count of how many actors (such as a channel graph)
    // are actively modifying (geometry) channels.
    int myActiveChannelChangesCount;
    bool myHandlingChannelChanges;

    // Set of geometry channel collections that have been modified since
    // the last call to beginChannelChanges.
    UT_StringSet myChangedGeometryChannelCollections;
};

#endif