UINetwork.h

// Copyright (C) 2001 Jean-Marc Valin

#ifndef UINETWORK_H
#define UINETWORK_H

//#include <gnome.h>
//#include "UIDocument.h"
#include <vector>
#include <string>
#include <libxml/tree.h>
#include <fstream>
#include <pthread.h>
#include "UINetTerminal.h"
#include "UINodeParameters.h"
#include "UINodeRepository.h"
#include <set>

namespace FD {
//struct xmlNode;
class ItemInfo;
class UINode;
class UITerminal;
class UILink;
class UINodeMenu;
class UIDocument;
class UINote;
//class UINetTerminal;

class Network;
class ParameterSet;

class UINetwork {
  public:
   enum Type {subnet=0, iterator=1, threaded=2};
protected:

   bool destroyed;

   UIDocument *doc;

   std::string name;

   std::string m_description;

   Type type;

   std::vector <UINode *> nodes;

   std::vector <UILink *> links;

   std::vector <UINetTerminal *> terminals;

   std::vector <UINote*> m_notes;

   //UINode *conditionNode;
private:
   
   bool buildRecurs;
public:
   UINetwork(UIDocument *_doc, std::string _name, Type _type);

   UINetwork(UIDocument *_doc, xmlNodePtr net, bool init=true);

   void load (xmlNodePtr net);

   virtual ~UINetwork();

   void setModified();

   UINode *loadNode (xmlNodePtr node);
   
   UINode *getNodeNamed(std::string n);
   
   void addNode(UINode *node);

   void removeNode (UINode *node);

   void addLink (UILink *link);

   void removeLink (UILink *link);

   const std::string &getName() {return name;}

   std::string getDescription() {return m_description;}

   void setDescription(const std::string & _description){m_description = _description;}

   
   Type getType() {return type;}

   UIDocument *getDocument() {return doc;}

   bool isIter() {return type==iterator;}


   void saveXML(xmlNode *root);

   virtual void newNetNotify(const std::string &cat, const std::string &type);

   void addTerminal(UINetTerminal *term);

   void removeTerminal(UINetTerminal *term);

   std::vector<std::string> getTerminals(UINetTerminal::NetTermType termType);

   void insertNetParams(std::vector<ItemInfo *> &params);

   virtual UINode *newNode(UINetwork* _net, xmlNodePtr def);
   
   virtual UINode *newNode(UINetwork* _net, std::string _name, 
                                                   std::string _type, double _x, double _y, bool doInit);

//   virtual UITerminal *newTerminal (string _name, UINode *_node, bool _isInput, double _x, double _y);

   virtual UILink *newLink (UITerminal *_from, UITerminal *_to, char *str=NULL);


   virtual UINote* newNote(const std::string &text, double x, double y, bool visible);


   virtual UINetTerminal *newNetTerminal (UITerminal *_terminal, UINetTerminal::NetTermType _type, const std::string &_name, 
                                          const std::string &_objType="any", const std::string &_description="No description available");

   Network *build(const std::string &netName, const ParameterSet &params);

   void genCode(std::ostream &out, int &id, std::set<std::string> &nodeList);
 
   std::vector<UINode *> getNodes() {return nodes;}
   std::vector<UILink *> getLinks() {return links;}
   std::vector<UINetTerminal *> getTerminals() {return terminals;}

   std::vector<UINote*> getNotes() {return m_notes;}

   void addNote(UINote *note);


   void removeNote(UINote *note);
   
   
   virtual void rename(std::string newName);

   void interfaceChangeNotify();

   virtual void updateAllSubnetTerminals(const std::string _nettype, const std::string _terminalname, 
                                         UINetTerminal::NetTermType _terminaltype, bool _remove); 


   virtual void updateAllSubnetParameters(const std::string _nettype, NodeInfo* _info);

};

}//namespace FD
#endif

---