COIN-OR::LEMON - Graph Library

source: glemon-0.x/graph_displayer_canvas-event.cc @ 96:e664d8aa3f72

gui
Last change on this file since 96:e664d8aa3f72 was 96:e664d8aa3f72, checked in by Hegyi Péter, 15 years ago

Notebook style is provided. Without opportunity to close tabs. :-) But with all other necessary things (I think).

  • Property exe set to *
File size: 24.0 KB
Line 
1#include "graph_displayer_canvas.h"
2#include <cmath>
3
4
5bool GraphDisplayerCanvas::on_expose_event(GdkEventExpose *event)
6{
7  Gnome::Canvas::CanvasAA::on_expose_event(event);
8  //usleep(10000);
9  //rezoom();
10  return true;
11}
12
13void GraphDisplayerCanvas::changeEditorialTool(int newtool)
14{
15  if(actual_tool!=newtool)
16    {
17
18      actual_handler.disconnect();
19
20      switch(actual_tool)
21        {
22        case CREATE_EDGE:
23          {
24            GdkEvent * generated=new GdkEvent();
25            generated->type=GDK_BUTTON_RELEASE;
26            generated->button.button=3;
27            createEdgeEventHandler(generated);     
28            break;
29          }
30        case EDGE_MAP_EDIT:
31          //has to do the same thing as in the case of NODE_MAP_EDIT
32        case NODE_MAP_EDIT:
33          {
34            break;
35          }
36        default:
37          break;
38        }
39
40      active_item=NULL;
41      target_item=NULL;
42      active_edge=INVALID;     
43      active_node=INVALID;     
44
45
46      actual_tool=newtool;
47 
48      switch(newtool)
49        {
50        case MOVE:
51          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
52          break;
53
54        case CREATE_NODE:
55          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
56          break;
57
58        case CREATE_EDGE:
59          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
60          break;
61
62        case ERASER:
63          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
64          break;
65
66        case EDGE_MAP_EDIT:
67          grab_focus();
68          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::edgeMapEditEventHandler), false);
69          break;
70
71        case NODE_MAP_EDIT:
72          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::nodeMapEditEventHandler), false);
73          break;
74
75        default:
76          break;
77        }
78    }
79}
80
81int GraphDisplayerCanvas::getActualTool()
82{
83  return actual_tool;
84}
85
86bool GraphDisplayerCanvas::moveEventHandler(GdkEvent* e)
87{
88  static Gnome::Canvas::Text *coord_text = 0;
89  switch(e->type)
90  {
91    case GDK_BUTTON_PRESS:
92      //we mark the location of the event to be able to calculate parameters of dragging
93      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
94
95      active_item=(get_item_at(clicked_x, clicked_y));
96      active_node=INVALID;
97      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
98        {
99          if(nodesmap[i]==active_item)
100            {
101              active_node=i;
102            }
103        }
104      switch(e->button.button)
105        {
106        case 3:     
107          isbutton=3;
108          break;
109        default:
110          isbutton=1;
111          break;
112        }
113      break;
114    case GDK_BUTTON_RELEASE:
115      if (coord_text)
116      {
117        delete coord_text;
118        coord_text = 0;
119      }
120      isbutton=0;
121      active_item=NULL;
122      active_node=INVALID;
123      break;
124    case GDK_MOTION_NOTIFY:
125      //we only have to do sg. if the mouse button is pressed AND the click was on a node that was found in the set of nodes
126      if(active_node!=INVALID)
127      {
128        (mytab.mapstorage).modified = true;
129
130        //new coordinates will be the old values,
131        //because the item will be moved to the
132        //new coordinate therefore the new movement
133        //has to be calculated from here
134
135        double new_x, new_y;
136
137        window_to_world (e->motion.x, e->motion.y, new_x, new_y);
138
139        double dx=new_x-clicked_x;
140        double dy=new_y-clicked_y;
141
142        //repositioning node and its text
143        active_item->move(dx, dy);
144        nodetextmap[active_node]->move(dx, dy);
145
146        // the new coordinates of the centre of the node
147        double coord_x = new_x - (clicked_x - (mytab.mapstorage).coords[active_node].x);
148        double coord_y = new_y - (clicked_y - (mytab.mapstorage).coords[active_node].y);
149
150        clicked_x=new_x;
151        clicked_y=new_y;
152
153        // write back the new coordinates to the coords map
154        (mytab.mapstorage).coords.set(active_node, xy<double>(coord_x, coord_y));
155
156        // reposition the coordinates text
157        std::ostringstream ostr;
158        ostr << "(" <<
159          (mytab.mapstorage).coords[active_node].x << ", " <<
160          (mytab.mapstorage).coords[active_node].y << ")";
161        double radius =
162          (nodesmap[active_node]->property_x2().get_value() -
163          nodesmap[active_node]->property_x1().get_value()) / 2.0;
164        if (coord_text)
165        {
166          coord_text->property_text().set_value(ostr.str());
167          coord_text->property_x().set_value((mytab.mapstorage).coords[active_node].x +
168              radius);
169          coord_text->property_y().set_value((mytab.mapstorage).coords[active_node].y -
170              radius);
171        }
172        else
173        {
174          coord_text = new Gnome::Canvas::Text(
175              displayed_graph,
176              (mytab.mapstorage).coords[active_node].x + radius,
177              (mytab.mapstorage).coords[active_node].y - radius,
178              ostr.str());
179          coord_text->property_fill_color().set_value("black");
180          coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
181        }
182
183        //all the edges connected to the moved point has to be redrawn
184        for(OutEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
185        {
186            Gnome::Canvas::Points coos;
187            double x1, x2, y1, y2;
188
189            nodesmap[(mytab.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
190            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
191
192            nodesmap[(mytab.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
193            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
194
195            if(isbutton==3)
196              {
197                edgesmap[ei]->setPoints(coos);
198              }
199            else
200              {
201                edgesmap[ei]->setPoints(coos,true);
202              }
203
204            //reposition of edgetext
205            xy<double> text_pos=edgesmap[ei]->getArrowPos();
206            text_pos+=(xy<double>(10,10));
207            edgetextmap[ei]->property_x().set_value(text_pos.x);
208            edgetextmap[ei]->property_y().set_value(text_pos.y);
209        }
210
211        for(InEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
212        {
213            Gnome::Canvas::Points coos;
214            double x1, x2, y1, y2;
215
216            nodesmap[(mytab.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
217            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
218
219            nodesmap[(mytab.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
220            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
221
222            if(isbutton==3)
223              {
224                edgesmap[ei]->setPoints(coos);
225              }
226            else
227              {
228                edgesmap[ei]->setPoints(coos,true);
229              }
230
231            xy<double> text_pos=edgesmap[ei]->getArrowPos();
232            text_pos+=(xy<double>(10,10));
233            edgetextmap[ei]->property_x().set_value(text_pos.x);
234            edgetextmap[ei]->property_y().set_value(text_pos.y);
235        }
236      }
237    default: break;
238  }
239
240  return false;
241}
242
243bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
244{
245  switch(e->type)
246  {
247    //move the new node
248    case GDK_MOTION_NOTIFY:
249      {
250        GdkEvent * generated=new GdkEvent();
251        generated->motion.x=e->motion.x;
252        generated->motion.y=e->motion.y;
253        generated->type=GDK_MOTION_NOTIFY;
254        moveEventHandler(generated);     
255        break;
256      }
257
258    case GDK_BUTTON_RELEASE:
259      (mytab.mapstorage).modified = true;
260
261      isbutton=1;
262
263      active_node=(mytab.mapstorage).graph.addNode();
264
265      //initiating values corresponding to new node in maps
266
267      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
268
269      // update coordinates
270      (mytab.mapstorage).coords.set(active_node, xy<double>(clicked_x, clicked_y));
271
272      // update all other maps
273      for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
274          (mytab.mapstorage).nodemap_storage.begin(); it !=
275          (mytab.mapstorage).nodemap_storage.end(); ++it)
276      {
277        if ((it->first != "coordinates_x") &&
278            (it->first != "coordinates_y"))
279        {
280          (*(it->second))[active_node] =
281            (mytab.mapstorage).nodemap_default[it->first];
282        }
283      }
284      // increment the id map's default value
285      (mytab.mapstorage).nodemap_default["id"] += 1.0;
286
287      nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
288          clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
289      active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
290      *(nodesmap[active_node]) <<
291        Gnome::Canvas::Properties::fill_color("blue");
292      *(nodesmap[active_node]) <<
293        Gnome::Canvas::Properties::outline_color("black");
294      active_item->raise_to_top();
295
296      (nodesmap[active_node])->show();
297
298      nodetextmap[active_node]=new Gnome::Canvas::Text(displayed_graph,
299          clicked_x+node_property_defaults[N_RADIUS]+5,
300          clicked_y+node_property_defaults[N_RADIUS]+5, "");
301      nodetextmap[active_node]->property_fill_color().set_value("darkblue");
302      nodetextmap[active_node]->raise_to_top();
303
304//       mapwin.updateNode(active_node);
305      propertyUpdate(active_node);
306
307      isbutton=0;
308      target_item=NULL;
309      active_item=NULL;
310      active_node=INVALID;
311      break;
312    default:
313      break;
314  }
315  return false;
316}
317
318bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
319{
320  switch(e->type)
321  {
322    case GDK_BUTTON_PRESS:
323      //in edge creation right button has special meaning
324      if(e->button.button!=3)
325      {
326        //there is not yet selected node
327        if(active_node==INVALID)
328        {
329          //we mark the location of the event to be able to calculate parameters of dragging
330
331          window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
332
333          active_item=(get_item_at(clicked_x, clicked_y));
334          active_node=INVALID;
335          for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
336          {
337            if(nodesmap[i]==active_item)
338            {
339              active_node=i;
340            }
341          }
342          //the clicked item is really a node
343          if(active_node!=INVALID)
344          {
345            *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
346            isbutton=1;
347          }
348          //clicked item was not a node. It could be e.g. edge.
349          else
350          {
351            active_item=NULL;
352          }
353        }
354        //we only have to do sg. if the mouse button
355        // is pressed already once AND the click was
356        // on a node that was found in the set of
357        //nodes, and now we only search for the second
358        //node
359        else
360        {
361          window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
362          target_item=(get_item_at(clicked_x, clicked_y));
363          Node target_node=INVALID;
364          for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
365          {
366            if(nodesmap[i]==target_item)
367            {
368              target_node=i;
369            }
370          }
371          //the clicked item is a node, the edge can be drawn
372          if(target_node!=INVALID)
373          {
374            if(target_node!=active_node)               
375            {
376              (mytab.mapstorage).modified = true;
377
378              *(nodesmap[target_node]) <<
379                Gnome::Canvas::Properties::fill_color("red");
380
381              //creating new edge
382              active_edge=(mytab.mapstorage).graph.addEdge(active_node,
383                  target_node);
384
385              // update maps
386              for (std::map<std::string,
387                  Graph::EdgeMap<double>*>::const_iterator it =
388                  (mytab.mapstorage).edgemap_storage.begin(); it !=
389                  (mytab.mapstorage).edgemap_storage.end(); ++it)
390              {
391                (*(it->second))[active_edge] =
392                  (mytab.mapstorage).edgemap_default[it->first];
393              }
394              // increment the id map's default value
395              (mytab.mapstorage).edgemap_default["id"] += 1.0;
396
397              //calculating coordinates of new edge
398              Gnome::Canvas::Points coos;
399              double x1, x2, y1, y2;
400
401              active_item->get_bounds(x1, y1, x2, y2);
402              coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
403
404              target_item->get_bounds(x1, y1, x2, y2);
405              coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
406
407              //drawing new edge
408              edgesmap[active_edge]=new BrokenEdge(displayed_graph, coos,
409                  *this);
410              *(edgesmap[active_edge]) <<
411                Gnome::Canvas::Properties::fill_color("green");
412              edgesmap[active_edge]->property_width_pixels().set_value(10);
413
414              edgesmap[active_edge]->lower_to_bottom();
415
416              //initializing edge-text as well, to empty string
417              xy<double> text_pos=edgesmap[active_edge]->getArrowPos();
418              text_pos+=(xy<double>(10,10));
419
420              edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph,
421                  text_pos.x, text_pos.y, "");
422              edgetextmap[active_edge]->property_fill_color().set_value(
423                  "darkgreen");
424              edgetextmap[active_edge]->raise_to_top();
425
426              //updating its properties
427//               mapwin.updateEdge(active_edge);
428              propertyUpdate(active_edge);
429            }
430            else
431            {
432              target_node=INVALID;
433              std::cerr << "Loop edge is not yet implemented!" << std::endl;
434            }
435          }
436          //clicked item was not a node. it could be an e.g. edge. we do not
437          //deal with it furthermore.
438          else
439          {
440            target_item=NULL;
441          }
442        }
443      }
444      break;
445    case GDK_BUTTON_RELEASE:
446      isbutton=0;
447      //we clear settings in two cases
448      //1: the edge is ready (target_item has valid value)
449      //2: the edge creation is cancelled with right button
450      if((target_item)||(e->button.button==3))
451      {
452        if(active_item)
453        {
454          *active_item << Gnome::Canvas::Properties::fill_color("blue");
455          active_item=NULL;
456        }
457        if(target_item)
458        {
459          *target_item << Gnome::Canvas::Properties::fill_color("blue");
460          target_item=NULL;
461        }
462        active_node=INVALID;
463        active_edge=INVALID;
464      }
465      break;
466    default:
467      break;
468  }
469  return false;
470}
471
472bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
473{
474  switch(e->type)
475    {
476    case GDK_BUTTON_PRESS:
477      //finding the clicked items
478      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
479      active_item=(get_item_at(clicked_x, clicked_y));
480      active_node=INVALID;
481      active_edge=INVALID;
482      //was it a node?
483      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
484        {
485          if(nodesmap[i]==active_item)
486            {
487              active_node=i;
488            }
489        }
490      //or was it an edge?
491      if(active_node==INVALID)
492        {
493          for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
494            {
495              if(edgesmap[i]==active_item)
496                {
497                  active_edge=i;
498                }
499            }
500        }
501
502      //recolor activated item
503      if(active_item)
504        {
505          *active_item << Gnome::Canvas::Properties::fill_color("red");
506        }
507      break;
508
509    case GDK_BUTTON_RELEASE:
510      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
511      if(active_item)
512        {
513          //the cursor was not moved since pressing it
514          if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
515            {
516              //a node was found
517              if(active_node!=INVALID)
518                {
519                  (mytab.mapstorage).modified = true;
520
521                  std::set<Graph::Edge> edges_to_delete;
522
523                  for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
524                    {
525                      edges_to_delete.insert(e);
526                    }
527                 
528                  for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
529                    {
530                      edges_to_delete.insert(e);
531                    }
532                 
533                  //deleting collected edges
534                  for(std::set<Graph::Edge>::iterator
535                        edge_set_it=edges_to_delete.begin();
536                      edge_set_it!=edges_to_delete.end();
537                      ++edge_set_it)
538                    {
539                      deleteItem(*edge_set_it);
540                    }
541                  deleteItem(active_node);
542                }
543              //a simple edge was chosen
544              else
545                {
546                  deleteItem(active_edge);
547                }
548            }
549          //pointer was moved, deletion is cancelled
550          else
551            {
552              if(active_node!=INVALID)
553                {
554                  *active_item << Gnome::Canvas::Properties::fill_color("blue");
555                }
556              else
557                {
558                  *active_item << Gnome::Canvas::Properties::fill_color("green");
559                }
560            }
561        }
562      //reseting datas
563      active_item=NULL;
564      active_edge=INVALID;
565      active_node=INVALID;
566      break;
567
568    case GDK_MOTION_NOTIFY:
569      break;
570
571    default:
572      break;
573    }
574  return false;
575}
576
577bool GraphDisplayerCanvas::edgeMapEditEventHandler(GdkEvent* e)
578{
579  if(actual_tool==EDGE_MAP_EDIT)
580  {
581    switch(e->type)
582    {
583      case GDK_BUTTON_PRESS:
584        {
585          //for determine, whether it was an edge
586          Edge clicked_edge=INVALID;
587
588          window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
589          active_item=(get_item_at(clicked_x, clicked_y));
590
591          //find the activated item between texts
592          for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
593          {
594            //at the same time only one can be active
595            if(edgetextmap[i]==active_item)
596            {
597              clicked_edge=i;
598            }
599          }
600
601          //if it was not between texts, search for it between edges
602          if(clicked_edge==INVALID)
603          {
604            for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
605            {
606              //at the same time only one can be active
607              if((edgesmap[i]==active_item)||(edgetextmap[i]==active_item))
608              {
609                clicked_edge=i;
610              }
611            }
612          }
613 
614          //if it was really an edge...
615          if(clicked_edge!=INVALID)
616          {
617            // the id map is not editable
618            if (edgemap_to_edit == "id") return 0;
619
620            //and there is activated map
621            if(edgetextmap[clicked_edge]->property_text().get_value()!="")
622            {
623              //activate the general variable for it
624              active_edge=clicked_edge;
625
626              //create a dialog
627              Gtk::Dialog dialog("Edit value", true);
628              dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
629              dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
630              Gtk::VBox* vbox = dialog.get_vbox();
631              Gtk::SpinButton spin(0.0, 4);
632              spin.set_increments(1.0, 10.0);
633              spin.set_range(-1000000.0, 1000000.0);
634              spin.set_numeric(true);
635              vbox->add(spin);
636              spin.show();
637              switch (dialog.run())
638              {
639                case Gtk::RESPONSE_NONE:
640                case Gtk::RESPONSE_CANCEL:
641                  break;
642                case Gtk::RESPONSE_ACCEPT:
643                  double new_value = spin.get_value();
644                  (*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
645                    new_value;
646                  std::ostringstream ostr;
647                  ostr << new_value;
648                  edgetextmap[active_edge]->property_text().set_value(
649                      ostr.str());
650                  //mapwin.updateEdge(active_edge);
651//                   mapwin.updateEdge(Edge(INVALID));
652                  propertyUpdate(Edge(INVALID));
653              }
654            }
655          }
656          break;
657        }
658      default:
659        break;
660    }
661  }
662  return false; 
663}
664
665bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
666{
667  if(actual_tool==NODE_MAP_EDIT)
668  {
669    switch(e->type)
670    {
671      case GDK_BUTTON_PRESS:
672        {
673          //for determine, whether it was a node
674          Node clicked_node=INVALID;
675
676          window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
677          active_item=(get_item_at(clicked_x, clicked_y));
678
679          //find the activated item between texts
680          for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
681          {
682            //at the same time only one can be active
683            if(nodetextmap[i]==active_item)
684            {
685              clicked_node=i;
686            }
687          }
688
689          //if there was not, search for it between nodes
690          if(clicked_node==INVALID)
691          {
692            for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
693            {
694              //at the same time only one can be active
695              if(nodesmap[i]==active_item)
696              {
697                clicked_node=i;
698              }
699            }
700          }
701
702          //if it was really a node...
703          if(clicked_node!=INVALID)
704          {
705            // the id map is not editable
706            if (nodemap_to_edit == "id") return 0;
707
708            //and there is activated map
709            if(nodetextmap[clicked_node]->property_text().get_value()!="")
710            {
711              //activate the general variable for it
712              active_node=clicked_node;
713
714              //create a dialog
715              Gtk::Dialog dialog("Edit value", true);
716              dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
717              dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
718              Gtk::VBox* vbox = dialog.get_vbox();
719              Gtk::SpinButton spin(0.0, 4);
720              spin.set_increments(1.0, 10.0);
721              spin.set_range(-1000000.0, 1000000.0);
722              spin.set_numeric(true);
723              vbox->add(spin);
724              spin.show();
725              switch (dialog.run())
726              {
727                case Gtk::RESPONSE_NONE:
728                case Gtk::RESPONSE_CANCEL:
729                  break;
730                case Gtk::RESPONSE_ACCEPT:
731                  double new_value = spin.get_value();
732                  (*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
733                    new_value;
734                  std::ostringstream ostr;
735                  ostr << new_value;
736                  nodetextmap[active_node]->property_text().set_value(
737                      ostr.str());
738                  //mapwin.updateNode(active_node);
739//                   mapwin.updateNode(Node(INVALID));
740                  propertyUpdate(Node(INVALID));
741              }
742            }
743          }
744          break;
745        }
746      default:
747        break;
748    }
749  }
750  return false; 
751}
752
753void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
754{
755  delete(nodetextmap[node_to_delete]);
756  delete(nodesmap[node_to_delete]);
757  (mytab.mapstorage).graph.erase(node_to_delete);
758}
759
760void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
761{
762  delete(edgetextmap[edge_to_delete]);
763  delete(edgesmap[edge_to_delete]);
764  (mytab.mapstorage).graph.erase(edge_to_delete);
765}
766
767void GraphDisplayerCanvas::textReposition(xy<double> new_place)
768{
769  new_place+=(xy<double>(10,10));
770  edgetextmap[forming_edge]->property_x().set_value(new_place.x);
771  edgetextmap[forming_edge]->property_y().set_value(new_place.y);
772}
773
774void GraphDisplayerCanvas::toggleEdgeActivity(BrokenEdge* active_bre, bool on)
775{
776  if(on)
777    {
778      if(forming_edge!=INVALID)
779        {
780          std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
781        }
782      else
783        {
784          for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
785            {
786              if(edgesmap[i]==active_bre)
787                {
788                  forming_edge=i;
789                }
790            }
791        }
792    }
793  else
794    {
795      if(forming_edge!=INVALID)
796        {
797          forming_edge=INVALID;
798        }
799      else
800        {
801          std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
802        }
803    }
804
805}
806
807int GraphDisplayerCanvas::addNewEdgeMap(double default_value, std::string mapname)
808{
809  //create the new map
810  Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> ((mytab.mapstorage).graph, default_value);
811
812  //if addition was not successful addEdgeMap returns one.
813  //cause can be that there is already a map named like the new one
814  if((mytab.mapstorage).addEdgeMap(mapname,emptr, default_value))
815    {
816      return 1;
817    }
818
819
820  //add it to the list of the displayable maps
821  mytab.registerNewEdgeMap(mapname);
822
823  //display it
824  changeEdgeText(mapname);
825
826  return 0;
827}
828
829int GraphDisplayerCanvas::addNewNodeMap(double default_value, std::string mapname)
830{
831  //create the new map
832  Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> ((mytab.mapstorage).graph,default_value);
833
834  //if addition was not successful addNodeMap returns one.
835  //cause can be that there is already a map named like the new one
836  if((mytab.mapstorage).addNodeMap(mapname,emptr, default_value))
837    {
838      return 1;
839    }
840
841  //add it to the list of the displayable maps
842  mytab.registerNewNodeMap(mapname);
843
844  //display it
845  changeNodeText(mapname);
846
847  return 0;
848}
849
Note: See TracBrowser for help on using the repository browser.