COIN-OR::LEMON - Graph Library

source: lemon-0.x/gui/graph_displayer_canvas-event.cc @ 1652:6eb2f0f3bab9

Last change on this file since 1652:6eb2f0f3bab9 was 1652:6eb2f0f3bab9, checked in by Akos Ladanyi, 14 years ago

Display the node's coordinates while moving it.

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