OP/OP_NetworkBoxItem.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:
 *      Joe Drew
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP_NetworkBoxItem.h (OP Library, C++)
 *
 * COMMENTS: The base class for anything which can go into a OP_NetworkBox.
 *           The only requirements for these classes are that they have an
 *           absolute X and Y position.
 */

#ifndef __OP_NetworkBoxItem__
#define __OP_NetworkBoxItem__

#include "OP_API.h"
#include <SYS/SYS_Types.h>
#include <UT/UT_PtrArray.h>

#include "OP_NetworkBoxItemFlags.h"

#define OP_NO_OWNER_NETWORK_BOX         "__NO_OWNER_NETWORK_BOX__"

class OP_Network;
class OP_NetworkBox;
class OP_NetworkBoxItem;
class OP_Node;
class UT_Color;
class UT_String;
class UT_HashTable;

typedef UT_PtrArray<OP_NetworkBoxItem *>        OP_NetworkBoxItemList;  

///This mask is used as a type to encompass all possible combinations of 
///OP_ItemType. 
typedef unsigned int                            OP_ItemTypeMask;

enum OP_ItemType
{
    OP_ITEMTYPE_NODE            = 0x00000001,   //OP_Node family
    OP_ITEMTYPE_INDIRECT        = 0x00000002,   //OP_InputIndirect family
    OP_ITEMTYPE_NETWORKBOX      = 0x00000004,   //OP_NetworkBox family
    OP_ITEMTYPE_POSTIT_NOTE     = 0x00000008,   //OP_PostIt family

    OP_ITEMTYPE_ALL             = 0xFFFFFFFF
                                 
};

class OP_API OP_NetworkBoxItem
{
public:
                         OP_NetworkBoxItem(OP_NetworkBoxItemFlags *flag = NULL);
    virtual             ~OP_NetworkBoxItem();

    virtual const OP_NetworkBoxItemFlags &flags() const { return *myFlags; }
    virtual OP_NetworkBoxItemFlags &flags() { return *myFlags; }

    /// Get and set the position of this item. Units are absolute, as opposed
    /// to relative units found in OPUI.
    virtual void         setXY(fpreal x, fpreal y) = 0;
    virtual fpreal       getX() const = 0;
    virtual fpreal       getY() const = 0;
    virtual fpreal       getW() const = 0;
    virtual fpreal       getH() const = 0;

    /// The following methods return the safe extents of the position of items.
    static fpreal        getMaxSafeX() { return  1e6; }
    static fpreal        getMinSafeX() { return -1e6; }
    static fpreal        getMaxSafeY() { return  1e6; }
    static fpreal        getMinSafeY() { return -1e6; }

    /// Set the node's location to a "good" position, using either the input
    /// or output nodes as the basis for the decision of what "good" means.
    /// The keepcentered flag tells us to move every item in our parent
    /// network _except_ us. The moveconnected flag causes this function to
    /// move items connected to the other side of this item to avoid overlaps
    /// when we move this item.
    void                 moveToGoodPosition(bool relativetoinputs = true,
                                            bool moveinputs = true,
                                            bool moveoutputs = true,
                                            bool moveunconnected = true);

    /// The owner box of an OP_NetworkBoxItem is the OP_NetworkBox which
    /// it's held in.
    /// If a box has no owner, its owner box will be returned as NULL.
    /// Owner box is NULL by default on construction.
    void                 setOwnerBox(OP_NetworkBox *box);
    OP_NetworkBox       *getOwnerBox() const;

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

    ///Returns the network that is our parent
    virtual OP_Network  *getParentNetwork() const = 0;

    /// Sets 'str' to be the path from 'parent' to this item. Pass in NULL for 
    /// 'parent' if you'd like the full path returned.
    void                 getPathFromParent(UT_String &str, 
                                           const OP_Node *parent) const;

    /// Returns true if the color has changed. NO implementation here, up to our
    /// children to implement this if needed.
    virtual bool                 setColor(const UT_Color &color);
    virtual const UT_Color      *getColor() const;
 
    /// Our children should implement this and return what type of item they are
    virtual OP_ItemType          getItemType() const = 0;

    /// Basically the same as OP_Node::getName(), but abstracted to a higher 
    /// level so we can call it on all items.
    virtual const UT_String     &getItemName() const = 0;

    /// getCreator is similar to getParentNetwork but it climbs the tree to
    /// find the network that originally created this network type. This 
    /// means that if you're down in a sub-network you climb right up to the
    /// parent of all the sub-nets. For SOPs this will return the object, 
    /// for COPs the icenet, for TOPs the Shader, for CHOPs the chopnet,
    /// for POPs the popnet. If the parent tree is truncated for some reason,
    /// we return whatever node is at the top.
    OP_Network                  *getCreator() const;

private:
    /// Fills an array with all network box items connected to this network
    /// box item. This function is sensitive to the type of this item,
    /// and avoids duplication and nesting (it won't return an item inside
    /// another item in the list).
    void                 getConnectedItems(OP_NetworkBoxItemList &items,
                                           bool inputs, bool recursive) const;

    /// Returns all the node and indirect input items contained by this
    /// network box, and any network boxes contained by this network box.
    void                 getContainedItems(OP_NetworkBoxItemList &items) const;

    /// Helper functions for the above two functions.
    static void          addItemToTable(const OP_NetworkBoxItem *item,
                                        UT_HashTable &connectedtable,
                                        bool inputs, bool recursive);
    static void          getConnectedItems(const OP_NetworkBoxItem *item,
                                           UT_HashTable &connectedtable,
                                           bool inputs, bool recursive);
    static void          getContainedItems(const OP_NetworkBox *box,
                                           OP_NetworkBoxItemList &items);

    OP_NetworkBox               *myOwnerBox;
    OP_NetworkBoxItemFlags      *myFlags;
};

#endif

---