开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
netmodel.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：87k
源码类别：

通讯编程

开发平台：

Visual C++

netmodel.cc：源码内容
  1. /*
  2.  * Copyright (c) 1991,1993 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *      This product includes software developed by the Computer Systems
  16.  *      Engineering Group at Lawrence Berkeley Laboratory.
  17.  * 4. Neither the name of the University nor of the Laboratory may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  * @(#) $Header: /cvsroot/nsnam/nam-1/netmodel.cc,v 1.113 2006/11/19 00:12:29 tom_henderson Exp $ (LBL)
  34.  */
  36. #include <stdlib.h>
  37. #ifdef WIN32
  38. #include <windows.h>
  39. #endif
  40. #include <stdio.h>
  41. #include <ctype.h>
  42. #include <math.h>
  43. #include <tcl.h>
  44. #include <tclcl.h>
  46. #include "config.h"
  47. #include "netview.h"
  48. #include "psview.h"
  49. #include "testview.h"
  50. #include "animation.h"
  51. #include "group.h"
  52. #include "tag.h"
  53. #include "queue.h"
  54. #include "drop.h"
  55. #include "packet.h"
  56. #include "edge.h"
  57. #include "lan.h"
  58. #include "node.h"
  59. #include "agent.h"
  60. #include "feature.h"
  61. #include "route.h"
  62. #include "netmodel.h"
  63. #include "monitor.h"
  64. #include "trace.h"
  65. #include "paint.h"
  66. #include "sincos.h"
  67. #include "state.h"
  68. #include "editview.h"
  69. #include "address.h"
  70. #include "animator.h"
  72. #include <float.h>
  74. extern int lineno;
  75. // not used
  76. //static int next_pat;
  78. class NetworkModelClass : public TclClass {
  79. public:
  80. NetworkModelClass() : TclClass("NetworkModel") {}
  81. TclObject* create(int argc, const char*const* argv) {
  82. if (argc < 5) 
  83. return 0;
  84. return (new NetModel(argv[4]));
  85. }
  86. } networkmodel_class;
  88. //----------------------------------------------------------------------
  89. //----------------------------------------------------------------------
  90. NetModel::NetModel(const char *animator) :
  91. TraceHandler(animator),
  92. drawables_(0),
  93. animations_(0),
  94. queues_(0),
  95. views_(0),
  96. nodes_(0),
  97. lans_(0), 
  98. node_sizefac_(NODE_EDGE_RATIO),
  99. mon_count_(0),
  100. monitors_(NULL),
  101. wireless_(0),
  102. resetf_(0),
  103. selectedSrc_(-1),
  104. selectedDst_(-1),
  105. selectedFid_(-1),
  106. hideSrc_(-1),
  107. hideDst_(-1),
  108. hideFid_(-1),
  109. colorSrc_(-1),
  110. colorDst_(-1),
  111. colorFid_(-1),
  112. showData_(1), 
  113. showRouting_(1),
  114. showMac_(1),
  115. selectedColor_(-1),
  116. nGroup_(0), 
  117. nTag_(0),
  118. parsetable_(&traceevent_) {
  120. int i;
  121. for (i = 0; i < EDGE_HASH_SIZE; ++i) {
  122. hashtab_[i] = 0;
  123. }
  125. for (i = 0; i < PTYPELEN; ++i) {
  126. selectedTraffic_[i] = '' ;
  127. colorTraffic_[i] = '' ;
  128. hideTraffic_[i] = '' ;
  129. }
  131. // Default node size is 10.0 so a default packet will be 25% of that (2.5)
  132. // This value is modified whenever a node is added.  It will be based on 
  133. // the running average of the size of the last 5 nodes.  Look at 
  134. // NetModel::addNode(const TraceEvent &e) for more details
  135. packet_size_ = 2.5;
  136.   
  137. /*XXX*/
  138. nymin_ = 1e6;
  139. nymax_ = -1e6;
  141. Paint *paint = Paint::instance();
  142. int p = paint->thin();
  143. // Initially 256 colors. Can be extended later.
  144. // See handling of otcl binding "color"
  145. nclass_ = 256;
  146. paintMask_ = 0xff;
  147. paint_ = new int[nclass_];
  148. oldpaint_ = new int[nclass_];
  149. for (i = 0; i < nclass_; ++i) {
  150. paint_[i] = p;
  151. oldpaint_[i] = p;
  152.   }
  154. addrHash_ = new Tcl_HashTable;
  155. Tcl_InitHashTable(addrHash_, TCL_ONE_WORD_KEYS);
  156. grpHash_ = new Tcl_HashTable;
  157. Tcl_InitHashTable(grpHash_, TCL_ONE_WORD_KEYS);
  158. tagHash_ = new Tcl_HashTable;
  159. Tcl_InitHashTable(tagHash_, TCL_STRING_KEYS);
  161. objnameHash_ = new Tcl_HashTable;
  162. Tcl_InitHashTable(objnameHash_, TCL_STRING_KEYS);
  163. registerObjName("ALL", ClassAllID);
  164. registerObjName("ANIMATION", ClassAnimationID);
  165. registerObjName("NODE", ClassNodeID);
  166. registerObjName("PACKET", ClassPacketID);
  167. registerObjName("EDGE", ClassEdgeID);
  168. registerObjName("QUEUEITEM", ClassQueueItemID);
  169. registerObjName("LAN", ClassLanID);
  170. registerObjName("TAG", ClassTagID);
  171. registerObjName("AGENT", ClassAgentID);
  173. bind("bcast_duration_", &bcast_duration_);
  174. bind("bcast_radius_", &bcast_radius_);
  175. }
  177. NetModel::~NetModel()
  178. {
  179. // We should delete everything here, if we want deletable netmodel...
  180. delete paint_;
  181. Animation *a, *n;
  182. for (a = animations_; a != 0; a = n) {
  183. n = a->next();
  184. delete a;
  185. }
  186. for (a = drawables_; a != 0; a = n) {
  187. n = a->next();
  188. delete a;
  189. }
  191. Tcl_DeleteHashTable(grpHash_);
  192. delete grpHash_;
  193. Tcl_DeleteHashTable(tagHash_);
  194. delete tagHash_;
  195. Tcl_DeleteHashTable(objnameHash_);
  196. delete objnameHash_;
  197. }
  199. void NetModel::update(double now)
  200. {
  201. Animation *a, *n;
  202. for (a = animations_; a != 0; a = n) {
  203. n = a->next();
  204. a->update(now);
  205. }
  207. /*
  208.  * Draw all animations and drawables on display to reflect
  209.  * current time.
  210.  */
  211. now_ = now;
  212. for (View* p = views_; p != 0; p = p->next_) {
  213. //  Calls View::draw() which calls NetView::render()
  214. //  which calls NetModel::render(View*)
  215. p->draw();
  216. }
  217. }
  219. void NetModel::update(double now, Animation* a) {
  220. a->update(now);
  221. for (View* p = views_; p != 0; p = p->next_)
  222. a->draw(p, now);
  223. }
  225. //----------------------------------------------------------------------
  226. // void
  227. // NetModel::reset(double now)
  228. //   - Reset all animations and queues to time 'now'.
  229. //----------------------------------------------------------------------
  230. void
  231. NetModel::reset(double now) {
  232. Animation* a;
  233. for (a = animations_; a != 0; a = a->next())
  234. a->reset(now);
  235. for (a = drawables_; a != 0; a = a->next())
  236. a->reset(now);
  237. for (Queue* q = queues_; q != 0; q = q->next_)
  238. q->reset(now);
  239. }
  241. //----------------------------------------------------------------------
  242. // void
  243. // NetModel::render(View * view)
  244. //   - Draw this NetModel's drawables, animations, and monitors.
  245. //     (tags, nodes, edges, packets, queues, etc.)
  246. //----------------------------------------------------------------------
  247. void
  248. NetModel::render(View* view) {
  249. Animation *a;
  250. Monitor *m;
  252. for (a = drawables_; a != 0; a = a->next()) 
  253.   a->draw(view, now_);
  255. for (a = animations_; a != 0; a = a->next())
  256.   a->draw(view, now_);
  258. for ( m = monitors_; m != NULL; m = m->next())
  259.   m->draw_monitor(view, nymin_, nymax_);
  260. }
  262. void NetModel::render(PSView* view) {
  263. Animation *a;
  264. for (a = drawables_; a != 0; a = a->next())
  265.   a->draw(view, now_);
  266. for (a = animations_; a != 0; a = a->next())
  267.   a->draw(view, now_);
  268. }
  270. void NetModel::render(TestView* view) {
  271. Animation *a;
  272. for (a = drawables_; a != 0; a = a->next())
  273.   a->draw(view, now_);
  274. for (a = animations_; a != 0; a = a->next())
  275.   a->draw(view, now_);
  276. }
  278. //----------------------------------------------------------------------
  279. // NetModel::EdgeHashNode *
  280. // NetModel::lookupEdgeHashNode(int src, int dst) const
  281. //   - Return a pointer to the edge between 'src' and 'dst'. 
  282. //----------------------------------------------------------------------
  283. NetModel::EdgeHashNode *
  284. NetModel::lookupEdgeHashNode(int source, int destination) const
  285. {
  286. EdgeHashNode* h;
  287. for (h = hashtab_[ehash(source, destination)]; h != 0; h = h->next)
  288. if (h->src == source && h->dst == destination)
  289. break;
  290. return (h);
  291. }
  293. int NetModel::addAddress(int id, int addr) const
  294. {
  295. int newEntry = 1;
  296. Tcl_HashEntry *he = 
  297. Tcl_CreateHashEntry(addrHash_, (const char *)addr, &newEntry);
  298. if (he == NULL)
  299. return -1;
  300. if (newEntry) {
  301. Tcl_SetHashValue(he, (ClientData)id);
  302. }
  303. return 0;
  304. }
  306. int NetModel::addr2id(int addr) const 
  307. {
  308. Tcl_HashEntry *he = Tcl_FindHashEntry(addrHash_, (const char *)addr);
  309. if (he == NULL)
  310. return -1;
  311. return *Tcl_GetHashValue(he);
  312. }
  314. //----------------------------------------------------------------------
  315. //  Adds an edge to a hash table?
  316. //----------------------------------------------------------------------
  317. void NetModel::enterEdge(Edge* e) {
  318. int src = e->src();
  319. int dst = e->dst();
  320. EdgeHashNode *h = lookupEdgeHashNode(src, dst);
  321. if (h != 0) {
  322. /* XXX */
  323. fprintf(stderr, "nam: duplicate edge (%d,%d)n", src, dst);
  324. //exit(1);
  325. return;
  326. }
  327. h = new EdgeHashNode;
  328. h->src = src;
  329. h->dst = dst;
  330. h->queue = 0;
  331. h->edge = e;
  332. int k = ehash(src, dst);
  333. h->next = hashtab_[k];
  334. hashtab_[k] = h;
  335. }
  337. //----------------------------------------------------------------------
  338. // void
  339. // NetModel::removeEdge(Edge* e)
  340. //   - Remove an edge from the network model and delete it
  341. //----------------------------------------------------------------------
  342. void
  343. NetModel::removeEdge(Edge* e) {
  344.   int k;
  345.   int src = e->src();
  346.   int dst = e->dst();
  347.   EdgeHashNode * h = lookupEdgeHashNode(src, dst);
  348.   EdgeHashNode * f, * g;  
  350.   if (h == 0) {
  351.     fprintf(stderr, "nam: trying to delete nonesisting edge (%d,%d)n", src, dst);
  352.     exit(1);
  353.   }
  355.   //XXX do we need to process queue ? leave it to the future 10/01/98
  356.   k = ehash(src, dst);
  358.   for (f = hashtab_[k]; f != 0; f = f->next) {
  359.     if (h->src == f->src && h->dst == f->dst) {
  360.       if (f == hashtab_[k]) {
  361.         hashtab_[k] = f->next;
  362.         break;
  363.       } else {
  364.         g->next = f->next;      
  365.         break;
  366.       } 
  367.     }
  368.     g = f;
  369.   }
  371.   
  372.   
  373.   delete h;
  374. }
  376. //----------------------------------------------------------------------
  377. // void 
  378. // NetModel::BoundingBox(BBox& bb) {
  379. // XXX Make this cheaper (i.e. cache it)
  380. //----------------------------------------------------------------------
  381. void NetModel::BoundingBox(BBox& bb) {
  382. /* ANSI C limits, from float.h */
  383. bb.xmin = bb.ymin = FLT_MAX;
  384. bb.xmax = bb.ymax = -FLT_MAX;
  386. for (Animation* a = drawables_; a != 0; a = a->next()) 
  387. a->merge(bb);
  388. }
  390. /*
  391.  Animation* NetModel::inside(double now, float px, float py) const
  392.  {
  393.   for (Animation* a = animations_; a != 0; a = a->next())
  394.   if (a->inside(now, px, py))
  395.   return (a);
  396.   for (Animation* d = drawables_; d != 0; d = d->next())
  397.   if (d->inside(now, px, py))
  398.   return (d);
  400.   return (0);
  401.  }
  402. */
  403. // Used exclusively for start_info() in nam.tcl. It ignores all tag objects
  404. // and therefore should *not* be used for editing.
  406. Animation* NetModel::inside(float px, float py) const
  407. {
  409. for (Animation* a = animations_; a != 0; a = a->next()) {
  410.      if (a->type() == BPACKET) {
  411.         BPacket* b = (BPacket* ) a ;
  412. if ((b->inside(px, py)) && (a->classid() != ClassTagID))
  413. return (a);
  414.      } 
  415.      else  {
  416. if ((a->inside(px, py)) && (a->classid() != ClassTagID))
  417. return (a);
  418.      }
  419. }
  420. for (Animation* d = drawables_; d != 0; d = d->next()) {
  421. if ((d->inside(px, py) && (d->classid() != ClassTagID)))
  422. return (d);
  423. }
  425. return (0);
  426. }
  428. int NetModel::add_monitor(Animation *a)
  429. {
  430.   Monitor *m = new Monitor(mon_count_, a, node_size_);
  431.   m->next(monitors_);
  432.   monitors_=m;
  433.   return mon_count_++;
  434. }
  436. int NetModel::monitor(double now, int monitor, char *result, int len)
  437. {
  438.   /*XXX should get rid of this search*/
  439.   for(Monitor *m=monitors_; m!=NULL; m=m->next()) {
  440.     if (m->monitor_number()==monitor) {
  441.       m->update(now, result, len);
  442.       if (strlen(result)==0)
  443. delete_monitor(m);
  444.       return 0;
  445.     }
  446.   }
  447.   result[0]='';
  448.   return -1;
  449. }
  451. //----------------------------------------------------------------------
  452. // void NetModel::check_monitors(Animation *a)
  453. //   - A new animation just got created.  Check to see if we should 
  454. //     already have a monitor on it.
  455. //----------------------------------------------------------------------
  456. void NetModel::check_monitors(Animation *a) {
  457. MonState * ms;
  458. Monitor * m;
  459. // Returns a "newed" MonState
  460. ms = a->monitor_state();
  462. if (ms == NULL) {
  463. return;
  464. }
  466. for(m = monitors_; m != NULL; m = m->next()) {
  467. if ((m->mon_state_ != NULL) &&
  468. (m->mon_state_->type = ms->type)) {
  470. switch (ms->type) {
  471. case MON_PACKET:
  472. if (m->mon_state_->pkt.id == ms->pkt.id) {
  473. m->anim(a);
  474. delete ms;
  475.   return;
  476. }
  477. break;
  478. case MON_ROUTE: 
  479. if ((m->mon_state_->route.src == ms->route.src)&&
  480. (m->mon_state_->route.group == ms->route.group)) {
  481. m->anim(a);
  482. delete ms;
  483. return;
  484. }
  485. break;
  486. }
  487. }
  488. }
  490. //  What happens to ms after the end of this function?  Maybe the memory leak?
  491. // fprintf(stderr, "Reached outside of check_monitorsn");
  492. }
  494. void NetModel::delete_monitor(int monitor)
  495. {
  496.   /*this version of delete_monitor is called from the GUI*/
  497.   /*given a monitor, remove it from the model's monitor list*/
  498.   Monitor *tm1, *tm2;
  499.   if (monitors_==NULL)
  500.     return;
  501.   tm1=monitors_;
  502.   tm2=monitors_;
  503.   while ((tm1!=NULL)&&(tm1->monitor_number()!=monitor))
  504.     {
  505.       tm2=tm1;
  506.       tm1=tm1->next();
  507.     }
  508.   if (tm1!=NULL)
  509.     {
  510.       tm2->next(tm1->next());
  511.       if (tm1==monitors_)
  512. monitors_=tm1->next();
  513.       if (tm1->anim()!=NULL)
  514. tm1->anim()->remove_monitor();
  515.       delete tm1;
  516.     }
  517. }
  519. void NetModel::delete_monitor(Monitor *m)
  520. {
  521.   /*given a monitor, remove it from a node's agent list*/
  522.   Monitor *tm1, *tm2;
  523.   if (monitors_==NULL)
  524.     return;
  525.   tm1=monitors_;
  526.   tm2=monitors_;
  527.   while ((tm1!=m)&&(tm1!=NULL))
  528.     {
  529.       tm2=tm1;
  530.       tm1=tm1->next();
  531.     }
  532.   if (tm1!=NULL)
  533.     {
  534.       tm2->next(tm1->next());
  535.       if (tm1==monitors_)
  536. monitors_=tm1->next();
  537.       tm1->anim()->remove_monitor();
  538.       delete tm1;
  539.     }
  540. }
  542. void NetModel::delete_monitor(Animation *a)
  543. {
  544.   /*given a monitor, remove it from a node's agent list*/
  545.   /*this version gets called when an animation deletes itself*/
  546.   /*XXX animations sometimes get deleted when the packet changed link*/
  547.   Monitor *tm1, *tm2;
  548.   if (monitors_==NULL)
  549.     return;
  550.   tm1=monitors_;
  551.   tm2=monitors_;
  552.   while ((tm1!=NULL)&&(tm1->anim()!=a))
  553.     {
  554.       tm2=tm1;
  555.       tm1=tm1->next();
  556.     }
  557.   if (tm1!=NULL)
  558.     {
  559.       tm2->next(tm1->next());
  560.       if (tm1==monitors_)
  561. monitors_=tm1->next();
  562.       delete tm1;
  563.     }
  564. }
  566. void NetModel::saveState(double tim)
  567. {
  568. State* state = State::instance();
  569. StateInfo min;
  570. min.time = 10e6;
  571. min.offset = 0;
  572. Animation *a, *n;
  573. StateInfo si;
  575. /*
  576.  * Update the animation list first to remove any unnecessary
  577.  * objects in the list.
  578.  */
  579. for (a = animations_; a != 0; a = n) {
  580. n = a->next();
  581. a->update(tim);
  582. }
  583. for (a = animations_; a != 0; a = n) {
  584. n = a->next();
  585. si = a->stateInfo();
  586. if (si.time < min.time)
  587. min = si;
  588. }
  589. if (min.offset)
  590. state->set(tim, min);
  591. }
  593. //---------------------------------------------------------------------
  594. // void 
  595. // NetModel::handle(const TraceEvent& e, double now, int direction)
  596. //   - Trace event handler.
  597. //---------------------------------------------------------------------
  598. void 
  599. NetModel::handle(const TraceEvent& e, double now, int direction) {
  600.   QueueItem *q;
  601.   EdgeHashNode *ehn, *ehnrev;
  602.   Edge* ep;
  603.   Node *n;
  604.   //Packet *p;
  605.   Route *r;
  606.   Agent *a;
  607.   Feature *f;
  608.   float x, y;
  609.   int pno;
  610.   double txtime;
  611.   bool do_relayout = false;
  613.   if (e.time > State::instance()->next())
  614.     saveState(e.time);
  616.   switch (e.tt) {
  617.     case 'T':
  618.       // Dummy event no-op used for realtime time synchronization
  619.       break;
  620.               
  621.     case 'v': {  
  622.       // 'variable' -- just execute it as a tcl command 
  623.       if (nam_ == 0) {
  624.         fprintf(stderr, "Couldn't evaluate %s without animatorn",
  625.           e.image);
  626.         break;
  627.       }
  628.       const char *p = e.image + e.ve.str;
  629.       char *q = new char[strlen(nam_->name()) + strlen(p) + 2];
  630.       sprintf(q, "%s %s", nam_->name(), p);
  631.       Tcl::instance().eval(q);
  632.       delete []q;
  633.       break;
  634.     }
  635.     
  636.     case 'h':
  637.       // traffic filter
  638.       if (wireless_) {
  639.         if (strcmp(e.pe.pkt.wtype,"AGT") == 0 ) return ; 
  640.         if (!showData_) { // filter out data packet
  641.            if ((strcmp(e.pe.pkt.wtype,"RTR") == 0 ) ||
  642.                (strcmp(e.pe.pkt.wtype,"MAC") == 0 )) {
  643.               if (((strcmp(e.pe.pkt.type,"cbr") == 0) ||
  644.                    (strcmp(e.pe.pkt.type,"tcp") == 0) ||
  645.                    (strcmp(e.pe.pkt.type,"ack") == 0))) 
  646.               return ;
  647.            }
  648.         }
  649.         if (!showRouting_){ // filter out routing packet
  650.            if (strcmp(e.pe.pkt.wtype,"RTR") == 0 ) {
  651.               if (!((strcmp(e.pe.pkt.type,"cbr") == 0)||
  652.                    (strcmp(e.pe.pkt.type,"tcp") == 0)   ||
  653.                    (strcmp(e.pe.pkt.type,"ack") == 0))) 
  654.               return ;
  655.            }
  656.         }
  657.         if (!showMac_){ // filter out routing packet
  658.            if (strcmp(e.pe.pkt.wtype,"MAC") == 0 ) {
  659.               if (!((strcmp(e.pe.pkt.type,"cbr") == 0)||
  660.                    (strcmp(e.pe.pkt.type,"tcp") == 0)   ||
  661.                    (strcmp(e.pe.pkt.type,"ack") == 0))) 
  662.               return ;
  663.            }
  664.         }
  665.       }
  667.       // show only packet with same chracteristics as selected packet
  668.       if (selectedSrc_ != -1) { //filter being trigger
  669.         if (e.pe.pkt.esrc != selectedSrc_ ) return ;
  670.       }
  671.       if (selectedDst_ != -1) { 
  672.         if (e.pe.pkt.edst != selectedDst_ ) return ;
  673.       }
  674.       if (selectedFid_ != -1) { 
  675.         if (atoi(e.pe.pkt.convid) != selectedFid_ ) return ;
  676.       }
  677.       if (selectedTraffic_[0] != '') { 
  678.         if (strcmp(e.pe.pkt.type,selectedTraffic_) != 0 ) return ;
  679.       }
  681.       // hide packet with same chracteristics as selected packet
  682.       if (hideSrc_ != -1) { // filter being trigger
  683.         if (e.pe.pkt.esrc == hideSrc_ ) return ;
  684.       }
  685.       if (hideDst_ != -1) { 
  686.         if (e.pe.pkt.edst == hideDst_ ) return ;
  687.       }
  688.       if (hideFid_ != -1) { 
  689.         if (atoi(e.pe.pkt.convid) == hideFid_ ) return ;
  690.       }
  691.       if (hideTraffic_[0] != '') { 
  692.         if (strcmp(e.pe.pkt.type,hideTraffic_) == 0 ) return ;
  693.       }
  695.       //change the packet color on the fly
  696.       if (selectedColor_ < 0 ) {
  697.         Paint *paint = Paint::instance();
  698.         selectedColor_ = paint->lookup("black",1);
  699.       }
  700.       if (colorSrc_ != -1) { 
  701.         if (e.pe.pkt.esrc == colorSrc_ ) 
  702.           paint_[atoi(e.pe.pkt.convid)] = selectedColor_  ;
  703.       }
  704.       if (colorDst_ != -1) { 
  705.         if (e.pe.pkt.edst == colorDst_ ) 
  706.           paint_[atoi(e.pe.pkt.convid)] = selectedColor_  ;
  707.       }
  708.       if (colorFid_ != -1) { 
  709.         if (atoi(e.pe.pkt.convid) == colorFid_ ) 
  710.           paint_[atoi(e.pe.pkt.convid)] = selectedColor_  ;
  711.       }
  712.       if (colorTraffic_[0] != '') { 
  713.         if (strcmp(e.pe.pkt.type,colorTraffic_) == 0 ) 
  714.             paint_[atoi(e.pe.pkt.convid)] = selectedColor_  ;
  715.       }
  717.       if (resetf_) 
  718.          paint_[atoi(e.pe.pkt.convid)] = oldpaint_[atoi(e.pe.pkt.convid)] ;
  720.       if (direction==BACKWARDS)
  721.         break;
  723.       if (e.pe.dst == -1) { //broadcasting
  724.         //a quick hack to give fixed transmission + delay time for
  725.         //broadcasting packet
  726.         if (e.time + BPACKET_TXT_TIME < now)
  727.           break ;
  729.         n = lookupNode(e.pe.src);
  730.         BPacket * p = new BPacket(n->x(), n->y(),e.pe.pkt,
  731.                                   e.time,e.offset,direction,
  732.   e.pe.pkt.wBcastDuration
  733.    ? e.pe.pkt.wBcastDuration
  734. : bcast_duration_,
  735.   e.pe.pkt.wBcastRadius
  736.    ? e.pe.pkt.wBcastRadius
  737. : bcast_radius_);
  738.         p->insert(&animations_);
  739.         p->paint(paint_[e.pe.pkt.attr & paintMask_]);
  740.         check_monitors(p);
  741.         break;
  742.       }
  744.       ehn = lookupEdgeHashNode(e.pe.src, e.pe.dst);
  745.       if (ehn == 0 || (ep = ehn->edge) == 0)
  746.         return;
  748.       /*
  749.        * If the current packet will arrive at its destination
  750.        * at a later time, insert the arrival into the queue
  751.        * of animations and set its paint id (id for X graphics
  752.        * context.
  753.        */
  754.       txtime = ep->txtime(e.pe.pkt.size);
  755.       if (e.time + txtime + ep->delay() >= now) {
  756.         /* XXX */
  757.         Packet *p = new Packet(ep, e.pe.pkt, e.time,
  758.                                txtime, e.offset);
  759.         p->insert(&animations_);
  760.         p->paint(paint_[e.pe.pkt.attr & paintMask_]);
  761.         check_monitors(p);
  763.        // fprintf(stderr, "packet %d sent from %d towards %dn",
  764.        //         e.pe.pkt.id, e.pe.src, e.pe.dst);
  765.       }
  766.       break;
  768.     case 'a':
  769.       n = lookupNode(e.ae.src);
  770.       if (n == 0)
  771.         return;
  772.       a = n->find_agent((char *) e.ae.agent.name);
  773.       if ((direction==FORWARDS)&&(e.ae.agent.expired==0)) {
  774.         if (a == NULL) {
  775.           // will only create an agent if there isn't one already 
  776.           // there with the same name
  777.           a = new BoxAgent(e.ae.agent.name, n->size());
  778.           a->Animation::insert(&animations_);
  779.           n->add_agent(a);
  780.           placeAgent(a, n);
  781.         }
  782.       } else {
  783.         if (a != NULL) {
  784.           n->delete_agent(a);
  785.           delete a;
  786.         }
  787.       }
  788.       break;
  790.     case 'f':
  791.       // We don't need any redraw for this, because it's always 
  792.       // displayed in monitors in a separate pane
  793.       n = lookupNode(e.fe.src);
  794.       if (n == 0)
  795.         return;
  796.       a = n->find_agent((char *)e.fe.feature.agent);
  797.       if (a == 0)
  798.         return;
  799.       f = a->find_feature((char *)e.fe.feature.name);
  800.       if (f == 0) {
  801.         switch (e.fe.feature.type) {
  802.         case 'v':
  803.           f = new VariableFeature(a, e.fe.feature.name);
  804.           break;
  805.         case 'l':
  806.           f = new ListFeature(a, e.fe.feature.name);
  807.           break;
  808.         case 's':
  809.         case 'u':
  810.         case 'd':
  811.           f = new TimerFeature(a, e.fe.feature.name);
  812.           break;
  813.         }
  814.         a->add_feature(f);
  815.       }
  817.       if (((direction==FORWARDS) && (e.fe.feature.expired == 0)) ||
  818.           ((direction==BACKWARDS) && (strlen(e.fe.feature.oldvalue) > 0))) {
  819.         char *value;
  820.         double time_set;
  821.         if (direction==FORWARDS) {
  822.           value=(char *)e.fe.feature.value;
  823.           time_set=now;
  824.         } else {
  825.           value=(char *)e.fe.feature.oldvalue;
  826.           /*XXX need an extra value here*/
  827.           time_set=0.0;
  828.         }
  829.         switch (e.fe.feature.type) {
  830.           case 'v':
  831.           case 'l':
  832.             f->set_feature(value);
  833.             break;
  834.           case 's':
  835.             f->set_feature(atof(value), TIMER_STOPPED, time_set);
  836.             break;
  837.           case 'u':
  838.             f->set_feature(atof(value), TIMER_UP, time_set);
  839.             break;
  840.           case 'd':
  841.             f->set_feature(atof(value), TIMER_DOWN, time_set);
  842.             break;
  843.         }
  844.       } else {
  845.         a->delete_feature(f);
  846.         delete f;
  847.       }
  848.       break;
  850.     case 'r':
  851.       if (direction == FORWARDS)
  852.         break;
  854.       if (e.pe.dst == -1) { //broadcasting
  855.         //a quick hack to give fixed transmission + delay time for
  856.         //broadcasting packet
  857.         if (e.time - BPACKET_TXT_TIME > now)
  858.           break ;
  860.         n = lookupNode(e.pe.src);
  861.         BPacket * p = new BPacket(n->x(), n->y(),e.pe.pkt,
  862.                                   e.time,e.offset,direction,
  863.   e.pe.pkt.wBcastDuration
  864.    ? e.pe.pkt.wBcastDuration
  865. : bcast_duration_,
  866.   e.pe.pkt.wBcastRadius
  867.    ? e.pe.pkt.wBcastRadius
  868. : bcast_radius_);
  869.         p->insert(&animations_);
  870.         p->paint(paint_[e.pe.pkt.attr & paintMask_]);
  871.         check_monitors(p);
  872.         break;
  873.       }
  875.       ehn = lookupEdgeHashNode(e.pe.src, e.pe.dst);
  876.       if (ehn == 0 || (ep = ehn->edge) == 0)
  877.         return;
  879.       /*
  880.        * If the current packet will arrive at its destination
  881.        * at a later time, insert the arrival into the queue
  882.        * of animations and set its paint id (id for X graphics
  883.        * context.
  884.        */
  885.       txtime = ep->txtime(e.pe.pkt.size);
  886.       if (e.time - (txtime + ep->delay()) <= now) {
  887.         /* XXX */
  888.         Packet *p = new Packet(ep, e.pe.pkt,
  889.                                e.time-(ep->delay() + txtime),
  890.                                txtime, e.offset);
  891.         p->insert(&animations_);
  892.         p->paint(paint_[e.pe.pkt.attr & paintMask_]);
  893.         check_monitors(p);
  894.       }
  895.       break;
  897.     case '+':
  898.       ehn = lookupEdgeHashNode(e.pe.src, e.pe.dst);
  899.       if (direction == FORWARDS) {
  900.         if (ehn != 0 && ehn->queue != 0) {
  901.           QueueItem *qi = new QueueItem(e.pe.pkt, e.time,
  902.                                         e.offset);
  903.           qi->paint(paint_[e.pe.pkt.attr & paintMask_]);
  904.           ehn->queue->enque(qi,QUEUE_TAIL);
  905.           qi->insert(&animations_);
  906.           check_monitors(qi);
  907.         }
  908.       } else {
  909.         if (ehn != 0 && ehn->queue != 0) {
  910.           q = ehn->queue->remove(e.pe.pkt);
  911.           delete q;
  912.         }
  913.       }
  914.       break;
  916.     case '-':
  917.       ehn = lookupEdgeHashNode(e.pe.src, e.pe.dst);
  918.       if (direction == FORWARDS) {
  919.         if (ehn != 0 && ehn->queue != 0) {
  920.           q = ehn->queue->remove(e.pe.pkt);
  921.           delete q;
  922.         }
  923.       } else {
  924.         if (ehn != 0 && ehn->queue != 0) {
  925.           QueueItem *qi = new QueueItem(e.pe.pkt, e.time,
  926.                                         e.offset);
  927.           qi->paint(paint_[e.pe.pkt.attr & paintMask_]);
  928.           ehn->queue->enque(qi,QUEUE_HEAD);
  929.           qi->insert(&animations_);
  930.           check_monitors(qi);
  931.         }
  932.       }
  933.       break;
  935.     case 'E': {
  936.       // Nothing for now
  937.       Group *grp = lookupGroup(e.pe.dst);
  938.       if (grp == NULL) {
  939.         fprintf(stderr, "Packet destination group %d not foundn",
  940.           e.pe.dst);
  941.         return;
  942.       }
  943.       int *mbr = new int[grp->size()];
  944.       grp->get_members(mbr);
  945.       for (int i = 0; i < grp->size(); i++) {
  946.         QueueItem *qi = new QueueItem(e.pe.pkt, e.time,
  947.               e.offset);
  948.         qi->paint(paint_[e.pe.pkt.attr & paintMask_]);
  949.         n = lookupNode(mbr[i]);
  950.         if (n == 0) {
  951.           fprintf(stderr, 
  952.             "Group member %d not foundn",
  953.             mbr[i]);
  954.           return;
  955.         }
  956.         if (direction == FORWARDS) {
  957.           n->queue()->enque(qi, QUEUE_TAIL);
  958.           qi->insert(&animations_);
  959.           check_monitors(qi);
  960.         } else {
  961.           qi = n->queue()->remove(e.pe.pkt);
  962.           delete qi;
  963.         }
  964.       }
  965.       delete mbr;    
  966.       break;
  967.     }
  969.     case 'D': {
  970.       n = lookupNode(e.pe.dst);
  971.       if (n == NULL) {
  972.         fprintf(stderr, "Bad node id %d for session deque eventn",
  973.           e.pe.dst);
  974.         return;
  975.       }
  976.       if (direction == FORWARDS) {
  977.         q = n->queue()->remove(e.pe.pkt);
  978.         delete q;
  979.       } else {
  980.         QueueItem *qi = new QueueItem(e.pe.pkt, e.time, e.offset);
  981.         qi->paint(paint_[e.pe.pkt.attr & paintMask_]);
  982.         n->queue()->enque(qi, QUEUE_HEAD);
  983.         qi->insert(&animations_);
  984.         check_monitors(qi);
  985.       }
  986.       break;
  987.     }
  989.     case 'P':  // session drop
  990.       // Get packet to drop.
  991.       if (direction == FORWARDS) {
  992.         // fprintf(stderr, "drop on %d -> %dn", e.pe.src, e.pe.dst);
  993.         n = lookupNode(e.pe.dst);
  994.         if (n == 0)
  995.           return;
  996.         q = 0;
  997.         if (n->queue() != 0) {
  998.           // Remove packet from session queue 
  999.           q = n->queue()->remove(e.pe.pkt);
  1000.           if (q == 0) {
  1001.             // No such packet in queue??? 
  1002.             fprintf(stderr, "No packet drop %id in queuen",
  1003.                             e.pe.pkt.id);
  1004.             return;
  1005.           }
  1006.           q->position(x,y);
  1007.           pno = q->paint();
  1008.           delete q;
  1009.         }
  1010.         
  1011.       // Compute the point at which the dropped packet disappears.
  1012.       // Let's just make this sufficiently far below the lowest
  1013.       // thing on the screen.
  1014.     
  1015.       // Watch out for topologies that have all their nodes lined
  1016.       // up horizontally. In this case, nymin_ == nymax_ == 0.
  1017.       // Set the bottom to -0.028. This was chosen empirically.
  1018.       // The nam display was set to the maximum size and the lowest
  1019.       // position on the display was around -0.028.
  1020.      
  1021.       float bot;
  1022.       if (nymin_ - nymax_ < 0.01)
  1023.         bot = nymin_ - 10 * n->size() ;
  1024.       else
  1025.         bot = nymin_ - (nymax_ - nymin_);
  1026.     
  1027.       Drop *d = new Drop(x, y, bot, n->size()*0.5, /* This is a hack */
  1028.                          e.time, e.offset, e.pe.pkt);
  1029.       d->paint(pno);
  1030.       d->insert(&animations_);
  1031.       check_monitors(d);
  1032.       break;
  1033.     } else {
  1034.       /*direction is BACKWARDS - need to create the packet*/
  1035.       //fprintf(stderr, "Packet drop backwardsn");
  1036.     }
  1038.     case 'G': {
  1039.       /* Group event */
  1040.       Group *grp = lookupGroup(e.ge.src);
  1041.       if (grp == NULL) {
  1042.         grp = new Group(e.ge.grp.name, e.ge.src);
  1043.         add_group(grp);
  1044.       }
  1045.       
  1046.       if (e.ge.grp.flag == GROUP_EVENT_JOIN) {
  1047.         grp->join(e.ge.grp.mbr);
  1048.         // XXX
  1049.         // Hard-coded queue angle for session queues. :(
  1050.         // Create session queue here because they are not like
  1051.         // traditional queues which are created when nam
  1052.         // started. Group member may dynamically join/leave,
  1053.         // so may session queues. We create them here because 
  1054.         // there's a 1-1 relationship between join and creating
  1055.         // session queues.
  1056.         n = lookupNode(e.ge.grp.mbr);
  1057.         if (n == NULL) {
  1058.           fprintf(stderr, "Bad node %d for group eventn",
  1059.             e.ge.grp.mbr);
  1060.           return;
  1061.         }
  1062.         // Need more consideration on the placement of these queues
  1063.         Queue *q = new Queue(0.5);
  1064.         q->next_ = queues_;
  1065.         queues_ = q;
  1066.         n->add_sess_queue(e.ge.src, q);
  1067.       } else if (e.ge.grp.flag == GROUP_EVENT_LEAVE)
  1068.         // No deletion of session queues.
  1069.         grp->leave(e.ge.grp.mbr);
  1070.       break;
  1071.     }
  1072.     case 'l': 
  1073.       /*link event*/
  1074.       // if src or dst = -1 this is a layout link (-t *)
  1075.       // so skip over it
  1076.       if (e.le.src == -1 || e.le.dst == -1)
  1077.         return;
  1079.       ehn = lookupEdgeHashNode(e.le.src, e.le.dst);
  1080.       if (ehn == 0) {
  1081.         // if edge doesn't exist try to create it dynamically
  1082.         ep = addEdge(e.le.src, e.le.dst, e);
  1083.         if (!ep) {
  1084.           fprintf(stderr, "Unable to create edge(%d,%d) dynamically.n",
  1085.                            e.le.src, e.le.dst);
  1086.           return;
  1087.         }
  1088.         ehn = lookupEdgeHashNode(e.le.src, e.le.dst);
  1089.         do_relayout= true;
  1090.       }
  1092.       ehnrev = lookupEdgeHashNode(e.le.dst, e.le.src);
  1093.       if (ehnrev == 0) {
  1094.         // if edge doesn't exist try to create it dynamically
  1095.         ep = addEdge(e.le.dst, e.le.src, e);
  1096.         if (!ep) {
  1097.           fprintf(stderr, "Unable to create reverse edge(%d,%d) dynamically.n",
  1098.                            e.le.dst, e.le.src);
  1099.           return;
  1100.         }
  1101.         ehnrev = lookupEdgeHashNode(e.le.dst, e.le.src);
  1102.         do_relayout = true;
  1103.       }
  1105.       if (do_relayout) {
  1106.         //relayout();
  1107.         relayoutNode(lookupNode(e.le.src));
  1108.         relayoutNode(lookupNode(e.le.dst));
  1109.         do_relayout = false;
  1110.       }
  1111.       /*note: many link events are bidirectional events so be careful to
  1112.         apply them to both a link and the reverse of it*/
  1114.       if (direction==FORWARDS)  {
  1115.         // Always save the color before the last DOWN event
  1116.         if (strncmp(e.le.link.state, "DOWN", 4)==0) {
  1117.           ehn->edge->set_down("red");
  1118.           ehnrev->edge->set_down("red");
  1119.         } else if (strncmp(e.le.link.state, "UP", 2)==0) {
  1120.           /* XXX Assume an UP event always follows a DOWN event */
  1121.           ehn->edge->set_up();
  1122.           ehnrev->edge->set_up();
  1123.         } else if (strncmp(e.le.link.state, "COLOR", 5) == 0) {
  1124.           ehn->edge->color((char *)e.le.link.color);
  1125.            ehnrev->edge->color((char *)e.le.link.color);
  1126.         } else if (strncmp(e.le.link.state, "DLABEL", 6) == 0) {
  1127.           ehn->edge->dlabel((char *)e.le.link.dlabel);
  1128.           ehnrev->edge->dlabel((char *)e.le.link.dlabel);
  1129.         } else if (strncmp(e.le.link.state, "DCOLOR", 6) == 0) {
  1130.           ehn->edge->dcolor((char *)e.le.link.dcolor);
  1131.           ehnrev->edge->dcolor((char *)e.le.link.dcolor);
  1132.         } else if (strncmp(e.le.link.state, "DIRECTION", 9) == 0) {
  1133.           ehn->edge->direction((char *)e.le.link.direction);
  1134.           ehnrev->edge->direction((char *)e.le.link.direction);
  1135.         } else if (strncmp(e.le.link.state, "DIRECTION", 9) == 0) {
  1136.           ehn->edge->direction((char *)e.le.link.direction);
  1137.           ehnrev->edge->direction((char *)e.le.link.direction);
  1138.         } 
  1140.       } else {
  1141.         if (strncmp(e.le.link.state, "UP", 2)==0) {
  1142.           ehn->edge->set_down("red");
  1143.           ehnrev->edge->set_down("red");
  1144.         } else if (strncmp(e.le.link.state, "DOWN", 4)==0) {
  1145.           ehn->edge->set_up();
  1146.         } else if (strncmp(e.le.link.state, "COLOR", 5) == 0) {
  1147.           ehn->edge->color((char *)e.le.link.oldColor);
  1148.           ehnrev->edge->color((char *)e.le.link.oldColor);
  1149.         } else if (strncmp(e.le.link.state, "DLABEL", 6) == 0) {
  1150.           ehn->edge->dlabel((char *)e.le.link.odlabel);
  1151.           ehnrev->edge->dlabel((char *)e.le.link.odlabel);
  1152.         } else if (strncmp(e.le.link.state, "DCOLOR", 6) == 0) {
  1153.           ehn->edge->dcolor((char *)e.le.link.odcolor);
  1154.           ehnrev->edge->dcolor((char *)e.le.link.odcolor);
  1155.         } else if (strncmp(e.le.link.state, "DIRECTION", 9) == 0) {
  1156.           ehn->edge->direction((char *)e.le.link.odirection);
  1157.           ehnrev->edge->direction((char *)e.le.link.odirection);
  1158.         } else if (strncmp(e.le.link.state, "DIRECTION", 9) == 0) {
  1159.           ehn->edge->direction((char *)e.le.link.odirection);
  1160.           ehnrev->edge->direction((char *)e.le.link.odirection);
  1161.         }
  1162.     }
  1163.       break;
  1164.     case 'n':
  1165.       /* node event */
  1166.       // Return if node has -t * 
  1167.       // Ths node is only used for initial layout
  1168.       if (e.ne.src == -1)
  1169.         return;
  1171.       n = lookupNode(e.ne.src);
  1172.       if (n == 0) {
  1173.         // if node doesn't exist try to create it dynamically
  1174.         n = addNode(e);
  1175.         if (!n)
  1176.           return;
  1177.       }
  1178.       if (direction==FORWARDS) {
  1179.         if (strncmp(e.ne.node.state, "DOWN", 4)==0) {
  1180.                 n->set_down("gray");
  1181.         } else if (strncmp(e.ne.node.state, "UP", 2)==0) {
  1182.                 n->set_up();
  1183.         } else if (strncmp(e.ne.node.state, "COLOR", 5) == 0) {
  1184.                 // normal color can be defined by user
  1185.                 n->color((char *)e.ne.node.color);
  1186.                 n->lcolor((char *)e.ne.node.lcolor);
  1187.         } else if (strncmp(e.ne.node.state, "DLABEL", 6) == 0) {
  1188.                 n->dlabel((char *)e.ne.node.dlabel); 
  1189.         } else if (strncmp(e.ne.node.state, "DCOLOR", 6) == 0) {
  1190.                 n->dcolor((char *)e.ne.node.dcolor);
  1191.         } else if (strncmp(e.ne.node.state, "DIRECTION", 9) == 0) {
  1192.                 n->direction((char *)e.ne.node.direction);
  1193.         }
  1194.       } else {
  1195.         if (strncmp(e.ne.node.state, "UP", 4)==0) {
  1196.                 n->set_down("gray");
  1197.         } else if (strncmp(e.ne.node.state, "DOWN", 2)==0) {
  1198.                 n->set_up();
  1199.         } else if (strncmp(e.ne.node.state, "COLOR", 5) == 0) {
  1200.                 n->color((char *)e.ne.node.oldColor);
  1201.                 n->lcolor((char *)e.ne.node.olcolor);
  1202.         }  else if (strncmp(e.ne.node.state, "DLABEL", 6) == 0) {
  1203.                 n->dlabel((char *)e.ne.node.odlabel);
  1204.         } else if (strncmp(e.ne.node.state, "DCOLOR", 6) == 0) {
  1205.                 n->dcolor((char *)e.ne.node.odcolor);
  1206.         } else if (strncmp(e.ne.node.state, "DIRECTION", 9) == 0) {
  1207.                 n->direction((char *)e.ne.node.odirection);
  1208.         }
  1209.       }  
  1210.       break;
  1212.     case 'm':
  1213.       /* node mark event */
  1214.       NodeMark *cm;
  1215.       n = lookupNode(e.me.src);
  1216.       if (n == 0)
  1217.         return;
  1218.       cm = n->find_mark((char *) e.me.mark.name);
  1219.       if (direction == FORWARDS) {
  1220.         if (e.me.mark.expired == 0) {
  1221.           /* once created, a node mark cannot be changed*/
  1222.           if (cm == NULL) 
  1223.             n->add_mark((char *)e.me.mark.name, 
  1224.                         (char *)e.me.mark.color,
  1225.                         (char *)e.me.mark.shape);
  1226.         } else 
  1227.           /* expired */
  1228.           n->delete_mark((char *)e.me.mark.name);
  1229.       } else {
  1230.         /* 
  1231.          * backward: 
  1232.          * (1) create it if expired == 1
  1233.          * (2) delete it if expired == 0
  1234.          */
  1235.         if (e.me.mark.expired == 0) 
  1236.           n->delete_mark((char *)e.me.mark.name);
  1237.         else {
  1238.           /* re-create the circle */
  1239.           if (cm == NULL)
  1240.             n->add_mark((char *)e.me.mark.name, 
  1241.             (char *)e.me.mark.color,
  1242.             (char *)e.me.mark.shape);
  1243.         }
  1244.       }
  1245.       break;
  1247.     case 'R':
  1248.       // route event
  1249.       if (((e.re.route.expired==0)&&(direction==FORWARDS))||
  1250.           ((e.re.route.expired==1)&&(direction==BACKWARDS))) {
  1251.          // this is a new route
  1252.         n = lookupNode(e.re.src);
  1253.         if (n == 0)
  1254.           return;
  1256.         ehn = lookupEdgeHashNode(e.re.src, e.re.dst);
  1257.         if (ehn == 0)
  1258.           return;
  1259.         int oif=1;
  1260.         if (strncmp(e.re.route.mode, "iif", 3)==0)
  1261.           oif=0;
  1262.         r = new Route(n, ehn->edge, e.re.route.group, e.re.route.pktsrc, 
  1263.                       e.re.route.neg, oif, e.re.route.timeout, now);
  1264.         n->add_route(r);
  1265.         n->place_route(r);
  1266.         r->insert(&animations_);
  1267.         r->paint(paint_[e.re.route.group & paintMask_]);
  1268.         check_monitors(r);
  1269.       } else {
  1270.         // an old route expired
  1271.         n = lookupNode(e.re.src);
  1272.         if (n == 0)
  1273.           return;
  1274.         
  1275.         // src and dst are node ids 
  1276.         ehn = lookupEdgeHashNode(e.re.src, e.re.dst);
  1277.         if (ehn == 0)
  1278.           return;
  1279.         int oif = 1;
  1280.         if (strncmp(e.re.route.mode, "iif", 3) == 0) {
  1281.           oif=0;
  1282.         }
  1283.         r = n->find_route(ehn->edge, e.re.route.group,
  1284.                           e.re.route.pktsrc, oif);
  1285.         if (r == 0) {
  1286.           fprintf(stderr, "nam: attempt to delete non-existent routen");
  1287.           abort();
  1288.         }
  1289.         n->delete_route(r);
  1290.         delete r;
  1291.       }
  1292.       break;
  1294.     case 'd':
  1295.       add_drop(e, now, direction);
  1296.   }
  1297. }
  1299. //---------------------------------------------------------------------
  1300. //  void
  1301. // NetModel::add_drop(const TraceEvent &e, double now, int direction)
  1302. //   - This method adds a packet drop animation to the animations_ list
  1303. //   - Packet drops can occur from queues and edges.  If the queue is 
  1304. //     not being displayed the packet is dropped from the node
  1305. //     position.
  1306. //   - If the animation direction is BACKWARDS a packet should be
  1307. //     created but it appears that this code does not do that.
  1308. //---------------------------------------------------------------------
  1309. void
  1310. NetModel::add_drop(const TraceEvent &e, double now, int direction) {
  1311.   EdgeHashNode *ehn;
  1312.   QueueItem *q;
  1313.   Packet *p;
  1314.   Lan *lan;
  1315.   float x, y;
  1316.   int pno;  // paint number (color with which to draw)
  1317.   
  1318.   // Get packet to drop. 
  1319.   if (direction == FORWARDS) {
  1320.     ehn = lookupEdgeHashNode(e.pe.src, e.pe.dst);
  1321.     if (ehn == 0) {
  1322.      return;
  1323.     }
  1325.     q = 0;
  1326.     if (ehn->queue != 0) {
  1327.       // if there's a queue, try removing it from the queue first
  1328.       // queue drops are more common than link drops...
  1329.       q = ehn->queue->remove(e.pe.pkt);
  1330.     }
  1332.     if (q == 0) {
  1333.       // perhaps it's a link packet drop
  1334.       p = lookupPacket(e.pe.src, e.pe.dst, e.pe.pkt.id);
  1335.       if (p != NULL) {
  1336.         // it was a link packet drop
  1337.         p->position(x, y, now);
  1338.         ehn->edge->DeletePacket(p);
  1339.         pno = p->paint();
  1340.         delete p;
  1341.       } else if ((lan = lookupLan(e.pe.src)) != NULL) {
  1342.         /* 
  1343.          * If it's a Lan (selective) packet drop, which means
  1344.          * the packet is only dropped on some of the lan links,
  1345.          * register the packet on the lan and drop it when the
  1346.          * packet is actually transmitted to that lan link.
  1347.          *
  1348.          * When the packet is actually dropped, this function will be 
  1349.          * called again, but at that time the packet will be actually
  1350.          * on the link and this code will not be executed.
  1351.          */
  1352.         lan->register_drop(e);
  1353.         return;
  1354.       } else {
  1355.         // probably it was a queue drop, but we're not displaying
  1356.         // that queue
  1357.        
  1358.         // It's possible that this packet is dropped directly from 
  1359.         // the queue, even before the enqT_ module. In this case, 
  1360.         // we should still produce a packet drop; we use the position
  1361.         // of the node to generate the drop.
  1362.         Node *s = lookupNode(e.pe.src);
  1363.         if (s == NULL) {
  1364.           fprintf(stderr, "NetModel::add_drop(): cannot find src node for packet drop.n");
  1365.           abort();
  1366.         }
  1367.         x = s->x();
  1368.         y = s->y();
  1369.         pno = paint_[e.pe.pkt.attr & paintMask_];
  1370.       }
  1371.     } else {
  1372.       // packet dropped from queue
  1373.       // get x,y position of queue item
  1374.       q->position(x, y);
  1375.       pno = q->paint();
  1376.       delete q;
  1377.     }
  1379.     /*
  1380.      * Compute the point at which the dropped packet disappears.
  1381.      * Let's just make this sufficiently far below the lowest
  1382.      * thing on the screen.
  1383.      *
  1384.      * Watch out for topologies that have all their nodes lined
  1385.      * up horizontally. In this case, nymin_ == nymax_ == 0.
  1386.      * Set the bottom to -0.028. This was chosen empirically.
  1387.      * The nam display was set to the maximum size and the lowest
  1388.      * position on the display was around -0.028.
  1389.      */
  1390.     float bottom;
  1391.     if (nymin_ - nymax_ < 0.01) {
  1392.       bottom = nymin_ - 20.0 * ehn->edge->PacketHeight() ;
  1393.     } else {
  1394.       bottom = nymin_ - (nymax_ - nymin_);
  1395.     }
  1396.     
  1397.     // The drop animation is taken care of by the drop class
  1398.     Drop * d = new Drop(x, y, bottom, 4 * ehn->edge->PacketHeight(),
  1399.                         e.time, e.offset, e.pe.pkt);
  1400.     d->paint(pno);
  1401.     d->insert(&animations_);
  1402.     check_monitors(d);
  1403.     return;
  1404.   } else {
  1405.     // direction is BACKWARDS - need to create the packet
  1406.     Lan *lan = lookupLan(e.pe.src);
  1407.     if (lan != NULL) {
  1408.        // We need to remove drop status in lans
  1409.       lan->remove_drop(e);
  1410.       //fprintf(stderr, "lan dropped packet %d is removed on lan link %d->%dn",
  1411.       //                e.pe.pkt.id, e.pe.src, e.pe.dst);
  1412.       return;
  1413.     }
  1414.   }
  1415. }
  1418. //----------------------------------------------------------------------------
  1419. // Node *
  1420. // NetModel::addNode(const TraceEvent &e)
  1421. //   - adds a node to the netmodel getting configuration info from the fields
  1422. //     in the TraceEvent
  1423. //----------------------------------------------------------------------------
  1424. Node *
  1425. NetModel::addNode(const TraceEvent &e)  {
  1426.   Node * n = NULL;
  1427.   char src[32];
  1429.   if (e.tt == 'n') {
  1430.     sprintf(src, "%d", e.ne.src);
  1431.     n = lookupNode(e.ne.src);
  1432.     // And remove them to be replaced by this node
  1433.     if (n != NULL) {
  1434.       fprintf(stderr, "Skipping duplicate node %s definition. n", src);
  1435.       //removeNode(n);
  1436.     }
  1438.     // Determine Node Type
  1439.     if (!strncmp(e.ne.mark.shape, "circle",6)) {
  1440.       n = new CircleNode(src, e.ne.size);
  1441.     } else if (!strncmp(e.ne.mark.shape, "box", 3) || 
  1442.                !strncmp(e.ne.mark.shape, "square", 6)) {
  1443.       n = new BoxNode(src, e.ne.size);
  1444.     } else if (!strncmp(e.ne.mark.shape, "hexagon",7)) { 
  1445.       n = new HexagonNode(src, e.ne.size);
  1446.     } else {
  1447.       return NULL;
  1448.     }
  1450.     // Check for wireless node
  1451.     if (e.ne.wireless) {
  1452.       n->wireless_ = true;
  1453.       //fprintf(stderr, "We have wireless nodes :-) !!!n");
  1454.     }
  1456.     // Node Address
  1457.     //  May need to check for no address passed in
  1458.     n->setaddr(e.ne.node.addr);
  1459.     addAddress(n->num(), e.ne.node.addr);
  1461.     // Node Color
  1462.     n->init_color(e.ne.node.color);
  1463.     n->lcolor(e.ne.node.lcolor);
  1465.     // dlabel initilization
  1466.     n->dlabel(e.ne.node.dlabel);
  1468.     // Set X,Y cordinates
  1469.     n->place(e.ne.x, e.ne.y);
  1470.     
  1471.     // Add Node to drawables list
  1472.     n->next_ = nodes_;
  1473.     nodes_ = n;
  1474.     n->Animation::insert(&drawables_);
  1476.     // Set Packet size to be running average of the last 5 nodes (25% of node size)
  1477.     packet_size_ = (4.0 * packet_size_ + e.ne.size*0.25)/5.0;
  1478.   }
  1479.   return (n);
  1480. }
  1482. //----------------------------------------------------------------------------
  1483. // Edge * 
  1484. // NetModel::addEdge(int argc, const char *const *argv)
  1485. //
  1486. //  <net> link <src> <dst> <bandwidth> <delay> <angle>
  1487. //  Create a link/edge between the specified source
  1488. //  and destination. Add it to this NetModel's list
  1489. //  of drawables and to the source's list of links.
  1490. //----------------------------------------------------------------------------
  1491. Edge * 
  1492. NetModel::addEdge(int argc, const char *const *argv) {
  1493.   Node * src, * dst;
  1494.   Edge * edge = NULL;
  1495.   double bandwidth, delay, length, angle;
  1497.   if (strcmp(argv[1], "link") == 0) {
  1498.     src = lookupNode(atoi(argv[2]));
  1499.     dst = lookupNode(atoi(argv[3]));
  1500.     
  1501.     if (src && dst) {
  1502.       bandwidth = atof(argv[4]);
  1503.       delay = atof(argv[5]);
  1504.       length = atof(argv[6]);
  1505.       angle = atof(argv[7]);
  1506.                         
  1507.       //enlarge link if the topology is a mixture of
  1508.       //wired and wireless network
  1509.       if (wireless_) {
  1510.         length = delay * WIRELESS_SCALE ;
  1511.       }
  1513.       edge = new Edge(src, dst, packet_size_, bandwidth, delay, length, angle, wireless_);
  1514.       edge->init_color("black");
  1515.       enterEdge(edge);
  1516.       edge->Animation::insert(&drawables_);
  1517.       src->add_link(edge);
  1518.     }
  1519.   }
  1520.   return edge;
  1521. }
  1523. //----------------------------------------------------------------------------
  1524. //
  1525. //----------------------------------------------------------------------------
  1526. Edge * 
  1527. NetModel::addEdge(int src_id, int dst_id, const TraceEvent &e) {
  1528.   Node *src, *dst;
  1529.   Edge * edge = NULL;
  1530.   double bandwidth, delay, length, angle;
  1532.   if (e.tt == 'l') {
  1533.     src = lookupNode(src_id);
  1534.     dst = lookupNode(dst_id);
  1535.     
  1536.     if (src && dst) {
  1537.       bandwidth = e.le.link.rate;
  1538.       delay = e.le.link.delay;
  1539.       length = e.le.link.length;
  1540.       angle = e.le.link.angle;
  1541.                         
  1542.       //enlarge link if the topology is a mixture of
  1543.       //wired and wireless network
  1544.       if (wireless_) {
  1545.         length = delay * WIRELESS_SCALE ;
  1546.       }
  1548.       edge = new Edge(src, dst, packet_size_, bandwidth, delay, length, angle, wireless_);
  1549.       edge->init_color("black");
  1550.       enterEdge(edge);
  1551.       edge->Animation::insert(&drawables_);
  1552.       src->add_link(edge);
  1553.     }
  1554.   }
  1555.   return edge;
  1556. }
  1558. void NetModel::addView(NetView* p)
  1559. {
  1560. p->next_ = views_;
  1561. views_ = p;
  1562. }
  1564. //----------------------------------------------------------------------
  1565. // Node * 
  1566. // NetModel::lookupNode(int nn) const
  1567. //----------------------------------------------------------------------
  1568. Node *
  1569. NetModel::lookupNode(int nn) const {
  1570.   for (Node* n = nodes_; n != 0; n = n->next_)
  1571.     if (n->num() == nn)
  1572.       return (n);
  1573.   return NULL;
  1574. }
  1577. //----------------------------------------------------------------------
  1578. // Edge *
  1579. // NetModel::lookupEdge(int source, int destination) const
  1580. //----------------------------------------------------------------------
  1581. Edge *
  1582. NetModel::lookupEdge(int source, int destination) const {
  1583. EdgeHashNode * edge_hash_node;
  1584. edge_hash_node = lookupEdgeHashNode(source, destination);
  1585. return edge_hash_node->edge;
  1586. }
  1589. void NetModel::removeNode(Node *n) 
  1590. {
  1591. Node *p, *q;
  1592. // Remove node n from nodes_ list, then delete it
  1593. for (p = nodes_; p != 0; q = p, p = p->next_)
  1594. if (p == n)
  1595. break;
  1596. if (p == nodes_)
  1597. nodes_ = p->next_;
  1598. else
  1599. q->next_ = p->next_;
  1600. delete p;
  1601. }
  1603. Agent *NetModel::lookupAgent(int id) const
  1604. {
  1605. for (Node* n = nodes_; n != 0; n = n->next_) 
  1606. for(Agent* a= n->agents(); a != 0; a = a->next_) 
  1607. if (a->number() == id) 
  1608. return (a);
  1609. return (0); 
  1610. }
  1612. Lan *NetModel::lookupLan(int nn) const
  1613. {
  1614. for (Lan* l = lans_; l != 0; l = l->next_)
  1615. if (l->num() == nn)
  1616. return (l);
  1617. /* XXX */
  1618. //fprintf(stderr, "nam: no such lan %dn", nn);
  1619. //exit(1);
  1620. return (0);// make visual c++ happy
  1621. }
  1623. Packet *NetModel::newPacket(PacketAttr &pkt, Edge *e, double time)
  1624. {
  1625.   /*this is called when we get a triggered event such as a packet
  1626.     getting duplicated within a LAN*/
  1627.   Packet *p = new Packet(e, pkt, time, e->txtime(pkt.size), 0);
  1628.   p->insert(&animations_);
  1629.   p->paint(paint_[pkt.attr & paintMask_]);
  1630.   check_monitors(p);
  1631.   return p;
  1632. }
  1634. Packet *NetModel::lookupPacket(int src, int dst, int id) const
  1635. {
  1636.   EdgeHashNode *h = lookupEdgeHashNode(src, dst);
  1637.   if (h == 0)
  1638.     return NULL;
  1639.   int ctr=0;
  1640.   for (Packet *p=h->edge->packets(); p!=NULL; p=p->next())
  1641.     {
  1642. #define PARANOID
  1643. #ifdef PARANOID
  1644.       ctr++;
  1645.       if (ctr>h->edge->no_of_packets()) abort();
  1646. #endif
  1647.       if (p->id() == id)
  1648. return p;
  1649.     }
  1650.   /*have to fail silent or we can't cope with link drops when doing settime*/
  1651.   return 0;
  1652. }
  1654. /* Do not delete groups, because they are not explicitly deleted */
  1655. int NetModel::add_group(Group *grp)
  1656. {
  1657. int newEntry = 1;
  1658. Tcl_HashEntry *he = Tcl_CreateHashEntry(grpHash_,
  1659.                                         (const char *)grp->addr(), 
  1660.                                         &newEntry);
  1661. if (he == NULL)
  1662. return -1;
  1663. if (newEntry) {
  1664. Tcl_SetHashValue(he, (ClientData)grp);
  1665. nGroup_++;
  1666. }
  1667. return 0;
  1668. }
  1670. Group* NetModel::lookupGroup(unsigned int addr)
  1671. {
  1672. Tcl_HashEntry *he = Tcl_FindHashEntry(grpHash_, (const char *)addr);
  1673. if (he == NULL)
  1674. return NULL;
  1675. return (Group *)Tcl_GetHashValue(he);
  1676. }
  1678. // Remove a view from the views link, but not delete it
  1679. void NetModel::remove_view(View *v)
  1680. {
  1681. View *p, *q;
  1682. p = q = views_;
  1683. if (p == v) {
  1684. views_ = p->next_;
  1685. return;
  1686. }
  1687. while (p != NULL) {
  1688. q = p;
  1689. p = p->next_;
  1690. if (p == v) {
  1691. q->next_ = p->next_;
  1692. return;
  1693. }
  1694. }
  1695. }
  1697. //----------------------------------------------------------------------
  1698. // int
  1699. // NetModel::command(int argc, const char *const *argv)
  1700. //   - Parses tcl commands (hook to enter c++ code from tcl)
  1701. //----------------------------------------------------------------------
  1702. int NetModel::command(int argc, const char *const *argv) {
  1703. Tcl& tcl = Tcl::instance();
  1704. int i;
  1705. Node * node;
  1706. double time;
  1708. if (argc == 2) {
  1709. if (strcmp(argv[1], "layout") == 0) {
  1710. /*
  1711.  * <net> layout
  1712.  * Compute reasonable defaults for missing node or edge
  1713.  * sizes based on the maximum link delay. Lay out the
  1714.  * nodes and edges as specified in the layout file.
  1715.  */
  1716. scale_estimate();
  1717. placeEverything();
  1718. return (TCL_OK);
  1719. }
  1720. if (strcmp(argv[1], "showtrees") == 0) {
  1721. /*
  1722.  * <net> showtrees
  1723.  */
  1724. color_subtrees();
  1725. for (View* p = views_; p != 0; p = p->next_) {
  1726. p->draw();
  1727. }
  1728. return (TCL_OK);
  1729. }
  1730. if (strcmp(argv[1],"resetFilter")==0) {
  1731.         resetf_ = 1 ;
  1732.                 selectedSrc_ = -1 ;
  1733.         selectedDst_ = -1 ;
  1734.         selectedFid_ = -1 ;
  1735.                 colorSrc_ = -1 ;
  1736.         colorDst_ = -1 ;
  1737.         colorFid_ = -1 ;
  1738.                 hideSrc_ = -1 ;
  1739.         hideDst_ = -1 ;
  1740.         hideFid_ = -1 ;
  1741.                 for (i = 0; i < PTYPELEN; ++i) {
  1742.                    selectedTraffic_[i] = '' ;
  1743.                    colorTraffic_[i] = '' ;
  1744.                    hideTraffic_[i] = '' ;
  1745.                         }
  1747. return (TCL_OK);
  1748. }
  1750. } else if (argc == 3) {
  1751. if (strcmp(argv[1], "incr-nodesize") == 0) {
  1752. /*
  1753.  * <net> incr-nodesize <factor>
  1754.  */
  1755. node_sizefac_ *= atof(argv[2]);
  1756. for (Node *n = nodes_; n != 0; n = n->next_)
  1757. for (Edge *e=n->links(); e != 0; e = e->next_)
  1758. e->unmark();
  1759. scale_estimate();
  1760. placeEverything();
  1761. for (View *p = views_; p != 0; p = p->next_)
  1762. if ((p->width() > 0) && (p->height() > 0)) {
  1763. p->redrawModel();
  1764. p->draw();
  1765. }
  1766. return (TCL_OK);
  1767. }
  1768. if (strcmp(argv[1], "decr-nodesize") == 0) {
  1769. node_sizefac_ /= atof(argv[2]);
  1770. for (Node *n = nodes_; n != 0; n = n->next_)
  1771. for (Edge *e=n->links(); e != 0; e = e->next_)
  1772. e->unmark();
  1773. scale_estimate();
  1774. placeEverything();
  1775. for (View *p = views_; p != 0; p = p->next_)
  1776. if ((p->width() > 0) && (p->height() > 0)) {
  1777. p->redrawModel();
  1778. p->draw();
  1779. }
  1780. return(TCL_OK);
  1781. }
  1783. if (strcmp(argv[1], "updateNodePositions") == 0) {
  1784. time = strtod(argv[2], NULL);
  1785. for (node = nodes_; node; node = node->next_) {
  1786. node->updatePositionAt(time);
  1787. moveNode(node);  // This updates the links and agents connected to the node
  1788. }
  1789. return TCL_OK;
  1790. }
  1792. if (strcmp(argv[1], "view") == 0) {
  1793. /*
  1794.  * <net> view <viewName>
  1795.  * Create the window for the network layout/topology.
  1796.  * Used for nam editor
  1797.  */
  1799. EditView *v = new EditView(argv[2], this, 300, 700);
  1800. v->next_ = views_;
  1801. views_ = v;
  1802. return (TCL_OK);
  1803. }
  1805. if (strcmp(argv[1], "psview") == 0) {
  1806. /*
  1807.  * <net> PSView <fileName>
  1808.  * Print the topology to a file
  1809.  */
  1810. PSView *v = new PSView(argv[2], this);
  1811. v->render();
  1812. delete(v);
  1813. return (TCL_OK);
  1814. }
  1815. if (strcmp(argv[1], "testview") == 0) {
  1816. /*
  1817.  * Added for nam validation test 
  1818.  */
  1819. TestView *v = new TestView(argv[2], this);
  1820. v->render();
  1821. delete(v);
  1822. return (TCL_OK);
  1823. }
  1824. if (strcmp(argv[1], "editview") == 0) {
  1825. /*
  1826.  * <net> editview <viewname>
  1827.  */
  1828. EditView *v = new EditView(argv[2], this);
  1829. v->next_ = views_;
  1830. views_ = v;
  1831. return (TCL_OK);
  1832. }
  1833. if (strcmp(argv[1],"savelayout")==0) {
  1834.         save_layout(argv[2]);
  1835. return (TCL_OK);
  1836. }
  1837. if (strcmp(argv[1],"select-traffic")==0) {
  1838.         strcpy(selectedTraffic_,argv[2]);
  1839. return (TCL_OK);
  1840. }
  1841. if (strcmp(argv[1],"select-src")==0) {
  1842.         selectedSrc_ = atoi(argv[2]);
  1843. return (TCL_OK);
  1844. }
  1845. if (strcmp(argv[1],"select-dst")==0) {
  1846.         selectedDst_ = atoi(argv[2]);
  1847. return (TCL_OK);
  1848. }
  1849. if (strcmp(argv[1],"select-fid")==0) {
  1850.         selectedFid_ = atoi(argv[2]);
  1851. return (TCL_OK);
  1852. }
  1853. if (strcmp(argv[1],"hide-traffic")==0) {
  1854.         strcpy(hideTraffic_,argv[2]);
  1855. return (TCL_OK);
  1856. }
  1857. if (strcmp(argv[1],"hide-src")==0) {
  1858.         hideSrc_ = atoi(argv[2]);
  1859. return (TCL_OK);
  1860. }
  1861. if (strcmp(argv[1],"hide-dst")==0) {
  1862.         hideDst_ = atoi(argv[2]);
  1863. return (TCL_OK);
  1864. }
  1865. if (strcmp(argv[1],"hide-fid")==0) {
  1866.         hideFid_ = atoi(argv[2]);
  1867. return (TCL_OK);
  1868. }
  1869. if (strcmp(argv[1],"color-traffic")==0) {
  1870.         resetf_ = 0 ;
  1871.         strcpy(colorTraffic_,argv[2]);
  1872. return (TCL_OK);
  1873. }
  1874. if (strcmp(argv[1],"color-src")==0) {
  1875.         resetf_ = 0 ;
  1876.         colorSrc_ = atoi(argv[2]);
  1877. return (TCL_OK);
  1878. }
  1879. if (strcmp(argv[1],"color-dst")==0) {
  1880.         resetf_ = 0 ;
  1881.         colorDst_ = atoi(argv[2]);
  1882. return (TCL_OK);
  1883. }
  1884. if (strcmp(argv[1],"color-fid")==0) {
  1885.         resetf_ = 0 ;
  1886.         colorFid_ = atoi(argv[2]);
  1887. return (TCL_OK);
  1888. }
  1889. if (strcmp(argv[1],"select-color")==0) {
  1890. Paint *paint = Paint::instance();
  1891.         selectedColor_ = paint->lookup(argv[2], 1);
  1892. if (selectedColor_ < 0) {
  1893.   fprintf(stderr,"%s color: no such color: %sn",
  1894.   argv[0], argv[2]);
  1895.   selectedColor_ = paint->lookup("black",1);
  1896.   if (selectedColor_ < 0) {
  1897.     tcl.resultf("%s no black! - bailing");
  1898.     return (TCL_ERROR);
  1899.   }
  1900. }
  1901. return (TCL_OK);
  1902.     }
  1904.   if (strcmp(argv[1], "node") == 0) {
  1906. //  else if (argc == 3 && strcmp(argv[1], "node") == 0)
  1907. /*
  1908.  * <net> node <name> <shape> <color> <addr> [<size>]
  1909.  * Create a node using the specified name
  1910.  * and the default size and insert it into this
  1911.  * NetModel's list of drawables.
  1912.  */
  1913. //Node* n = addNode(argc, argv);
  1914.       
  1915.       char * line = new char[strlen(argv[2])];
  1916.       strncpy(line, argv[2],strlen(argv[2]));
  1917.       parsetable_.parseLine(line);
  1918.    Node * node = addNode(traceevent_);
  1919.       delete line;
  1920.    if (node) {
  1921.    return (TCL_OK);
  1922.    } else {
  1923.    tcl.resultf("Unable to create Node %s.", argv[2]);
  1924.    return (TCL_ERROR);
  1925.    }
  1926.     }
  1929. } else if (argc >= 4 && strcmp(argv[1], "agent") == 0) {
  1930. // Create a new agent
  1931.     
  1932. /*
  1933.  * <net> agent <label> <role> <node> <flowcolor> <winInit> 
  1934.  *             <win> <maxcwnd>
  1935.  *             <tracevar> <start> <producemore> <stop>
  1936.  * <net> agent <label> <role> <node> <flowcolor> <packetSize>
  1937.  *       <interval> <start> <stop>
  1938.  */
  1939. int node = atoi(argv[4]);
  1940. int partner_num;
  1941. Node *n = lookupNode(node);
  1942.     
  1943. if (n == 0) {
  1944. tcl.resultf("Node %d doesn't exist.", node);
  1945. return (TCL_ERROR);
  1946. }
  1948. Agent *a = new BoxAgent((char *)argv[2], n->size());
  1949. if (a == 0) {
  1950. tcl.resultf("Cannot create Agent %s exist on Node %d",
  1951.     argv[2], node);
  1952. return (TCL_ERROR);
  1953. }
  1955. placeAgent(a, n);
  1956. a->node_ = n;
  1957. n->add_agent(a);
  1958.     
  1959. a->AgentRole_ = (atoi(argv[3]));
  1961. if (a->AgentRole_ == 20) {
  1962. a->setNumber(atoi(argv[5]));
  1963. partner_num = (atoi(argv[6]));
  1965. Agent *partner = lookupAgent(partner_num);
  1966. if (partner) {
  1967. a->AgentPartner_ = partner;
  1968. partner->AgentPartner_ = a;
  1969. }
  1971. } else if ((a->AgentRole_ == 10) && 
  1972.    (strcmp(argv[2], "CBR") == 0)) {
  1973. if (strcmp(argv[5],"(null)")!=0)
  1974. a->flowcolor((char *)argv[5]);
  1975. a->packetSize(atoi(argv[6]));
  1976. a->interval(atoi(argv[7]));
  1977. a->startAt(atof(argv[8]));
  1978. a->stopAt(atof(argv[9]));
  1979. a->setNumber(atoi(argv[10]));
  1980. partner_num = (atoi(argv[11]));
  1982. Agent *partner = lookupAgent(partner_num);
  1983. if (partner) {
  1984. a->AgentPartner_ = partner;
  1985. partner->AgentPartner_ = a;
  1986. }
  1988. } else if (a->AgentRole_ != 0) {
  1989. if (strcmp(argv[5],"(null)")!=0)
  1990. a->flowcolor((char *)argv[5]);
  1991. a->windowInit(atoi(argv[6]));
  1992. a->window(atoi(argv[7]));
  1993. a->maxcwnd(atoi(argv[8]));
  1994. a->tracevar((char *)argv[9]);
  1995. a->startAt(atof(argv[10]));
  1996. a->produce(atoi(argv[11]));
  1997. a->stopAt(atof(argv[12]));
  1998. a->setNumber(atoi(argv[13]));
  1999. partner_num = (atoi(argv[14]));
  2001. Agent *partner = lookupAgent(partner_num);
  2002. if (partner) {
  2003. a->AgentPartner_ = partner;
  2004. partner->AgentPartner_ = a;
  2005. }
  2006. }
  2007. a->Animation::insert(&animations_);
  2008. return (TCL_OK);
  2010. } else if (argc == 4) {
  2011. if (strcmp(argv[1], "new_monitor_agent") == 0) {
  2012. /* 
  2013.  * <net> new_monitor_agent <node_id> <agent_name>
  2014.  */
  2015. int node = atoi(argv[2]);
  2016. Node *n = lookupNode(node);
  2017. if (n == 0) {
  2018. tcl.resultf("Node %d doesn't exist.", node);
  2019. return (TCL_ERROR);
  2020. }
  2021. Agent *a = n->find_agent((char *)argv[3]);
  2022. if (a == 0) {
  2023. tcl.resultf("Agent %s not exist at node %d",
  2024.     argv[3], node);
  2025. return (TCL_ERROR);
  2026. }
  2027. tcl.resultf("%d", add_monitor(a));
  2028. return (TCL_OK);
  2029. }
  2031. if (strcmp(argv[1], "color") == 0) {
  2032. /*
  2033.  * <net> color <packetClass> <colorName>
  2034.  * Display packets of the specified class using
  2035.  * the specified color.
  2036.  */
  2037. int c = atoi(argv[2]);
  2038. //   if ((unsigned int)c > 1024) {
  2039. //   tcl.resultf("%s color: class %d out of range",
  2040. //       argv[0], c);
  2041. //   return (TCL_ERROR);
  2042. //   }
  2043. // Convert this color index to [0,255], so that 
  2044. // it matches correctly with packet flow ids.
  2045. Paint *paint = Paint::instance();
  2046. if (c > nclass_) {
  2047. int n, i;
  2048. for (n = nclass_; n < c; n <<= 1);
  2049. int *p = new int[n];
  2050. for (i = 0; i < nclass_; ++i)
  2051. p[i] = paint_[i];
  2052. delete paint_;
  2053. paint_ = p;
  2054. nclass_ = n;
  2055. paintMask_ = nclass_ - 1;
  2056. int pno = paint->thin();
  2057. for (; i < n; ++i)
  2058. paint_[i] = pno;
  2059. }
  2060. int pno = paint->lookup(argv[3], 1);
  2061. if (pno < 0) {
  2062.   fprintf(stderr,"%s color: no such color: %sn",
  2063.   argv[0], argv[3]);
  2064.   pno = paint->lookup("black",1);
  2065.   if (pno < 0) {
  2066.     tcl.resultf("%s no black! - bailing");
  2067.     return (TCL_ERROR);
  2068.   }
  2069. }
  2070. paint_[c] = pno;
  2071. oldpaint_[c] = pno;
  2073. return (TCL_OK);
  2074. }
  2075.     
  2076. if (strcmp(argv[1], "ncolor") == 0) {
  2077. /*
  2078.  * <net> ncolor <node> <colorName>
  2079.  * set color of node to the specified color.
  2080.  */
  2081. Paint *paint = Paint::instance();
  2082. Node *n = lookupNode(atoi(argv[2]));
  2083. if (n == NULL) {
  2084. fprintf(stderr, "No such node %sn", argv[2]);
  2085. exit(1);
  2086. }
  2087. int pno = paint->lookup(argv[3], 3);
  2088. if (pno < 0) {
  2089.   fprintf(stderr,"%s ncolor: no such color: %sn",
  2090.   argv[0], argv[3]);
  2091.   int pno = paint->lookup("black",1);
  2092.   if (pno < 0) {
  2093.     tcl.resultf("%s no black! - bailing");
  2094.     return (TCL_ERROR);
  2095.   }
  2096. }
  2097. n->paint(pno);
  2098. return (TCL_OK);
  2099. }
  2103.       
  2104.   // ----- 5 tcl arguments ------
  2105. } else if (argc == 5) {
  2106. if (strcmp(argv[1], "select-pkt") == 0) {
  2107. selectPkt(atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
  2108. return(TCL_OK);
  2109. }
  2112. if (strcmp(argv[1], "lookupColorName") == 0) {
  2113. /*
  2114.  * <net> lookupColorName red green blue
  2115.  * get color name from its rgb value 
  2116.  */   
  2117.  Paint *paint = Paint::instance();
  2118.  int r = atoi(argv[2]);
  2119.  int g = atoi(argv[3]);
  2120.  int b = atoi(argv[4]);
  2121.  tcl.resultf("%s",paint->lookupName(r,g,b));
  2122.  return(TCL_OK);
  2123. }
  2126. if (strcmp(argv[1], "queue") == 0) {
  2127. /*
  2128.  * <net> queue <src> <dst> <angle>
  2129.  * Create a queue for the edge from 'src' to 'dst'.
  2130.  * Add it to this NetModel's queue list.
  2131.  * Display the queue at the specified angle from
  2132.  * the edge to which it belongs.
  2133.  */
  2134. int src = atoi(argv[2]);
  2135. int dst = atoi(argv[3]);
  2136. EdgeHashNode *h = lookupEdgeHashNode(src, dst);
  2137. if (h == 0) {
  2138. tcl.resultf("%s queue: no such edge (%d,%d)",
  2139.     argv[0], src, dst);
  2140. return (TCL_ERROR);
  2141. }
  2142. /* XXX can we assume no duplicate queues? */
  2143. double angle = atof(argv[4]);
  2144. Edge *e = h->edge;
  2145. angle += e->angle();
  2146. Queue *q = new Queue(angle);
  2147. h->queue = q;
  2148. q->next_ = queues_;
  2149. queues_ = q;
  2150. return (TCL_OK);
  2151. }
  2154. if (strcmp(argv[1], "ecolor") == 0) {
  2155. /*
  2156.  * <net> ecolor <src> <dst> <colorName>
  2157.  * set color of edge to the specified color.
  2158.  */
  2159. Paint *paint = Paint::instance();
  2160. EdgeHashNode* h = lookupEdgeHashNode(atoi(argv[2]), atoi(argv[3]));
  2161. if (h == 0) {
  2162. tcl.resultf("%s ecolor: no such edge (%s,%s)",
  2163.     argv[0], argv[2], argv[3]);
  2164. return (TCL_ERROR);
  2165. }
  2166. int pno = paint->lookup(argv[4], 3);
  2167. if (pno < 0) {
  2168.   fprintf(stderr,"%s ncolor: no such color: %sn",
  2169.   argv[0], argv[3]);
  2170.   pno = paint->lookup("black",1);
  2171.   if (pno < 0) {
  2172.     tcl.resultf("%s no black! - bailing");
  2173.     return (TCL_ERROR);
  2174.   }
  2175. }
  2176. h->edge->paint(pno);
  2177. return (TCL_OK);
  2178. }
  2181. if (strcmp(argv[1], "edlabel") == 0) {
  2182. /*
  2183.  * <net> edlabel <src> <dst> <colorName>
  2184.  * set label of edge.
  2185.  */
  2186. EdgeHashNode* h = lookupEdgeHashNode(atoi(argv[2]), 
  2187.      atoi(argv[3]));
  2188. if (h == 0) {
  2189. tcl.resultf("%s ecolor: no such edge (%s,%s)",
  2190.     argv[0], argv[2], argv[3]);
  2191. return (TCL_ERROR);
  2192. }
  2193. if (strcmp(argv[4],"(null)")!=0) {
  2194. h->edge->dlabel((char *)argv[4]);
  2195. // XXX Should never set edge size outside
  2196. // scale_estimate()!!!!
  2197. //   h->edge->size(25.0);
  2198. }
  2199. return (TCL_OK);
  2200. }
  2203. if (strcmp(argv[1], "lanlink") == 0) {
  2204. /*
  2205.  * <net> lanlink <src> <lan> <angle>
  2206.  * Create a link/edge between the specified source
  2207.  * and a lan.
  2208.  */
  2209. Node * src = lookupNode(atoi(argv[2]));
  2210. Lan * lan = lookupLan(atoi(argv[3]));
  2212. if (lan == NULL) {
  2213. fprintf(stderr, "Error: lan %s does not exist.n", argv[3]);
  2214. exit(1);
  2215. }
  2217. double angle = atof(argv[4]);
  2218. double bw = lan->bw();
  2219. double delay = (lan->delay())/2.0;
  2221. Edge *e1 = new Edge(src, lan->virtual_node(), packet_size_, bw, delay, 0, angle+1);
  2222. e1->init_color("black");
  2223. enterEdge(e1);
  2225. e1->Animation::insert(&drawables_);
  2226. src->add_link(e1);
  2228. Edge *e2 = new Edge(lan->virtual_node(), src, packet_size_, bw, delay, 0, angle);
  2229. e2->init_color("black");
  2230. enterEdge(e2);
  2231. e2->Animation::insert(&drawables_);
  2232. lan->add_link(e2);
  2233. return (TCL_OK);
  2234. }
  2237. if (strcmp(argv[1], "set_node_tclscript") == 0) {
  2238. //------------------------------------------------------------------
  2239. // $netModel set_node_tclscript $node_id $button_label $tcl_command
  2240. //   - from tcl/node.tcl
  2241. //          Animator instproc node_tclscript
  2242. //------------------------------------------------------------------
  2243. // Sets the tcl_script for a node to be run when the
  2244. // start_info exec button is pressed.
  2245. Node * node = lookupNode(atoi(argv[2]));
  2246. if (node) {
  2247. // The following strings are deleted by the node when it 
  2248. // changes to another script or it is deleted
  2249. node->setTclScript(argv[3], argv[4]);
  2250. return TCL_OK;
  2251. } else {
  2252. return TCL_ERROR;
  2253. }
  2254. }
  2258. } else if (argc == 6) {
  2259. if (strcmp(argv[1], "lan") == 0) {
  2260. /*
  2261.  * <net> lan <name> <bandwidth> <delay> <angle>
  2262.  * Create a link/edge between the specified source
  2263.  * and destination. Add it to this NetModel's list
  2264.  * of drawables and to the source's list of links.
  2265.  */
  2266. double bw = atof(argv[3]);
  2267. double delay = atof(argv[4]);
  2268. double angle = atof(argv[5]);
  2270. Lan *l = new Lan(argv[2], this, packet_size_, bw, delay, angle);
  2271. l->next_ = lans_;
  2272. lans_ = l;
  2273. l->insert(&drawables_);
  2275. Node *n = l->virtual_node();
  2276. n->next_ = nodes_;
  2278. nodes_ = n;
  2279. return (TCL_OK);
  2280. }
  2282. } else if (argc == 8) {
  2283. if (strcmp(argv[1], "link") == 0) {
  2284. /*
  2285.  * <net> link <src> <dst> <bandwidth> <delay> <angle>
  2286.  * Create a link/edge between the specified source
  2287.  * and destination. Add it to this NetModel's list
  2288.  * of drawables and to the source's list of links.
  2289.  */
  2290. Edge * edge = addEdge(argc,argv);
  2291. if (!edge) {
  2292. tcl.resultf("node %s or %s is not defined... ", argv[2], argv[3]);
  2293. return TCL_ERROR;
  2294. } else { 
  2295. tcl.resultf("%g", edge->delay());
  2296. return (TCL_OK);
  2297. }
  2298. }
  2299. }
  2300. /* If no NetModel commands matched, try the Object commands. */
  2301. fprintf(stderr, "No matching command found for %sn",argv[0]);
  2302. return (TclObject::command(argc, argv));
  2303. }
  2306. void NetModel::selectPkt(int sData, int sRoute, int sMac) 
  2307. {
  2308.     showData_ = sData;
  2309.     showRouting_ = sRoute;
  2310.     showMac_ = sMac;
  2311. }
  2315. // ---------------------------------------------------------------------
  2316. // void
  2317. // NetModel::placeEdgeByAngle(Edge* e, Node* src) const {
  2318. // Place edges by their angles
  2319. // ---------------------------------------------------------------------
  2320. void 
  2321. NetModel::placeEdgeByAngle(Edge * e, Node * src) const {
  2322.   double nsin, ncos, x0, x1, y0, y1;
  2323.   Node * destination;
  2324.   EdgeHashNode * h;
  2326.   if (e->marked() == 0) {
  2327.     // get destination node
  2328.     destination = e->neighbor();
  2330.     SINCOSPI(e->angle(), &nsin, &ncos);
  2332.     x0 = src->x(e) + src->size() * ncos * 0.75;
  2333.     y0 = src->y(e) + src->size() * nsin * 0.75;
  2334.     x1 = destination->x(e) - destination->size() * ncos * 0.75;
  2335.     y1 = destination->y(e) - destination->size() * nsin * 0.75;
  2337.     e->place(x0, y0, x1, y1);
  2338.     
  2339.     // Place the queue here too.
  2340.     h = lookupEdgeHashNode(e->src(), e->dst());
  2341.     if (h->queue != 0) {
  2342.       h->queue->place(e->size(), e->x0(), e->y0());
  2343.     }
  2345.     e->mark();
  2346.   }
  2347. }
  2349. void NetModel::placeEdge(Edge * e, Node * src) const {
  2350. if (e->marked() == 0) {
  2351. double hyp, dx, dy;
  2352. Node * dst = e->neighbor();
  2353. dx = dst->x(e) - src->x(e);
  2354. dy = dst->y(e) - src->y(e);
  2355. hyp = sqrt(dx*dx + dy*dy);
  2356. e->setAngle(atan2(dy,dx));
  2357. double x0 = src->x(e) + src->size() * (dx/hyp) * .75;
  2358. double y0 = src->y(e) + src->size() * (dy/hyp) * .75;
  2359. double x1 = dst->x(e) - dst->size() * (dx/hyp) * .75;
  2360. double y1 = dst->y(e) - dst->size() * (dy/hyp) * .75;
  2361. e->place(x0, y0, x1, y1);
  2363. /* Place the queue here too.  */
  2364. EdgeHashNode *h = lookupEdgeHashNode(e->src(), e->dst());
  2365. if (h->queue != 0)
  2366. h->queue->place(e->size(), e->x0(), e->y0());
  2368. e->mark();
  2369. }
  2370. }
  2372. //----------------------------------------------------------------------
  2373. // void
  2374. // NetModel::placeAgent(Agent *a, Node *src) const
  2375. //----------------------------------------------------------------------
  2376. void 
  2377. NetModel::placeAgent(Agent *a, Node *src) const {
  2378.   double x0, y0, nsin, ncos;
  2379.   Agent * agents;
  2380.   Edge * links;
  2381.   int choices[8], i, ix;
  2382.   double angle;
  2383.   TrafficSource * traffic_source;
  2385.   if (a->marked() == 0) {
  2386.     if (a->angle()==NO_ANGLE) {
  2387.       if (a->edge()==NULL) {
  2388.         /* determine where to put the label so it
  2389.            won't overlap a link (if possible) */
  2390.         for(i = 0; i < 8; i++) {
  2391.           choices[i] = 1;
  2392.         }
  2394.         // Get list of agents attached to the src node
  2395.         agents = src->agents();
  2397.         // Loop through list of agents checking their locations
  2398.         while (agents != NULL) {
  2399.           angle = agents->angle();
  2400.           if (angle < 0) {
  2401.             angle = angle+2*M_PI;
  2402.           }
  2403.           ix = int(angle*4);
  2404.           if (ix < 8) {
  2405.             choices[ix] = 0;
  2406.           }
  2407.           agents=agents->next_;
  2408.         }
  2410.         // Get a list of links attached to the src node
  2411.         links = src->links();
  2413.         // Loop through the list checking their locations
  2414.         while (links!=NULL) {
  2415.           angle = links->angle();
  2416.           if (angle < 0) {
  2417.             angle = angle + 2*M_PI;
  2418.           }
  2419.           ix = int(angle * 4);
  2420.           if (ix < 8) {
  2421.             choices[ix] = 0;
  2422.           }
  2423.           links=links->next_;
  2424.         }
  2426.         // Choose an angle from the marked choices list
  2427.         if (choices[0] == 1) {
  2428.           a->angle(0);
  2429.         } else if (choices[4] == 1) {
  2430.           a->angle(1.0);
  2431.         } else if ((choices[1] == 1) && (choices[2] == 1)) {
  2432.           a->angle(0.5);
  2433.         } else if ((choices[6]==1)&&(choices[7]==1)) {
  2434.           a->angle(1.5);
  2435.         } else if (choices[1]==1) {
  2436.           a->angle(0.25);
  2437.         } else {
  2438.           a->angle(1.75);
  2439.         }
  2440.       } else {
  2441.         a->angle(a->edge()->angle() + 0.25);
  2442.       }
  2443.     }
  2445.     SINCOSPI(a->angle(), &nsin, &ncos);
  2446.     x0 = src->x() + src->size() * ncos * .75;
  2447.     y0 = src->y() + src->size() * nsin * .75;
  2448.     a->place(x0, y0);
  2449.     a->mark(1);
  2451.     // Place any traffic sources that are connected to this agent
  2452.     for (traffic_source = a->traffic_sources_;
  2453.          traffic_source;
  2454.          traffic_source = traffic_source->next_) {
  2455.       traffic_source->place();
  2456.     }
  2457.     
  2458.   }
  2459. }
  2461. //----------------------------------------------------------------------
  2462. //----------------------------------------------------------------------
  2463. void
  2464. NetModel::hideAgentLinks() {
  2465. for (Node* n = nodes_; n != 0; n = n->next_) 
  2466. for(Agent* a= n->agents(); a != 0; a = a->next_) 
  2467. a->hideLink();
  2468. }
  2470. //----------------------------------------------------------------------
  2471. //----------------------------------------------------------------------
  2472. void NetModel::set_wireless() {
  2473. wireless_ = 1 ;
  2474. for (Node *n = nodes_; n != 0; n = n->next_)
  2475. for (Edge *e=n->links(); e != 0; e = e->next_)
  2476. e->unmark();
  2477. scale_estimate();
  2478. placeEverything();
  2479. for (View *p = views_; p != 0; p = p->next_)
  2480. if ((p->width() > 0) && (p->height() > 0)) {
  2481. p->redrawModel();
  2482. p->draw();
  2483. }
  2484. }
  2486. //----------------------------------------------------------------------
  2487. // void
  2488. // NetModel::scale_estimate() {
  2489. //   - Compute reasonable defaults for missing node or edge sizes
  2490. //     based on the maximum link delay.
  2491. //----------------------------------------------------------------------
  2492. void
  2493. NetModel::scale_estimate() {
  2494.   /* Determine the maximum link delay. */
  2495.   // XXX Must use length(). This is essential for appropriate 
  2496.   // packet height when using a pre-made layout.
  2497.   double emax = 0.;
  2498.   Node *n;
  2499.   for (n = nodes_; n != 0; n = n->next_) {
  2500.     for (Edge* e = n->links(); e != 0; e = e->next_)
  2501.       if (e->length() > emax)
  2502.         emax = e->length();
  2503.   }
  2505.   /*store this because we need it for monitors*/
  2506.   node_size_ = node_sizefac_ * emax;
  2508.   /*
  2509.    * Check for missing node or edge sizes. If any are found,
  2510.    * compute a reasonable default based on the maximum edge
  2511.    * dimension.
  2512.    */
  2513.   for (n = nodes_; n != 0; n = n->next_) {
  2514.     if (n->size() <= 0.)
  2515.       n->size(node_size_);
  2517.     for (Edge* e = n->links(); e != 0; e = e->next_)
  2518.       if (e->size() <= 0.)
  2519.         e->size(.03 * emax);
  2520.   }
  2521. }
  2523. //----------------------------------------------------------------------
  2524. //----------------------------------------------------------------------
  2525. void NetModel::placeEverything() {
  2526.   // If there is no fixed node, anchor the first one entered at (0,0).
  2527.   Node *n;
  2528.   Edge * e;
  2529.   int nodes_to_be_placed;
  2531.   for (n = nodes_; n != 0; n = n->next_) {
  2532.     n->mark(0);
  2533.     n->clear_routes();
  2534.   }
  2536.   if (nodes_) {
  2537.     //nodes_->place(0., 0.);
  2538.     nodes_->place(nodes_->x(), nodes_->y());
  2539.   }
  2541.   do {
  2542.     nodes_to_be_placed = 0;
  2543.     for (n = nodes_; n != 0; n = n->next_) {
  2544.       nodes_to_be_placed |= traverseNodeConnections(n);
  2545.     }
  2546.   } while (nodes_to_be_placed);
  2548.   // Place edges
  2549.   for (n = nodes_; n != 0; n = n->next_) { 
  2550.     for (e = n->links(); e != 0; e = e->next_) {
  2551.       placeEdgeByAngle(e, n);
  2552.     }
  2553.   }
  2555.   // After edges are laied out, place all routes.
  2556.   for (n = nodes_; n != 0; n = n->next_) {
  2557.     n->place_all_routes();
  2558.   }
  2559. }
  2561. //----------------------------------------------------------------------
  2562. //----------------------------------------------------------------------
  2563. void NetModel::move(double& x, double& y, double angle, double d) const {
  2564. double ncos, nsin;
  2565. SINCOSPI(angle, &nsin, &ncos);
  2566. x += d * ncos;
  2567. y += d * nsin;
  2568. }
  2570. //----------------------------------------------------------------------
  2571. // int NetModel::traverseNodeConnections(Node* n)
  2572. //   - Traverse node n's neighbors and place them based on the
  2573. //     delay of their links to n.  The two branches of the if..else
  2574. //     are to handle unidirectional links -- we place ourselves if
  2575. //     we haven't been placed & our downstream neighbor has.
  2576. //----------------------------------------------------------------------
  2577. int NetModel::traverseNodeConnections(Node* n) {
  2578.   double x, y, distance;
  2579.   int placed_node = 0;
  2581.   for (Edge* e = n->links(); e != 0; e = e->next_) {
  2582.     Node *neighbor = e->neighbor();
  2583.     distance = e->length() + (n->size() + neighbor->size()) * 0.75;
  2585.     if (n->marked() && !neighbor->marked()) {
  2586.       x = n->x(e);
  2587.       y = n->y(e);
  2588.       move(x, y, e->angle(), distance);
  2589.       neighbor->place(x, y);
  2591.       placed_node |= traverseNodeConnections(neighbor);
  2593.       if (nymax_ < y)
  2594.         nymax_ = y;
  2595.       if (nymin_ > y)
  2596.         nymin_ = y;
  2598.     } else if (!n->marked() && neighbor->marked()) {
  2599.       x = neighbor->x(e);
  2600.       y = neighbor->y(e);
  2601.       move(x, y, e->angle(), -distance);
  2602.       n->place(x, y);
  2603.       placed_node = 1;
  2604.     }
  2605.   }
  2606.   return placed_node;
  2607. }
  2609. int NetModel::save_layout(const char *filename)
  2610. {
  2611.   FILE *file;
  2612.   Node *n;
  2613.   Edge *e;
  2614.   int ret;
  2615.   file=fopen(filename, "w");
  2616.   if (file==0)
  2617.   {
  2618.     fprintf(stderr, "nam: Couldn't open file: %sn", filename);
  2619.     return -1;
  2620.   }
  2621.   for (n = nodes_; n != 0; n = n->next_)
  2622.   {
  2623.     ret = n->save(file);
  2624.     if (ret!=0) {
  2625.       fclose(file);
  2626.       return -1;
  2627.     }
  2628.   }
  2629.   for (n = nodes_; n != 0; n = n->next_)
  2630.     for(e= n->links(); e !=0; e = e->next_)
  2631.     {
  2632.       ret = e->save(file);
  2633.       if (ret!=0) {
  2634. fclose(file);
  2635. return -1;
  2636.       }
  2637.     }
  2638.   return(fclose(file));
  2639. }
  2641. void NetModel::color_subtrees()
  2642. {
  2643.   Node *n, *dst, *prevdst, *newdst;
  2644.   Edge* e;
  2645.   for (n = nodes_; n != 0; n = n->next_) {
  2646.     int ctr=0;
  2647.     for (e = n->links(); e != 0; e = e->next_)
  2648.       ctr++;
  2649.     if (ctr==1)
  2650.     {
  2651.       n->color("grey");
  2652.       n->links()->color("grey");
  2653.       dst=n->links()->neighbor();
  2654.       for (e = dst->links(); e != 0; e = e->next_)
  2655. if (e->neighbor()==n)
  2656. {
  2657.   e->color("grey");
  2658.   break;
  2659. }
  2660.       ctr=2;
  2661.       prevdst=n;
  2662.       while(ctr==2) {
  2663. ctr=0;
  2664. for (e = dst->links(); e != 0; e = e->next_)
  2665.   ctr++;
  2666. if (ctr==2) {
  2667.   dst->color("grey");
  2668.   dst->links()->color("grey");
  2669.   for (e = dst->links(); e != 0; e = e->next_)
  2670.     if (e->neighbor()!=prevdst)
  2671.     {
  2672.       newdst=e->neighbor();
  2673.       break;
  2674.     }
  2675.   e->color("grey");
  2676.   for (e = newdst->links(); e != 0; e = e->next_)
  2677.     if (e->neighbor()==dst)
  2678.     {
  2679.       e->color("grey");
  2680.       break;
  2681.     }
  2682.   prevdst=dst;
  2683.   dst=newdst;
  2684. }
  2685.       }
  2686.     }
  2687.   }
  2688. }
  2691. //----------------------------------------------------------------------
  2692. // int
  2693. // NetModel::add_tag(Tag *tag)
  2694. //----------------------------------------------------------------------
  2695. int
  2696. NetModel::add_tag(Tag *tag) {
  2697.   int newEntry = 1;
  2698.   Tcl_HashEntry * he;
  2699.   he = Tcl_CreateHashEntry(tagHash_, (const char *)tag->name(), &newEntry);
  2701.   if (he == NULL) {
  2702.     return (TCL_ERROR);
  2703.   }
  2705.   if (newEntry) {
  2706.     Tcl_SetHashValue(he, (ClientData)tag);
  2707.     nTag_++;
  2708.   }
  2710.   tag->insert(&drawables_);
  2712.   return (TCL_OK);
  2713. }
  2715. // Remove a tag from netmodel, and clear all its memberships but not 
  2716. // actually delete it
  2717. void NetModel::delete_tag(const char *tn)
  2718. {
  2719. Tcl_HashEntry *he = 
  2720. Tcl_FindHashEntry(tagHash_, (const char *)tn);
  2721. if (he != NULL) {
  2722. // Do *NOT* delete tag here.
  2723. Tcl_DeleteHashEntry(he);
  2724. nTag_--;
  2725. }
  2726.   
  2727. }
  2729. Tag* NetModel::lookupTag(const char *tn)
  2730. {
  2731. Tcl_HashEntry *he = Tcl_FindHashEntry(tagHash_, tn);
  2732. if (he == NULL)
  2733. return NULL;
  2734. return (Tag *)Tcl_GetHashValue(he);
  2735. }
  2737. int NetModel::registerObjName(const char *name, int id)
  2738. {
  2739. int newEntry = 1;
  2740. Tcl_HashEntry *he = 
  2741. Tcl_CreateHashEntry(objnameHash_, name, &newEntry);
  2742. if (he == NULL)
  2743. return (TCL_ERROR);
  2744. if (newEntry) {
  2745. Tcl_SetHashValue(he, (ClientData)id);
  2746. nTag_++;
  2747. }
  2748. return (TCL_OK);
  2749. }
  2751. //XXX: maximum name length is 256. 
  2752. int NetModel::lookupObjname(const char *name)
  2753. {
  2754. #define STATIC_NAMELEN 256
  2755. char n[STATIC_NAMELEN];
  2756. size_t len = strlen(name);
  2757. len = (len < STATIC_NAMELEN) ? len : STATIC_NAMELEN;
  2758. for (size_t i = 0; i < len; i++)
  2759. n[i] = toupper(name[i]);
  2761. Tcl_HashEntry *he = Tcl_FindHashEntry(objnameHash_, n);
  2762. if (he == NULL)
  2763. return -1;
  2764. return *Tcl_GetHashValue(he);
  2765. #undef STATIC_NAMELEN
  2766. }
  2768. /*
  2769.  * Unite tag name space and animation id space:
  2770.  * 
  2771.  * (1) if tag is a number, we'll first look it up in our 
  2772.  *     animation objects table. 
  2773.  * (2) if tag is a string, it must be in the tag table
  2774.  */
  2775. Animation* NetModel::lookupTagOrID(const char *name)
  2776. {
  2777. char end[256];
  2778. if (name == NULL)
  2779. return NULL;
  2780. unsigned int id = (unsigned int)strtoul(name, (char **)&end, 0);
  2781. if (*end != 0)
  2782. // This must be a tag string name
  2783. return lookupTag(name);
  2784. else 
  2785. return Animation::find(id);
  2786. }
  2788. /*
  2789.  * Handling Tcl command "addtags" of EditView
  2790.  *
  2791.  * <view> addtag tag <searchSpec> arg...
  2792.  *
  2793.  * searchSpec can be: 
  2794.  *   all <ObjectType>
  2795.  *   closest x y ?halo? 
  2796.  *   enclosed x1 y1 x2 y2
  2797.  *   overlapping x1 y1 x2 y2
  2798.  *   withTag tagOrID
  2799.  * specification copied from Tk's canvas
  2800.  *
  2801.  * If newTag isn't null, then first lookup the tag. If found, add
  2802.  * the searchSpec results to that tag, otherwise create a new tag
  2803.  * and add results to that tag.
  2804.  * Return error if newTag == NULL.
  2805.  *
  2806.  * Tagging policies, e.g., whether an object can simultaneously belong 
  2807.  * to multiple tags, are left to the users.
  2808.  */
  2809. int NetModel::tagCmd(View *v, int argc, char **argv, 
  2810.      char *newTag, char *cmdName)
  2811. {
  2812. Tag *tag = NULL;
  2813. size_t length;
  2814. Tcl& tcl = Tcl::instance();
  2815. int res = (TCL_OK), bNew = 0;
  2817. if (newTag != NULL) {
  2818. tag = (Tag *)lookupTagOrID(newTag);
  2819. if ((tag != NULL) && (tag->classid() != ClassTagID)) {
  2820. Tcl_AppendResult(tcl.interp(),
  2821.  newTag, "should be a tag ",
  2822.  (char *)NULL);
  2823. return TCL_ERROR;
  2824. }
  2825. if (tag == NULL) {
  2826. tag = new Tag(newTag);
  2827. bNew = 1;
  2828. }
  2829. }
  2831. int c = argv[0][0];
  2832. length = strlen(argv[0]);
  2834. if ((c == 'a') && (strncmp(argv[0], "all", length) == 0)
  2835.     && (length >= 2)) {
  2836. if (argc > 2) {
  2837. Tcl_AppendResult(tcl.interp(), 
  2838.  "wrong # args: should be "", cmdName,
  2839.  " all ?Obj?", (char *) NULL);
  2840. res = TCL_ERROR;
  2841. goto error;
  2842. }
  2843. Animation *a;
  2844. int objType = ClassAllID;
  2845. if (argc == 2) {
  2846. // Map object name to class id
  2847. objType = lookupObjname(argv[1]);
  2848. if (objType == -1) {
  2849. Tcl_AppendResult(tcl.interp(),
  2850.  "Bad object name ", argv[1]);
  2851. res = (TCL_ERROR);
  2852. goto error;
  2853. }
  2854. }
  2855. if (objType == ClassAllID) {
  2856. for (a = animations_; a != NULL; a = a->next())
  2857. if (!a->isTagged())
  2858. tagObject(tag, a);
  2859. for (a = drawables_; a != NULL; a = a->next())
  2860. if (!a->isTagged())
  2861. tagObject(tag, a);
  2862. } else {
  2863. for (a = animations_; a != NULL; a = a->next())
  2864. if (!a->isTagged() && a->classid() == objType)
  2865. tagObject(tag, a);
  2866. for (a = drawables_; a != NULL; a = a->next())
  2867. if (!a->isTagged() && a->classid() == objType)
  2868. tagObject(tag, a);
  2869. }
  2871. } else if ((c == 'e') && (strncmp(argv[0], "enclosed", length) == 0)) {
  2872. /* 
  2873.  * enclosed x1 y1 x2 y2
  2874.  */
  2875. if (argc != 5) {
  2876. Tcl_AppendResult(tcl.interp(), 
  2877.  "wrong # args: should be "",
  2878.  cmdName, " enclosed x1 y1 x2 y2", 
  2879.  (char *) NULL);
  2880. res = TCL_ERROR;
  2881. goto error;
  2882. }
  2883. BBox bb;
  2884. // Translation/scaling will not change the order of bbox. :)
  2885. if ((v->getCoord(argv[1], argv[2],
  2886.  bb.xmin, bb.ymin) != TCL_OK) ||
  2887.     (v->getCoord(argv[3], argv[4], bb.xmax, bb.ymax)!=TCL_OK))
  2888. res = TCL_ERROR;
  2889. else 
  2890. res = tagArea(bb, tag, 1);
  2892. } else if ((c == 'o') && 
  2893.    (strncmp(argv[0], "overlapping", length) == 0)) {
  2894. /*
  2895.  * Overlapping x1 y1 x2 y2 
  2896.  */
  2897. if (argc != 5) {
  2898. Tcl_AppendResult(tcl.interp(), 
  2899.  "wrong # args: should be "",
  2900.  cmdName, " overlapping x1 y1 x2 y2",
  2901.  (char *) NULL);
  2902. res = TCL_ERROR;
  2903. goto error;
  2904. }
  2905. BBox bb;
  2906. // Translation/scaling will not change the order of bbox. :)
  2907. if ((v->getCoord(argv[1], argv[2],
  2908.  bb.xmin, bb.ymin) != TCL_OK) ||
  2909.     (v->getCoord(argv[3], argv[4], bb.xmax, bb.ymax)!=TCL_OK))
  2910. res = TCL_ERROR;
  2911. else 
  2912. res = tagArea(bb, tag, 0);
  2914. } else if ((c == 'w') && (strncmp(argv[0], "withtag", length) == 0)) {
  2915. if (argc != 2) {
  2916. Tcl_AppendResult(tcl.interp(), 
  2917.  "wrong # args: should be "",
  2918.  cmdName, " withtag tagOrId", 
  2919.  (char *) NULL);
  2920. res = TCL_ERROR;
  2921. goto error;
  2922. }
  2923. // Find that tag or ID
  2924. Animation *p = lookupTagOrID(argv[1]);
  2925. if (p == NULL) {
  2926. // Wrong tag
  2927. Tcl_AppendResult(tcl.interp(),
  2928.  "wrong tag ", argv[1],
  2929.  (char *)NULL);
  2930. res = TCL_ERROR;
  2931. } else {
  2932. // Label them as this tag
  2933. tagObject(tag, p);
  2934. }
  2936. } else if ((c == 'c') && (strncmp(argv[0], "closest", length) == 0)) {
  2937. float coords[2], halo;
  2938. if ((argc < 3) || (argc > 5)) {
  2939. Tcl_AppendResult(tcl.interp(), 
  2940.  "wrong # args: should be "",
  2941.  cmdName, " closest x y ?halo? ",
  2942.  (char *) NULL);
  2943. res = TCL_ERROR;
  2944. goto error;
  2945. }
  2946. if (v->getCoord(argv[1], argv[2], 
  2947. coords[0], coords[1]) != TCL_OK) {
  2948. Tcl_AppendResult(tcl.interp(),
  2949.  "bad coordinates ",
  2950.  argv[1], " ", argv[2], (char *)NULL);
  2951. res = TCL_ERROR;
  2952. goto error;
  2953. }
  2954. if (argc > 3) {
  2955. // XXX: It's impossible to convert length in 
  2956. // screen space to world space with translation
  2957. // and scaling. We think it's in world space
  2958. halo = strtod(argv[3], NULL);
  2959. if (halo < 0.0) {
  2960. Tcl_AppendResult(tcl.interp(), 
  2961.        "can't have negative halo value "",
  2962.  argv[3], """, (char *) NULL);
  2963. res = TCL_ERROR;
  2964. goto error;
  2965. }
  2966. } else {
  2967. halo = 0.0;
  2968. }
  2969. Animation *p = findClosest(coords[0], coords[1], halo);
  2970. if (p != NULL)
  2971. tagObject(tag, p);
  2972. else 
  2973. res = TCL_ERROR;
  2975. } else  {
  2976. Tcl_AppendResult(tcl.interp(), 
  2977.  "bad search command "", argv[0],
  2978.  "": must be above, all, below, closest, enclosed, ",
  2979.  "overlapping, or withtag", (char *) NULL);
  2980. res = TCL_ERROR;
  2981. goto error;
  2982. }
  2984. if (res == TCL_OK) {
  2985. if (bNew)
  2986. add_tag(tag);
  2987. return TCL_OK;
  2988. }
  2989. error:
  2990. if (tag != NULL)
  2991. delete tag;
  2992. return res;
  2993. }
  2995. Animation* NetModel::findClosest(float dx, float dy, double halo)
  2996. {
  2997. double closestDist;
  2998. Animation *startPtr, *closestPtr, *itemPtr;
  2999. BBox bb;
  3001. startPtr = animations_;
  3002. itemPtr = startPtr;
  3003. if (itemPtr == NULL) {
  3004. return NULL;
  3005. }
  3006. closestDist = itemPtr->distance(dx, dy) - halo;
  3008. if (closestDist < 0.0) {
  3009. closestDist = 0.0;
  3010. }
  3011. while (1) {
  3012. double newDist;
  3013. /*
  3014.  * Update the bounding box using itemPtr, which is the
  3015.  * new closest item.
  3016.  */
  3017. bb.xmin = dx - closestDist - halo - 1,
  3018. bb.ymin = dy - closestDist - halo - 1,
  3019. bb.xmax = dx + closestDist + halo + 1,
  3020. bb.ymax = dy + closestDist + halo + 1;
  3021. closestPtr = itemPtr;
  3022. /*
  3023.  * Search for an item that beats the current closest 
  3024.  * one.
  3025.  * Work circularly through the canvas's item list until
  3026.  * getting back to the starting item.
  3027.  */
  3028. while (1) {
  3029. itemPtr = itemPtr->next();
  3030. if (itemPtr == NULL) {
  3031. if (startPtr == animations_) {
  3032. startPtr = drawables_;
  3033. itemPtr = startPtr;
  3034. } else 
  3035. return closestPtr;
  3036. }
  3037. if (itemPtr->isTagged()|| !itemPtr->bbox().overlap(bb))
  3038. continue;
  3039. newDist = itemPtr->distance(dx, dy)-halo;
  3040. if (newDist < 0.0) {
  3041. newDist = 0.0;
  3042. }
  3043. if (newDist <= closestDist) {
  3044. closestDist = newDist;
  3045. break;
  3046. }
  3047. }
  3048. }
  3049. }
  3051. //----------------------------------------------------------------------
  3052. // void
  3053. // NetModel::tagObject(Tag *tag, Animation * animation_object)
  3054. //----------------------------------------------------------------------
  3055. void
  3056. NetModel::tagObject(Tag *tag, Animation * animation_object) {
  3057. Tcl & tcl = Tcl::instance();
  3059. if (tag == NULL) {
  3060. char str[20];
  3061. sprintf(str, "No tag for %d", animation_object->id());
  3062. Tcl_AppendElement(tcl.interp(), str);
  3063. return;
  3064. }
  3066. if (tag == animation_object)
  3067. return;
  3069. // add animation object to the tag group 
  3070. tag->add(animation_object);
  3071. }
  3073. //----------------------------------------------------------------------
  3074. //----------------------------------------------------------------------
  3075. int NetModel::tagArea(BBox &bb, Tag *tag, int bEnclosed)
  3076. {
  3077. Animation *p;
  3079. // Because the area is a rectangle, we only need to 
  3080. // find out all objects whose bounding boxes are 
  3081. // within/overlapping the given rectangle.
  3082. if (bEnclosed == 0) {
  3083. // overlapping and enclosed
  3084. for (p = animations_; p != NULL; p = p->next()) 
  3085. if (!p->isTagged() && p->bbox().overlap(bb) 
  3086.     && (p != tag))
  3087. tagObject(tag, p);
  3088. for (p = drawables_; p != NULL; p = p->next())
  3089. if (!p->isTagged() && p->bbox().overlap(bb)
  3090.     && (p != tag))
  3091. tagObject(tag, p);
  3092. } else {
  3093. // enclosed only
  3094. for (p = animations_; p != NULL; p = p->next()) 
  3095. if (!p->isTagged() && bb.inside(p->bbox())
  3096.     && (p != tag))
  3097. tagObject(tag, p);
  3098. for (p = drawables_; p != NULL; p = p->next())
  3099. if (!p->isTagged() && bb.inside(p->bbox())
  3100.     && (p != tag))
  3101. tagObject(tag, p);
  3102. }
  3103. return TCL_OK;
  3104. }
  3106. int NetModel::deleteTagCmd(char *tagName, char *tagDel)
  3107. {
  3108. Tag *p;
  3109. Animation *q = NULL;
  3111. p = (Tag *)lookupTagOrID(tagName);
  3112. if (tagDel != NULL)
  3113. q = lookupTagOrID(tagDel);
  3115. if (p == NULL) {
  3116. Tcl_AppendResult(Tcl::instance().interp(),
  3117.  "bad tag ", tagName, (char *)NULL);
  3118. return (TCL_ERROR);
  3119. }
  3120. if ((p->classid() != ClassTagID) || (p == q) || (q == NULL)){
  3121. // If given an ID, or given a group only
  3122. // delete it and do nothing else
  3123. delete p;
  3124. return TCL_OK; 
  3125. }
  3126. // Now delete tag p from object q
  3127. q->deleteTag(p);
  3128. return TCL_OK;
  3129. }
  3131. // ---------------------------------------------------------------------
  3132. // void
  3133. // NetModel::render(EditView* view, BBox &bb)
  3134. //   - This is a partial render which does not seem to be complete.
  3135. //     Above here are several other render functions which redisplay 
  3136. //     the entire model.
  3137. //
  3138. // XXX: Partial redraw is only working for EditView! Not for other
  3139. // animation views for now. We need a method in each Animation object
  3140. // to decide their "dirtiness" to make this redraw work. :( And the
  3141. // computation of clipping box should be purely within NetModel but
  3142. // not fed in externally
  3143. // ---------------------------------------------------------------------
  3144. void
  3145. NetModel::render(EditView* view, BBox &bb) {
  3146.   Animation *a;
  3148.   for (a = drawables_; a != 0; a = a->next()) {
  3149.     if (!a->bbox().overlap(bb)) {
  3150.       // if outside of our views bounding box then skip 
  3151.       // this animation object
  3152.       continue;
  3153.     }
  3154.     a->draw(view, now_);
  3155.   }
  3157.   for (a = animations_; a != 0; a = a->next()) {
  3158.     if (!a->bbox().overlap(bb)) {
  3159.       // if outside of our views bounding box then skip 
  3160.       // this animation object
  3161.       continue;
  3162.     }
  3163.     a->draw(view, now_);
  3164.   }
  3165. }
  3167. void NetModel::moveNode(Node *n) {
  3168. //fprintf(stderr, "Moving nodes can only be performed by NetModel.n");
  3169. for (Edge *e = n->links(); e != 0; e = e->next_) {
  3170. e->unmark();
  3171. placeEdge(e, n);
  3172. Node *dst = e->neighbor();
  3173. // Should place reverse edges too
  3174. Edge *p = dst->find_edge(n->num());
  3175. if (p != NULL) {
  3176. p->unmark();
  3177. placeEdge(p, dst);
  3178. }
  3179. dst->clear_routes();
  3180. dst->place_all_routes();
  3181. }
  3182. for (Agent *a = n->agents(); a != NULL; a = a->next()) {
  3183. a->mark(0), a->angle(NO_ANGLE);
  3184. placeAgent(a, n);
  3185. }
  3186. // Relayout all routes
  3187. n->clear_routes();
  3188. n->place_all_routes();
  3189. }