OP/OP_InputIndirect.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.
 *
 * Produced by:
 *      Side Effects Software Inc.
 *      477 Richmond St. West
 *      Toronto, Ontario,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        OP_InputIndirect.h (C++)
 *
 * COMMENTS: OP_InputIndirect is used to maintain an indirect input
 *      for a macro or sub-network. The input is a reference to one
 *      of the inputs to the owner of this node. The owner will be
 *      the macro/sub-net. It will maintain a list of these indirect
 *      input references. The actual nodes that connect to this
 *      indirect reference will have their OP_Input's flagged as
 *      indirect and will include a pointer to one of these indirect
 *      input objects.
 */

#ifndef _OP_InputIndirect_h_
#define _OP_InputIndirect_h_

#include "OP_API.h"
#include <iostream.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_String.h>

#include "OP_PropagateData.h"
#include "OP_Value.h"
#include "OP_NetworkBoxItem.h"

#define OP_INVALID_INDIRECT_ID  -999

class OP_Input;
class OP_Node;
class OP_Network;

class OP_API OP_InputIndirect : public OP_NetworkBoxItem
{
public:
             OP_InputIndirect(OP_Network *net, int input_index,
                              float x=0.0F, float y=0.0F);
    virtual ~OP_InputIndirect();

    virtual int          save(ostream &os, int bin) const;
    virtual bool         load(UT_IStream &is);

    virtual int          setPicked(int on_off, 
                                   bool propagate_parent_event = true);
    virtual int          getPicked() const;

//  Get the Node that this input refers to.  May return NULL
//  This simply goes to the owner and asks him for the input specified
//  by our input index. Nothing too magic here. It's mostly bookkeeping.
//
    virtual OP_Node     *getNode();

//  myOwner is the subnet itself
    virtual void         setOwner(OP_Network *net, int input_index);
    OP_Network          *getOwner()      const { return myOwner; }
    int                  getInputIndex() const { return myInputIndex; }

    //Return the network this item resides in (i.e. getOwner())
    virtual OP_Network  *getParentNetwork() const;
    
//
//  We maintain a list of output nodes so that we can do things to
//  them, like inform them when we're being deleted.
//
    unsigned             getNOutputs() const { return myOutputs.entries(); }
    OP_Node             *getOutput(unsigned idx) const
                         {
                           return (idx < getNOutputs()) ? myOutputs(idx) : 0;
                         }
//
//  The disconnect method will disconnect this indirect input from
//  all the nodes that it outputs to. This is done upon destruction.
//
    void                 disconnect();

    //
    //  Position is used by the UI.
    //
    virtual void         setXY(fpreal x, fpreal y);
    virtual fpreal       getX() const { return myPosX;          }
    virtual fpreal       getY() const { return myPosY;          }

    // Absolute Width & Height
    virtual fpreal       getW() const;
    virtual fpreal       getH() const;

    OP_InputIndirect    &operator=(const OP_InputIndirect &from);

    virtual OP_ItemType          getItemType() const;

    ///Note that indirect inputs don't support names at this point, so this 
    ///always returns an empty string.
    virtual const UT_String     &getItemName() const;

protected:
    void                 addOutput(OP_Node *);
    void                 delOutput(OP_Node *);
    void                 propagateChange(OP_EventType type, void *data=0);
    void                 propagateModification(OP_Node *by_whom,
                                               OP_EventType reason,
                                               int parm_index,
                                               OP_PropagateData &prop_data);
    unsigned int         getUniqueId();
    unsigned int         getUniqueId() const { return myUniqueId; }

    OP_Network                  *myOwner;
    UT_PtrArray<OP_Node *>       myOutputs;
    float                        myPosX;                // For UI
    float                        myPosY;
    short                        myInputIndex;
    short                        myFlags;

private:
    /// Sets X and Y without making an undo block
    void                 onlySetXY(float x, float y);
    void                 clearId() { myUniqueId = 0; }

    UT_String            myName;
    
    unsigned int         myUniqueId;

    friend ostream      &operator<<(ostream &os, const OP_InputIndirect &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
    friend class        OP_Input;
    friend class        OP_Network;
};

#endif

---