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

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

通讯编程

开发平台：

Visual C++

editview.cc：源码内容
  1. /*
  2.  * Copyright (C) 1997 by the University of Southern California
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License,
  6.  * version 2, as published by the Free Software Foundation.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License along
  14.  * with this program; if not, write to the Free Software Foundation, Inc.,
  15.  * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16.  *
  17.  *
  18.  * The copyright of this module includes the following
  19.  * linking-with-specific-other-licenses addition:
  20.  *
  21.  * In addition, as a special exception, the copyright holders of
  22.  * this module give you permission to combine (via static or
  23.  * dynamic linking) this module with free software programs or
  24.  * libraries that are released under the GNU LGPL and with code
  25.  * included in the standard release of ns-2 under the Apache 2.0
  26.  * license or under otherwise-compatible licenses with advertising
  27.  * requirements (or modified versions of such code, with unchanged
  28.  * license).  You may copy and distribute such a system following the
  29.  * terms of the GNU GPL for this module and the licenses of the
  30.  * other code concerned, provided that you include the source code of
  31.  * that other code when and as the GNU GPL requires distribution of
  32.  * source code.
  33.  *
  34.  * Note that people who make modified versions of this module
  35.  * are not obligated to grant this special exception for their
  36.  * modified versions; it is their choice whether to do so.  The GNU
  37.  * General Public License gives permission to release a modified
  38.  * version without this exception; this exception also makes it
  39.  * possible to release a modified version which carries forward this
  40.  * exception.
  41.  *
  42.  * $Header: /cvsroot/nsnam/nam-1/editview.cc,v 1.36 2007/02/12 07:08:43 tom_henderson Exp $
  43.  */
  45. #include <stdlib.h>
  46. #ifdef WIN32
  47. #include <windows.h>
  48. #endif
  50. #include <ctype.h>
  51. #include <math.h>
  53. #include "view.h"
  54. #include "bbox.h"
  55. #include "netmodel.h"
  56. #include "editview.h"
  57. #include "tclcl.h"
  58. #include "paint.h"
  59. #include "tag.h"
  60. #include "node.h"
  61. #include "edge.h"
  62. #include "agent.h"
  64. void EditView::DeleteCmdProc(ClientData cd)
  65. {
  66. EditView *ev = (EditView *)cd;
  67. if (ev->tk_ != NULL) {
  68. Tk_DestroyWindow(ev->tk_);
  69. }
  70. }
  72. //----------------------------------------------------------------------
  73. //----------------------------------------------------------------------
  74. EditView::EditView(const char *name, NetModel* m) 
  75.         : NetView(name), defTag_(NULL)
  76. {
  77. if (tk_!=0) {
  78. Tcl& tcl = Tcl::instance();
  79. cmd_ = Tcl_CreateCommand(tcl.interp(), Tk_PathName(tk_), 
  80.  command, 
  81.  (ClientData)this, DeleteCmdProc);
  82. }
  83. char str[256];
  84. model_ = m;
  85. sprintf(str, "def%-u", (long)this);
  86. defTag_ = new Tag(str);
  87. model_->add_tag(defTag_);
  88. editing_stage_ = NONE;
  89. }
  91. //----------------------------------------------------------------------
  92. // EditView::EditView(const char *name, NetModel* m,
  93. //                    int width, int height)
  94. //----------------------------------------------------------------------
  95. EditView::EditView(const char *name, NetModel* m, int width, int height)
  96.   : NetView(name, SQUARE, width, height), defTag_(NULL) {
  98. char str[256];
  100. if (tk_!=0) {
  101. Tcl& tcl = Tcl::instance();
  102. cmd_ = Tcl_CreateCommand(tcl.interp(), Tk_PathName(tk_),
  103.                          command, (ClientData) this,
  104.                          DeleteCmdProc);
  105. }
  107. model_ = m;
  108. sprintf(str, "def%-u", (long)this);
  109. defTag_ = new Tag(name);
  110. model_->add_tag(defTag_);
  111. editing_stage_ = NONE;
  112. }
  114. EditView::~EditView()
  115. {
  116. model_->remove_view(this);
  117. if (defTag_ != NULL) {
  118. model_->delete_tag(defTag_->name());
  119. delete defTag_;
  120. defTag_ = NULL;
  121. }
  122. // Delete Tcl command created
  123. //   Tcl& tcl = Tcl::instance();
  124. //   Tcl_DeleteCommandFromToken(tcl.interp(), cmd_);
  125. }
  127. //----------------------------------------------------------------------
  128. // int 
  129. // EditView::command(ClientData cd, Tcl_Interp* tcl,
  130. //                   int argc, char **argv)
  131. //    Parse Tcl command interface
  132. //      - setPoint, addNode, addLink addAgent, deleteObject, etc...
  133. //----------------------------------------------------------------------
  134. int EditView::command(ClientData cd, Tcl_Interp* tcl,
  135.                       int argc, CONST84 char **argv) {
  136.   EditorNetModel * editor_net_model;
  137.   Node * node, * source, * destination;
  138.   Edge * edge;
  139.   Agent * source_agent, * destination_agent;
  140.   TrafficSource * traffic_source;
  141.   LossModel * loss_model;
  142.   //double world_x, world_y;
  143.   
  144.   if (argc < 2) {
  145.     Tcl_AppendResult(tcl, """, argv[0], "": arg mismatch", 0);
  146.     return (TCL_ERROR);
  147.   }
  149.   char c = argv[1][0];
  150.   int length = strlen(argv[1]);
  151.   EditView * ev = (EditView *) cd;
  152.   editor_net_model = (EditorNetModel *) ev->model_;
  154.   float cx, cy;
  155.   int flag;
  157.   // Following implements several useful interactive commands of 
  158.   // Tk's canvas. Their syntax and semantics are kept as close to
  159.   // those of Tk canvas as possible.
  161.   if ((c == 'd') && (strncmp(argv[1], "draw", length) == 0)) {
  162.     // Redraw seen at time = argv[2]
  163.     ev->draw(strtod(argv[2],NULL));
  164.     return TCL_OK;
  166.   } else if ((c == 'c') && (strncmp(argv[1], "close", length) == 0)) {
  167.     ev->destroy();
  168.     return TCL_OK;
  170.   } else if ((c == 'd') &&
  171.              (strncmp(argv[1], "dctag", length) == 0)) {
  172.     /*
  173.      * <view> dctag
  174.      * 
  175.      * Delete the current selection, start all over.
  176.      */
  177.     if (ev->defTag_ != NULL)
  178.       ev->defTag_->remove();
  179.     ev->draw();
  180.     return (TCL_OK);
  182.   } else if ((c == 's') &&
  183.              (strncmp(argv[1], "setPoint", length) == 0)) {
  184.     /*
  185.      * <view> setPoint x y addFlag
  186.      * 
  187.      * Select the object (if any) under point (x, y). If no such
  188.      * object, set current point to (x, y)
  189.      */
  190.     if (argc != 5) {
  191.       Tcl_AppendResult(tcl, "wrong # args: should be "",
  192.                             argv[0], " setPoint x y addFlag"", 
  193.                             (char *)NULL);
  194.       return (TCL_ERROR);
  195.     }
  196.     cx = strtod(argv[2], NULL);
  197.     cy = strtod(argv[3], NULL);
  198.     flag = strtol(argv[4], NULL, 10);
  199.     return ev->cmdSetPoint(cx, cy, flag);
  201.   } else if ((c == 'd') && (strncmp(argv[1], "deleteObject", length) == 0)) { 
  202.     cx = strtod(argv[2], NULL);
  203.     cy = strtod(argv[3], NULL);
  204.     return  ev->cmdDeleteObj(cx, cy);
  206.   } else if ((c == 'm') && (strncmp(argv[1], "moveTo", length) == 0)) { 
  207.     /*
  208.      * <view> moveto x y
  209.      * 
  210.      * Move the current selected object (if any) or the 
  211.      * rubber band to point (x, y)
  212.      */
  213.     if (argc != 4) {
  214.       Tcl_AppendResult(tcl, "wrong # args: should be "",
  215.                              argv[0],
  216.                             " moveTo x y"", (char *)NULL);
  217.       return (TCL_ERROR);
  218.     }
  219.     cx = strtod(argv[2], NULL);
  220.     cy = strtod(argv[3], NULL);
  221.     return ev->cmdMoveTo(cx, cy);
  223.   } else if ((c == 'r') && (strncmp(argv[1], "releasePoint", length) == 0)) {
  224.     /*
  225.      * <view> releasePoint x y
  226.      * 
  227.      * If any object is selected, set the object's
  228.      * position to point (x,y); otherwise set the rubber
  229.      * band rectangle and select all the objects in that
  230.      * rectangle Note: we need a default tag for the
  231.      * selection in rubber band.  
  232.      */
  233.     if (argc != 4) {
  234.       Tcl_AppendResult(tcl, "wrong # args: should be "",
  235.            argv[0],
  236.            " releasePoint x y"", (char *)NULL);
  237.       return (TCL_ERROR);
  238.     }
  239.     cx = strtod(argv[2], NULL);
  240.     cy = strtod(argv[3], NULL);
  241.     return ev->cmdReleasePoint(cx, cy);
  244.   } else if ((c == 's') && (strncmp(argv[1], "setNodeProperty", length) == 0)) {
  245.     // <view> setNodeProperty nodeid nodepropertyvalue properyname
  246.     int nodeid = atoi(argv[2]);
  247.     return ev->cmdsetNodeProperty(nodeid, argv[3], argv[4]);
  249.   } else if ((c == 's') && (strncmp(argv[1], "setAgentProperty", length) == 0)) {
  250.      // <view> setAgentProperty nodeid nodepropertyvalue properyname
  251.     int agentid = atoi(argv[2]);
  252.     return ev->cmdsetAgentProperty(agentid, argv[3], argv[4]);
  254.   } else if ((c == 's') && (strncmp(argv[1], "setLinkProperty", length) == 0)) {
  255.     // <view> setLinkProperty sid did propertyvalue properyname
  256.     int source_id = atoi(argv[2]);
  257.     int destination_id = atoi(argv[3]);
  258.     return ev->cmdsetLinkProperty(source_id, destination_id,
  259.                                   argv[4], argv[5]);
  260.   } else if ((c == 's') &&
  261.              (strncmp(argv[1], "setQueueHandleProperty", length) == 0)) {
  262.     // Called by the following code in Editor.tcl
  263.     // ------------------------------------------------------------
  264.     // $editor_view_ setQueueHandleProperty $source $destination 
  265.     //                                      $property_value 
  266.     //                                      $property_variable
  267.     //
  268.     //  - argv[2] = source
  269.     //  - argv[3] = destination
  270.     //  - argv[4] = value
  271.     //  - argv[5] = variable name
  273.     editor_net_model->setQueueHandleProperty(atoi(argv[2]), atoi(argv[3]),
  274.                                               argv[4], argv[5]);
  276.     ev->draw();
  277.     return TCL_OK;
  279.   } else if ((c == 's') &&
  280.              (strncmp(argv[1], "setTrafficSourceProperty", length) == 0)) {
  281.     // <view> setTrafficSourceProperty id propertyvalue propertyname
  282.     int id = atoi(argv[2]);
  283.     const char * value = argv[3];
  284.     const char * variable_name = argv[4];
  285.     return ev->cmdsetTrafficSourceProperty(id, value, variable_name);
  286.  
  287.   } else if ((c == 's') &&
  288.              (strncmp(argv[1], "setLossModelProperty", length) == 0)) {
  289.     // <view> setLossModelProperty id propertyvalue propertyname
  290.     int id = atoi(argv[2]);
  291.     const char * value = argv[3];
  292.     const char * variable_name = argv[4];
  293.     return ev->cmdsetLossModelProperty(id, value, variable_name);
  295.   } else if ((c == 'a') && (strncmp(argv[1], "addNode", length) == 0)) {
  296.     // <view> addNode x y
  297.     //   - add a new Node under current (x,y) with default size
  298.     cx = strtod(argv[2], NULL);
  299.     cy = strtod(argv[3], NULL);
  300.     return ev->cmdaddNode(cx, cy);
  302.   } else if ((c == 'i') && (strncmp(argv[1], "importNode", length) == 0)) {
  303.     // Used when reading a nam editor file to add a node created in tcl
  304.     // to this editview and its editornetmodel
  306.     node = (Node *) TclObject::lookup(argv[2]);
  307.     //world_x = atof(argv[3]);
  308.     //world_y = atof(argv[4]);
  310.     if (node) {
  311.       if (editor_net_model->addNode(node)) {
  312.      //   node->place(world_x, world_y);
  313.      //   ev->draw();
  314.         return TCL_OK;
  315.       }
  316.     }
  318.     fprintf(stderr, "Error creating node.n");
  319.     return TCL_ERROR;
  321.   } else if ((c == 'a') && (strncmp(argv[1], "attachNodes", length) == 0)) {
  322.     // <view> linkNodes source_id destination_id
  323.     //   - link 2 existing nodes to each other
  325.     edge = (Edge *) TclObject::lookup(argv[2]);
  326.     source = (Node *) TclObject::lookup(argv[3]);
  327.     destination = (Node *) TclObject::lookup(argv[4]);
  328.     edge->attachNodes(source, destination);
  329.     editor_net_model->addEdge(edge);
  331.     ev->draw();  
  332.     return TCL_OK;
  334.   } else if ((c == 'a') && (strncmp(argv[1], "addLink", length) == 0)) {
  335.     //  <view> addLink x y 
  336.     //    - add a new Link if its start AND end point is inside of 
  337.     cx = strtod(argv[2], NULL);
  338.     cy = strtod(argv[3], NULL);
  339.     return ev->cmdaddLink(cx, cy);
  341.   } else if ((c == 'a') && (strncmp(argv[1], "addQueueHandle", length) == 0)) {
  342.     //  <view> addQueueHandle edge queue_type
  343.     edge = (Edge *) TclObject::lookup(argv[2]);
  344.     if (edge) {
  345.       editor_net_model->addQueueHandle(edge, argv[3]);
  346.     }
  347.     return TCL_OK;
  348.     
  350.   
  351.   // --------------- Agent -----------------
  352.   } else if ((c == 'a') && (strncmp(argv[1], "addAgent", length) == 0)) {
  353.     // <view> addAgent x y agent
  354.     //   - add a new agent
  355.     cx = strtod(argv[2], NULL);
  356.     cy = strtod(argv[3], NULL);
  357.     const char * agent_name = argv[4];
  358.     return ev->cmdaddAgent(cx, cy, agent_name);
  360.   } else if ((c == 'i') && (strncmp(argv[1], "importAgent", length) == 0)) {
  361.     source_agent = (Agent *) TclObject::lookup(argv[2]);
  362.     node = (Node *) TclObject::lookup(argv[3]);
  363.     return editor_net_model->addAgent(source_agent, node);
  365.   } else if ((c == 'l') && (strncmp(argv[1], "linkAgents", length) == 0)) {
  366.     // <view> linkAgents source_id destination_id
  367.     //   - link 2 existing agents to each other
  368.     source_agent = (Agent *) TclObject::lookup(argv[2]);
  369.     destination_agent = (Agent *) TclObject::lookup(argv[3]);
  370.     return editor_net_model->addAgentLink(source_agent, destination_agent);
  372.   } else if ((c == 's') && (strncmp(argv[1], "showAgentLink", length) == 0)) {
  373.     cx = strtod(argv[2], NULL);
  374.     cy = strtod(argv[3], NULL);
  375.     return ev->showAgentLink(cx, cy);
  377.   } else if ((c == 'h') && (strncmp(argv[1], "hideAgentLinks", length) == 0)) {
  378.     editor_net_model->hideAgentLinks();
  379.     ev->draw();
  380.     return TCL_OK;
  381.  
  382.   // --------------- Traffic Source -----------------
  383.   } else if ((c == 'a') &&
  384.              (strncmp(argv[1], "addTrafficSource", length) == 0)) {
  385.     // <view> addTrafficSource x y trafficsource_type
  386.     //   -  add a new TrafficSource
  387.     cx = strtod(argv[2], NULL);
  388.     cy = strtod(argv[3], NULL);
  389.     // argv[4] is the name of the traffic source
  390.     return ev->cmdaddTrafficSource(cx, cy, argv[4]);
  392.   } else if ((c == 'a') &&
  393.              (strncmp(argv[1], "attachTrafficSource", length) == 0)) {
  394.     traffic_source = (TrafficSource *) TclObject::lookup(argv[2]);
  395.     source_agent = (Agent *) TclObject::lookup(argv[3]);
  396.     return editor_net_model->addTrafficSource(traffic_source, source_agent);
  399.   // ----------- Loss Models ----------------
  400.   } else if ((c == 'a') &&
  401.              (strncmp(argv[1], "addLossModel", length) == 0)) {
  402.     // <view> addLossModel x y lossmodel
  403.     cx = strtod(argv[2], NULL);
  404.     cy = strtod(argv[3], NULL);
  405.     // argv[4] is the type of the loss model to add
  406.     return ev->cmdaddLossModel(cx, cy, argv[4]);
  408.   } else if ((c == 'a') &&
  409.              (strncmp(argv[1], "attachLossModel", length) == 0)) {
  410.     loss_model = (LossModel *) TclObject::lookup(argv[2]);
  411.     source = (Node *) TclObject::lookup(argv[3]);
  412.     destination = (Node *) TclObject::lookup(argv[4]);
  414.     edge = source->find_edge(destination->number());
  415.     return editor_net_model->addLossModel(loss_model, edge);
  417.   
  418.   // ----------- Object and Object Properties ----------------
  419.   } else if ((c == 'g') &&
  420.              (strncmp(argv[1], "getObjectInformation", length) == 0)) {
  421.  
  422.     // <view> getObject x y
  423.     //   - return object under current point
  425.     cx = strtod(argv[2], NULL);
  426.     cy = strtod(argv[3], NULL);
  428.     return ev->cmdgetObjectInformation(cx, cy);
  430.   } else if ((c == 'g') &&
  431.              (strncmp(argv[1], "getObjectProperty", length) == 0)) {
  432.     // <view> getObjectPropert x y [type]
  433.     //  - return properties for object under current point
  434.     //  - if type is passed in then pass that to object
  436.     cx = strtod(argv[2], NULL);
  437.     cy = strtod(argv[3], NULL);
  439.     if (argc == 5) {
  440.       return ev->cmdgetObjectProperties(cx, cy, argv[4]);
  441.     } else {
  442.       return ev->cmdgetObjProperty(cx, cy);
  443.     }
  446.   } else if ((c == 'v') && (strncmp(argv[1], "view_mode", length)==0)) {
  447.     /*
  448.      * <view> view_mode
  449.      * 
  450.      * clear defTag_ and change to view mode
  451.      */
  452.     ev->view_mode();
  453.     return TCL_OK;
  454.   }
  456.   return (NetView::command(cd, tcl, argc, argv));
  457. }
  459. int EditView::cmdsetNodeProperty(int id, const char * value, const char * variable)
  460. {
  461. EditorNetModel* emodel_ = (EditorNetModel *) model_;
  462.   // goto enetmodel.cc
  463. emodel_->setNodeProperty(id, value, variable);
  465. // EditType oldt_;
  466. // oldt_ = editing_stage_;
  467. // editing_stage_ = END_OBJECT;
  468. draw();
  469. // editing_stage_ = NONE;
  470. // model_->update(model_->now());
  471. // editing_stage_ = oldt_;
  473. return(TCL_OK);
  474. }
  476. int EditView::cmdsetAgentProperty(int id, const char * value, const char * variable) {
  477. EditorNetModel* emodel_ = (EditorNetModel *) model_;
  478. emodel_->setAgentProperty(id, value ,variable);
  479. draw();  
  480. return(TCL_OK);
  481. }
  484. int EditView::cmdsetLinkProperty(int sid, int did,
  485.                                  const char * value, const char * variable) {
  486.   EditorNetModel * emodel_ = (EditorNetModel *) model_;
  487.   emodel_->setLinkProperty(sid, did, value, variable);
  488.   draw();
  489.   return(TCL_OK);
  490. }
  492. //----------------------------------------------------------------------
  493. // int
  494. // EditView::cmdsetTrafficSourceProperty(int sid, int did, const char *pv, int pn)
  495. //----------------------------------------------------------------------
  496. int
  497. EditView::cmdsetTrafficSourceProperty(int id, const char * value, const char * variable) {
  498.   EditorNetModel* emodel_ = (EditorNetModel *) model_;
  499.   emodel_->setTrafficSourceProperty(id, value, variable);
  500.   draw();
  501.   return(TCL_OK);
  502. }        
  504. //----------------------------------------------------------------------
  505. // int
  506. // EditView::cmdsetLossModelProperty(int id, char * value, char * variable) 
  507. //----------------------------------------------------------------------
  508. int
  509. EditView::cmdsetLossModelProperty(int id, const char * value, const char * variable) {
  510.   EditorNetModel* emodel_ = (EditorNetModel *) model_;
  511.   emodel_->setLossModelProperty(id, value, variable);
  512.   draw();
  513.   return(TCL_OK);
  514. }        
  516. //----------------------------------------------------------------------
  517. // int 
  518. // EditView::cmdgetObjProperty(float cx, float cy)
  519. //   - get properties for a selected object
  520. //----------------------------------------------------------------------
  521. int 
  522. EditView::cmdgetObjProperty(float cx, float cy) { 
  523. Animation *p;
  524. Tcl& tcl = Tcl::instance();
  526. // matrix_ comes from class View (view.h)
  527. //  - imap is the inverse mapping
  528. //    (i.e from screen to world coordinate systems)
  529. matrix_.imap(cx, cy);
  531. // Finds the object which contains the coordinate (cx, cy)
  532. p = model_->inside(cx, cy);
  534. if (p == NULL) {
  535.    tcl.resultf("NONE");
  536. } else {
  537.    tcl.resultf("%s",p->property());
  538.   }
  539. return(TCL_OK);
  540. }
  543. //----------------------------------------------------------------------
  544. // int 
  545. // EditView::cmdgetObjectProperties(float cx, float cy, char * type)
  546. //   - get properties for a selected object and the specific 
  547. //     type within that object
  548. //----------------------------------------------------------------------
  549. int 
  550. EditView::cmdgetObjectProperties(float cx, float cy, const char * type) { 
  551. Animation * animation_object;
  552. Tcl& tcl = Tcl::instance();
  554. // matrix_ comes from class View (view)
  555. //  - imap is the inverse mapping
  556. //    (i.e from screen to world coordinate systems)
  557. matrix_.imap(cx, cy);
  559. // Finds the object which contains the coordinate (cx, cy)
  560. animation_object = model_->inside(cx, cy);
  562. if (animation_object == NULL) {
  563.    tcl.resultf("NONE");
  564. } else {
  565.    tcl.resultf("%s",animation_object->getProperties(type));
  566. }
  567. return(TCL_OK);
  568. }
  570. //----------------------------------------------------------------------
  571. //----------------------------------------------------------------------
  572. int EditView::cmdgetObjectInformation(float cx, float cy) { 
  573. Tcl& tcl = Tcl::instance();
  574. matrix_.imap(cx, cy);
  575. Animation *p = model_->inside(cx, cy);
  577. if (p == NULL) {
  578. tcl.resultf("NONE");
  579. } else {
  580. tcl.resultf("%s",p->info());
  581. }
  582. return(TCL_OK);
  583. }
  586. //----------------------------------------------------------------------
  587. // int
  588. // EditView::cmdaddLink(float cx, float cy)
  589. //   - Note: all cx_ and cy_ below are in *window* coordinates
  590. //----------------------------------------------------------------------
  591. int
  592. EditView::cmdaddLink(float cx, float cy) {
  593.   Animation * p;
  594.   static Animation * old_p;
  595.   EditorNetModel* emodel_ = (EditorNetModel *) model_;
  597.   cx_ = cx;
  598.   cy_ = cy;
  599.   matrix_.imap(cx, cy);
  601.   // Do we have a node  on current point ?
  602.   p = model_->inside(cx, cy);
  604.   if (p == NULL) {
  605.     defTag_->remove();
  606.     if (editing_stage_ == START_LINK) {
  607.        editing_stage_ = NONE;
  608.       draw();
  609.     }
  610.     return (TCL_OK);
  611.   }
  613.   if (p->classid() == ClassNodeID) {
  615.     if (editing_stage_ != START_LINK) {
  616.       old_p = p;                /* remember the orig node */
  617.       startSetObject(p, cx_, cy_);
  618.       editing_stage_ = START_LINK;
  620.      } else if ((old_p == p)||(old_p->classid()!=ClassNodeID)) {
  621.        editing_stage_ = NONE;
  622.        draw();
  623.        // to support making link by click-&-click 
  624.        editing_stage_ = START_LINK; 
  626.      } else {
  627.        // add a new link b/w the two nodes
  628.        startSetObject(p, cx_, cy_);
  630.        Node *src, *dst;
  631.        src = (Node *)old_p;
  632.        dst = (Node *)p;
  633.        emodel_->addLink(src, dst);
  634.        editing_stage_ = END_OBJECT;
  635.      
  636.        // Erase old positions
  637.        defTag_->draw(this, model_->now());
  638.        // At least we should redo scale estimation and
  639.        // place everything
  640.        defTag_->move(this, rb_.xmax - oldx_, rb_.ymax - oldy_);
  641.        model_->recalc();
  642.        model_->render(this);
  643.        defTag_->remove();
  644.        editing_stage_ = NONE;
  645.        draw();
  646.        editing_stage_ = NONE;
  647.      }
  649.   } else if (p->classid() == ClassAgentID) {
  650.     if (editing_stage_ != START_LINK) {
  651.       old_p = p;
  652.       startSetObject(p, cx_, cy_);
  653.       editing_stage_ = START_LINK;
  654.     } else if ((old_p == p)||(old_p->classid()!= ClassAgentID)) {
  655.       editing_stage_ = NONE;
  656.       draw();
  657.       // to support making agent-link by click-&-click
  658.       editing_stage_ = START_LINK;
  659.     } else {
  660.       startSetObject(p, cx_, cy_);
  662.       Agent *src_agent, *dst_agent;
  663.       src_agent = (Agent *)old_p;
  664.       dst_agent = (Agent *)p;
  665.       emodel_->addAgentLink(src_agent, dst_agent);
  666.       editing_stage_ = END_OBJECT;
  668.       defTag_->draw(this, model_->now());
  669.       defTag_->move(this, rb_.xmax - oldx_, rb_.ymax - oldy_);
  670.       model_->recalc();
  671.       model_->render(this);
  672.       defTag_->remove();
  673.       editing_stage_ = NONE;
  674.       draw();
  675.     }
  676.   } else {
  677.     editing_stage_ = NONE;
  678.   }
  679.   return(TCL_OK);
  680. }
  683. //----------------------------------------------------------------------
  684. // int 
  685. // EditView::cmdaddAgent(float cx, float cy, char* agent)
  686. //----------------------------------------------------------------------
  687. int EditView::cmdaddAgent(float cx, float cy, const char* agent) {
  688.   Animation * p;
  689.   Node * src;
  690.   EditorNetModel* emodel_ = (EditorNetModel *)model_;
  692.   // Switch from screen coordinates to world coordinates
  693.   matrix_.imap(cx, cy);
  695.   // Do we have a node on the clicked point ?
  696.   p = model_->inside(cx, cy);
  697.   if (p == NULL) {
  698.     defTag_->remove();
  699.     return (TCL_OK);
  700.   } 
  702.   if (p->classid() == ClassNodeID) {
  703.     // Yes, we have a node to which we can add the agent
  704.     src = (Node *) p;
  705.     // goto EditorNetModel::addAgent(...) in enetmodel.cc
  706.     emodel_->addAgent(src, agent, cx, cy);
  707.     draw();
  708.   } else {
  709.     return (TCL_OK);
  710.   }
  711.   return(TCL_OK);
  712. }
  714. //----------------------------------------------------------------------
  715. // int EditView::showAgentLink(float cx, float cy)
  716. //----------------------------------------------------------------------
  717. int EditView::showAgentLink(float cx, float cy) {
  718. Animation * animation;
  719. Agent * agent;
  721. // Change from screen coordinates to worl coordinates
  722. matrix_.imap(cx, cy);
  724. // Get the clicked on animation object.
  725. animation = model_->inside(cx, cy);
  727. if (animation != NULL && animation->classid() == ClassAgentID) {
  728. agent = (Agent *) animation;
  729. agent->showLink();
  730. draw();
  731. }
  733. return(TCL_OK);
  734. }
  736. //----------------------------------------------------------------------
  737. // int 
  738. // EditView::cmdaddNode(float cx, float cy)
  739. //   Note: all cx_ and cy_ below are in *window* coordinates
  740. //----------------------------------------------------------------------
  741. int EditView::cmdaddNode(float cx, float cy) {
  742.   Animation * animation_object;
  743.   EditorNetModel* emodel_ = (EditorNetModel *)model_;
  745.   // Convert screen coordinates to world coordinates
  746.   matrix_.imap(cx, cy);
  748.   // Check to see if an object already exists on the click point
  749.   animation_object = model_->inside(cx,cy);
  750.   if (animation_object == NULL) {
  751.     defTag_->remove();
  752.     emodel_->addNode(cx, cy);
  753.     draw();
  754.   } 
  755.   return(TCL_OK);
  756. }
  758. //----------------------------------------------------------------------
  759. // int
  760. // EditView::cmdDeleteObj(float cx, float cy)
  761. //----------------------------------------------------------------------
  762. int
  763. EditView::cmdDeleteObj(float cx, float cy) {
  764.   Animation * p;  // I don't know why p was chosen for the varible name
  765.                   // Just to confuse other programmers, I guess
  766.   
  767.   // First of all, clear the old point 
  768.   cx_ = cx;
  769.   cy_ = cy;
  770.                 
  771.   // Do we have an animation object on the clicked point?
  772.   matrix_.imap(cx, cy);
  773.   p = model_->inside(cx, cy);
  774.   if (p == NULL) {
  775.     defTag_->remove();
  776.     return (TCL_OK);
  777.   }       
  778.   
  779.   // If object is already selected unselect it
  780.   if (p->isTagged()) {
  781.     if (p->numTag() > 1) {
  782.       fprintf(stderr, "Error: More than one tag for an object %d!n",
  783.                        p->id());
  784.       p = NULL;
  785.     } else {
  786.       p = p->getLastTag();
  787.     }
  788.   }
  790.   // Only nodes, links, agents, traffic sources and
  791.   // loss models can be deleted
  792.   if ((p->classid() != ClassNodeID) &&
  793.       (p->classid() != ClassEdgeID) &&
  794.       (p->classid() != ClassAgentID) &&
  795.       (p->classid() != ClassTrafficSourceID) &&
  796.       (p->classid() != ClassLossModelID)) {
  797.     p = NULL;
  798.   }
  800.   if (p == NULL) {
  801.     defTag_->remove();
  802.   } else {
  803.     if (p->classid() == ClassNodeID) {
  804.       Node * n = (Node *) p;
  805.       EditorNetModel * emodel_ = (EditorNetModel *) model_;
  806.       emodel_->removeNode(n);
  807.       draw();
  808.     } 
  809.     if (p->classid() == ClassEdgeID) {
  810.       Edge * e = (Edge *) p;
  811.       EditorNetModel * emodel_ = (EditorNetModel *) model_;
  812.       emodel_->removeLink(e);
  813.       draw();
  814.     } 
  815.     if (p->classid() == ClassAgentID) {
  816.       Agent * a = (Agent *) p;
  817.       EditorNetModel* emodel_ = (EditorNetModel *) model_;
  818.       emodel_->removeAgent(a);
  819.       draw();
  820.     }
  821.     if (p->classid() == ClassTrafficSourceID) {
  822.       TrafficSource * ts = (TrafficSource *) p;
  823.       EditorNetModel* emodel_ = (EditorNetModel *) model_;
  824.       emodel_->removeTrafficSource(ts);
  825.       draw();
  826.     }
  827.     if (p->classid() == ClassLossModelID) {
  828.       LossModel * lossmodel = (LossModel *) p;
  829.       EditorNetModel* emodel_ = (EditorNetModel *) model_;
  830.       emodel_->removeLossModel(lossmodel);
  831.       draw();
  832.     }
  834.   }
  836.   return (TCL_OK);
  837. }
  839. //----------------------------------------------------------------------
  840. // int 
  841. // EditView::cmdaddTrafficSource(float cx, float cy, char * type)
  842. //----------------------------------------------------------------------
  843. int
  844. EditView::cmdaddTrafficSource(float cx, float cy, const char * type) {
  845.   Animation * object;
  846.   Agent * agent;
  847.   EditorNetModel* emodel_ = (EditorNetModel *)model_;
  849.   // Switch from screen coordinates to world coordinates
  850.   matrix_.imap(cx, cy);
  852.   // Do we have an agent on the clicked point ?
  853.   object = model_->inside(cx, cy);
  854.   if (object == NULL) {
  855.     defTag_->remove();
  856.     return (TCL_OK);
  857.   } 
  859.   if (object->classid() == ClassAgentID) {
  860.     // Yes, we have a node to which we can add the agent
  861.     agent = (Agent *) object;
  862.     // goto EditorNetModel::addTrafficSource(...) in enetmodel.cc
  863.     emodel_->addTrafficSource(agent, type, cx, cy);
  864.     draw();
  865.   } else {
  866.     return (TCL_OK);
  867.   }
  868.   return(TCL_OK);
  869. }
  871. //----------------------------------------------------------------------
  872. // int 
  873. // EditView::cmdaddLossModel(float cx, float cy, char * type)
  874. //----------------------------------------------------------------------
  875. int
  876. EditView::cmdaddLossModel(float cx, float cy, const char * type) {
  877. Animation * object;
  878. Node * source, * destination;
  879. Edge * edge, * reverse_edge;
  880. EditorNetModel* emodel_ = (EditorNetModel *) model_;
  882. // Switch from screen coordinates to world coordinates
  883. matrix_.imap(cx, cy);
  885. // Do we have a link on the clicked point ?
  886. object = model_->inside(cx, cy);
  887. if (object == NULL) {
  888. defTag_->remove();
  889. return (TCL_OK);
  890. } 
  892. if (object->classid() == ClassEdgeID ||
  893. object->classid() == ClassQueueHandleID ) {
  894. //
  895. // Yes, we have a possible edge to which we can add the loss model
  897. if (object->classid() == ClassQueueHandleID ) {
  898. edge = ((QueueHandle *) object)->getEdge();
  899. } else {
  900. edge = (Edge *) object;
  901. }
  903. if (edge) {
  904. // Check distance to source to determine if we should attach 
  905. // to the forward or reverse edge
  906. source = edge->getSourceNode();
  907. destination = edge->getDestinationNode();
  909. if (source->distance(cx, cy) > destination->distance(cx,cy)) {
  910. // if source is farther away than destination then place
  911. // this loss model on the reverse edge
  912. reverse_edge = emodel_->lookupEdge(destination->number(), source->number());
  913. if (reverse_edge) { // Make sure there is a reverse edge
  914. edge = reverse_edge;
  915. }
  916. }
  918. // goto EditorNetModel::addTrafficSource(...) in enetmodel.cc
  919. emodel_->addLossModel(edge, type, cx, cy);
  920. draw();
  921. }
  922. }
  924. return(TCL_OK);
  925. }
  927. // ---------------------------------------------------------------------
  928. // int 
  929. // EditView::cmdSetPoint(float cx, float cy, int bAdd)
  930. //   - Note: all cx_ and cy_ below are in *window* coordinates
  931. // ---------------------------------------------------------------------
  932. int 
  933. EditView::cmdSetPoint(float cx, float cy, int add_object) {
  934.   Animation * animation_object;
  935.   // First of all, clean the old group
  936.   cx_ = cx;
  937.   cy_ = cy;
  939.   // Inverse Map cx, cy to world coordinates
  940.   matrix_.imap(cx, cy);
  942.   // Do we have anything on current point?
  943.   animation_object = model_->inside(cx, cy);
  945.   // If nothing at this point start selection rubberband
  946.   if (animation_object == NULL) {
  947.     defTag_->remove();
  948.     startRubberBand(cx_, cy_);
  949.     return (TCL_OK);
  950.   }
  952.   // Otherwise look to move object if it is a node or a Tag
  953.   //   - A tag is a grouping marker, if an object is tagged then
  954.   //     that tag group can be moved together
  955.   if (animation_object->isTagged()) {
  956.     if (animation_object->numTag() > 1) {
  957.       fprintf(stderr, "Error: More than one tag for object %d!n",
  958.                        animation_object->id());
  959.       animation_object = NULL;
  960.     } else {
  961.       animation_object = animation_object->getLastTag();
  962.     }
  963.   }
  964.   
  965.   // Only nodes and tags can be moved
  966.   if ((animation_object->classid() == ClassNodeID) ||
  967.       (animation_object->classid() == ClassTagID)) {
  968.     
  969.     // If a single non-tag object is selected, or explicitly 
  970.     // instructed, remove the previous selection.  Otherwise,
  971.     // the object under the current point will be added to the
  972.     // entire tagged selection
  973.     if (!add_object && (animation_object != defTag_)) {
  974.       defTag_->remove();
  975.     }
  977.     // Just tags the object as being selected.
  978.     // Draws a box around the tagged object
  979.     startSetObject(animation_object, cx_, cy_);
  981.   } else {
  982.     defTag_->remove();
  983.     startRubberBand(cx_, cy_);
  984.   }
  986.   return (TCL_OK);
  987. }
  989. //----------------------------------------------------------------------
  990. // int
  991. // EditView::cmdMoveTo(float cx, float cy)
  992. //   - Moves object to end location
  993. //   - Ends the rubber band selection
  994. //----------------------------------------------------------------------
  995. int EditView::cmdMoveTo(float cx, float cy) {
  996.   // cx and cy should be in screen (canvas) coordinates
  997.   cx_ = cx;
  998.   cy_ = cy;
  1000.   switch (editing_stage_) {
  1001.     case START_RUBBERBAND:
  1002.     case MOVE_RUBBERBAND:
  1003.       oldx_ = rb_.xmax;
  1004.       oldy_ = rb_.ymax;
  1005.       rb_.xmax = cx_;
  1006.       rb_.ymax = cy_;
  1007.       editing_stage_ = MOVE_RUBBERBAND;
  1008.       clip_ = rb_;
  1009.       clip_.adjust();
  1011.       if (clip_.xmin > oldx_) 
  1012.         clip_.xmin = oldx_;
  1014.       if (clip_.xmax < oldx_) 
  1015.         clip_.xmax = oldx_;
  1017.       if (clip_.ymin > oldy_) 
  1018.         clip_.ymin = oldy_;
  1020.       if (clip_.ymax < oldy_) 
  1021.         clip_.ymax = oldy_;
  1023.       break;
  1025.     case START_OBJECT:
  1026.     case MOVE_OBJECT: {
  1027.       oldx_ = rb_.xmax;
  1028.       oldy_ = rb_.ymax;
  1029.       rb_.xmax = cx_;
  1030.       rb_.ymax = cy_;
  1031.       editing_stage_ = MOVE_OBJECT;
  1032.       clip_.clear();
  1033.       defTag_->merge(clip_);
  1034.       matrix_.map(clip_.xmin, clip_.ymin);
  1035.       matrix_.map(clip_.xmax, clip_.ymax);
  1036.       clip_.adjust();
  1037.       // Actual move and final bbox computation is done in render
  1038.       break;
  1040.       case START_LINK:
  1041.       case MOVE_LINK:
  1042.         // I believe this is never reached and should be removed
  1043.         // maybe it is changed in the future
  1044.         oldx_ = rb_.xmax;
  1045.         oldy_ = rb_.ymax;
  1046.         rb_.xmax = cx_;
  1047.         rb_.ymax = cy_;
  1048.         editing_stage_ = MOVE_LINK;
  1049.         clip_ = rb_;
  1050.         clip_.adjust();
  1051.         if (clip_.xmin > oldx_)
  1052.           clip_.xmin = oldx_;
  1053.         if (clip_.xmax < oldx_)
  1054.           clip_.xmax = oldx_;
  1055.         if (clip_.ymin > oldy_)
  1056.           clip_.ymin = oldy_;
  1057.         if (clip_.ymax < oldy_)
  1058.           clip_.ymax = oldy_;
  1059.         break;
  1060.       }
  1061.     default:
  1062.       // to avoid segmentation fault from click-n-dragging
  1063.       return (TCL_OK);
  1064.   }
  1065.   draw();
  1066.   return (TCL_OK);
  1067. }
  1069. int EditView::cmdReleasePoint(float cx, float cy) {
  1070. static char buffer[512];
  1071. int chars_written;
  1073. cx_ = cx;
  1074. cy_ = cy;
  1075. Tcl & tcl = Tcl::instance();
  1077. switch (editing_stage_) {
  1078. case START_RUBBERBAND:
  1079. case MOVE_RUBBERBAND: {
  1080. oldx_ = rb_.xmax; oldy_ = rb_.ymax;
  1081. rb_.xmax = cx_, rb_.ymax = cy_;
  1082. // Need to add the region to defTag_
  1083. clip_ = rb_;
  1084. clip_.adjust();
  1085. BBox bb = clip_;
  1086. matrix_.imap(bb.xmin, bb.ymin);
  1087. matrix_.imap(bb.xmax, bb.ymax);
  1088. bb.adjust();
  1089. model_->tagArea(bb, defTag_, 1);
  1091. // We can do a total redraw
  1092. editing_stage_ = NONE;
  1093. draw();
  1095. // Get time movement info for node markers on time slider
  1096. // defTag_->addNodeMovementDestination(this, cx - oldx_, cy - oldy_, model_->now());
  1097. // chars_written = defTag_->getNodeMovementTimes(buffer, 512);
  1098. // if (chars_written == -1) {
  1099. tcl.resultf("NONE");
  1100. // } else {
  1101. // tcl.resultf("%s", buffer);
  1102. // }
  1103. break;
  1104. }
  1106. case START_OBJECT:
  1107. case MOVE_OBJECT: {
  1108. oldx_ = rb_.xmax;
  1109. oldy_ = rb_.ymax;
  1110. rb_.xmax = cx_;
  1111. rb_.ymax = cy_;
  1112. clip_.clear();
  1113. defTag_->merge(clip_);
  1114. matrix_.map(clip_.xmin, clip_.ymin);
  1115. matrix_.map(clip_.xmax, clip_.ymax);
  1116. clip_.adjust();
  1118. // Later in render() we'll compute the real bbox
  1119. editing_stage_ = END_OBJECT;
  1120. draw();
  1122. editing_stage_ = NONE;
  1123. model_->update(model_->now());
  1124. //      defTag_->move(this, rb_.xmax - oldx_, rb_.ymax - oldy_);
  1126. // Get time movement info for node markers on time slider
  1127. defTag_->addNodeMovementDestination(this, cx - oldx_, cy - oldy_, model_->now());
  1128. chars_written = defTag_->getNodeMovementTimes(buffer, 512);
  1129. if (chars_written == -1) {
  1130. tcl.resultf("NONE");
  1131. } else {
  1132. tcl.resultf("%s", buffer);
  1133. }
  1134. break;
  1135. }
  1137. case START_LINK:
  1138. case MOVE_LINK: {
  1139. editing_stage_ = START_LINK;
  1140. draw();
  1141. model_->update(model_->now());
  1142. cmdaddLink(cx_, cy_);
  1143. tcl.resultf("NONE");
  1144. break;
  1145. }
  1147. default:
  1148. // This cannot happen!
  1149. editing_stage_ = NONE;
  1150. draw();
  1151. tcl.resultf("NONE");
  1152. }
  1154. return (TCL_OK);
  1155. }
  1157. //----------------------------------------------------------------------
  1158. //----------------------------------------------------------------------
  1159. inline void
  1160. EditView::startRubberBand(float cx, float cy) {
  1161. // Nothing's here. Set rubber band.
  1162. editing_stage_ = START_RUBBERBAND;
  1163. rb_.xmin = rb_.xmax = cx;
  1164. rb_.ymin = rb_.ymax = cy;
  1165. clip_ = rb_;
  1166. }
  1168. //----------------------------------------------------------------------
  1169. //----------------------------------------------------------------------
  1170. inline void
  1171. EditView::startSetObject(Animation * animation_object, float cx, float cy) {
  1172. // Find an object, add it to group
  1173. editing_stage_ = START_OBJECT;
  1175. // Add it into defTag_
  1176. if (animation_object != defTag_) {
  1177. model_->tagObject(defTag_, animation_object);
  1178. }
  1180. rb_.xmin = rb_.xmax = cx;
  1181. rb_.ymin = rb_.ymax = cy;
  1182. clip_.clear();
  1183. defTag_->merge(clip_);
  1185. // for the bounding box (bbox)
  1186. oldx_ = rb_.xmax;
  1187. oldy_ = rb_.ymax;
  1188. rb_.xmax = cx_;
  1189. rb_.ymax = cy_;
  1190. clip_.clear();
  1191. defTag_->merge(clip_);
  1192. matrix_.map(clip_.xmin, clip_.ymin);
  1193. matrix_.map(clip_.xmax, clip_.ymax);
  1194. clip_.adjust();
  1196. // Later in render() we'll compute the real bbox
  1198. // We have selected the object and now we are at the end of 
  1199. // the object selection process
  1200. editing_stage_ = END_OBJECT;
  1201. draw();
  1203. editing_stage_ = NONE;
  1204. model_->update(model_->now());
  1205. editing_stage_ = START_OBJECT;
  1206. }
  1212. //----------------------------------------------------------------------
  1213. // void EditView::draw()
  1214. //----------------------------------------------------------------------
  1215. void EditView::draw() {
  1216. if (editing_stage_ == NONE) {
  1217. View::draw();
  1219. } else {
  1220. // Ignore the cleaning part
  1221. render();
  1222.  
  1223. // XXX Don't understand why clip's height and width need to 
  1224. // increase 3 to draw tagged objects correctly. 
  1225. XCopyArea(Tk_Display(tk_), offscreen_, Tk_WindowId(tk_), 
  1226.           background_,(int)clip_.xmin, (int)clip_.ymin, 
  1227.           (int)clip_.width()+3, (int)clip_.height()+3, 
  1228.           (int)clip_.xmin, (int)clip_.ymin);
  1229. }
  1230. }
  1234. //----------------------------------------------------------------------
  1235. // void EditView::draw(double current_time)
  1236. //----------------------------------------------------------------------
  1237. void EditView::draw(double current_time) {
  1238. model_->update(current_time);
  1239. }
  1241. //----------------------------------------------------------------------
  1242. //----------------------------------------------------------------------
  1243. void EditView::xline(float x0, float y0, float x1, float y1, GC gc) {
  1244.   XDrawLine(Tk_Display(tk_), offscreen_, gc, (int) x0, (int) y0,
  1245.                                              (int) x1, (int) y1);
  1246. }
  1248. // Without transform.
  1249. void EditView::xrect(float x0, float y0, float x1, float y1, GC gc)
  1250. {
  1251. int x = (int) floor(x0);
  1252. int y = (int) floor(y0);
  1253. int w = (int)(x1 - x0);
  1254. if (w < 0) {
  1255. x = (int) ceil(x1);
  1256. w = -w;
  1257. }
  1258. int h = (int)(y1 - y0);
  1259. if (h < 0) {
  1260. h = -h;
  1261. y = (int)ceil(y1);
  1262. }
  1263. XDrawRectangle(Tk_Display(tk_), offscreen_, gc, x, y, w, h);
  1264. }
  1266. void EditView::line(float x0, float y0, float x1, float y1, int color)
  1267. {
  1268. if (editing_stage_ != NONE)
  1269. View::line(x0, y0, x1, y1, Paint::instance()->Xor());
  1270. else 
  1271. View::line(x0, y0, x1, y1, color);
  1272. }
  1274. void EditView::rect(float x0, float y0, float x1, float y1, int color)
  1275. {
  1276. if (editing_stage_ != NONE)
  1277. View::rect(x0, y0, x1, y1, Paint::instance()->Xor());
  1278. else 
  1279. View::rect(x0, y0, x1, y1, color);
  1280. }
  1282. void EditView::polygon(const float* x, const float* y, int n, int color)
  1283. {
  1284. if (editing_stage_ != NONE)
  1285. View::polygon(x, y, n, Paint::instance()->Xor());
  1286. else 
  1287. View::polygon(x, y, n, color);
  1288. }
  1290. void EditView::fill(const float* x, const float* y, int n, int color)
  1291. {
  1292. if (editing_stage_ != NONE)
  1293. View::fill(x, y, n, Paint::instance()->Xor());
  1294. else 
  1295. View::fill(x, y, n, color);
  1296. }
  1298. void EditView::circle(float x, float y, float r, int color)
  1299. {
  1300. if (editing_stage_ != NONE)
  1301. View::circle(x, y, r, Paint::instance()->Xor());
  1302. else 
  1303. View::circle(x, y, r, color);
  1304. }
  1306. // Do not display any string, because no xor font gc
  1307. void EditView::string(float fx, float fy, float dim, const char* s, int anchor)
  1308. {
  1309. if (editing_stage_ == NONE)
  1310. View::string(fx, fy, dim, s, anchor);
  1311. }
  1313. //----------------------------------------------------------------------
  1314. // void
  1315. // EditView::BoundingBox(BBox &bb)
  1316. //   - This copies the area in which an animation drawn may be drawn
  1317. //     into (clipping area) the destination bb.  
  1318. //----------------------------------------------------------------------
  1319. void
  1320. EditView::BoundingBox(BBox &bb) {
  1321.   double temp;
  1322.   
  1323.   // Calculate the world coordinates for the view's canvas
  1324.   matrix_.imap(0.0, 0.0, bb.xmin, bb.ymin);
  1325.   matrix_.imap(width_, height_, bb.xmax, bb.ymax);
  1327.   // Check to make sure xmin, ymin is the lower left corner
  1328.   // and xmax, ymax is the upper right
  1329.   if (bb.xmin > bb.xmax) {
  1330.     temp = bb.xmax;
  1331.     bb.xmax = bb.xmin;
  1332.     bb.xmin = temp;
  1333.   }
  1334.   if (bb.ymin > bb.ymax) {
  1335.     temp = bb.ymax;
  1336.     bb.ymax = bb.ymin;
  1337.     bb.ymin = temp;
  1338.   }
  1339. }
  1341. void
  1342. EditView::getWorldBox(BBox &bb) {
  1343.   model_->BoundingBox(bb);
  1344. }
  1346. //----------------------------------------------------------------------
  1347. // void 
  1348. // EditView::render()
  1349. //   - not sure why this is called render but it seems to take care of 
  1350. //     rubberband selections and moving a selection on the screen
  1351. //   - I believe the real "rendering" is done in model_->render()
  1352. //     which is of type NetModel.  -- mehringe@isi.edu
  1353. //
  1354. //----------------------------------------------------------------------
  1355. void
  1356. EditView::render() {
  1357.   // Here we can compute the clipping box for render
  1358.   Paint *paint = Paint::instance();
  1359.   GC gc = paint->paint_to_gc(paint->Xor());
  1361.   switch (editing_stage_) {
  1362.     case START_RUBBERBAND:
  1363.       // draw rubber band
  1364.       xrect(rb_.xmin, rb_.ymin, rb_.xmax, rb_.ymax, gc);
  1365.       break;
  1367.     case MOVE_RUBBERBAND: 
  1368.       // erase previous rubberband
  1369.       xrect(rb_.xmin, rb_.ymin, oldx_, oldy_, gc);
  1370.       // draw new rubberband
  1371.       xrect(rb_.xmin, rb_.ymin, rb_.xmax, rb_.ymax, gc);
  1372.       break;
  1374.     case END_RUBBERBAND: 
  1375.       // erase previous rubber band
  1376.       xrect(rb_.xmin, rb_.ymin, oldx_, oldy_, gc);
  1377.       // XXX Should draw the tag?
  1378.       model_->render(this);
  1379.       editing_stage_ = NONE;
  1380.       break;
  1382.     case START_OBJECT:
  1383.       xrect(rb_.xmin, rb_.ymin, rb_.xmax, rb_.ymax, gc);
  1384.       // xor-draw all relevant objects
  1385.       defTag_->draw(this, model_->now());
  1386.       break;
  1388.     case MOVE_OBJECT: 
  1389.       // erase old positions first.
  1390.       if ((oldx_ == rb_.xmax) && (oldy_ == rb_.ymax)) 
  1391.         return;
  1392.       defTag_->draw(this, model_->now());
  1393.       // move these objects
  1394.       defTag_->move(this, rb_.xmax - oldx_, rb_.ymax - oldy_);
  1395.       BBox bb;
  1396.       bb.clear();
  1397.       defTag_->merge(bb);
  1398.       matrix_.imap(bb.xmin, bb.ymin);
  1399.       matrix_.imap(bb.xmax, bb.ymax);
  1400.       bb.adjust();
  1401.       clip_.merge(bb);
  1402.       defTag_->draw(this, model_->now());
  1403.       break;
  1405.     case END_OBJECT:
  1406.       // Erase old positions
  1407.       defTag_->draw(this, model_->now());
  1408.       // At least we should redo scale estimation and 
  1409.       // place everything
  1410.       defTag_->move(this, rb_.xmax - oldx_, rb_.ymax - oldy_);
  1411.       model_->recalc();
  1412.       model_->render(this);
  1413.       editing_stage_ = NONE;
  1414.       break;
  1416.     case START_LINK:
  1417.       line(link_start_x_, link_start_y_, link_end_x_, link_end_y_, 3);
  1418.       defTag_->draw(this, model_->now());
  1419.       break;
  1421.     case MOVE_LINK:
  1422.       // erase previous link
  1423.       xline(rb_.xmin, rb_.ymin, oldx_, oldy_, gc);
  1424.       // draw new rubberband
  1425.       xline(rb_.xmin, rb_.ymin, rb_.xmax, rb_.ymax, gc);
  1426.       break;
  1428.     case END_LINK:
  1429.       // erase previous link
  1430.       xline(rb_.xmin, rb_.ymin, oldx_, oldy_, gc);
  1431.       // XXX Should draw the tag?
  1432.       model_->render(this);
  1433.       editing_stage_ = NONE;
  1434.       break;
  1436.     default:
  1437.       // redraw model
  1438.       model_->render(this);
  1439.       break;
  1440.   }
  1441.   return;
  1442. }