COIN-OR::LEMON - Graph Library

Changeset 27:e2c86ae158cf in glemon-0.x


Ignore:
Timestamp:
06/24/05 09:58:18 (14 years ago)
Author:
Hegyi Péter
Branch:
gui
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk/gui@1993
Message:

File graph_displayer is split in functional parts.

Files:
3 added
2 edited

Legend:

Unmodified
Added
Removed
  • Makefile.am

    r17 r27  
    77        all_include.h \
    88        graph_displayer_canvas.cc \
     9        graph_displayer_canvas-edge.cc \
     10        graph_displayer_canvas-event.cc \
     11        graph_displayer_canvas-zoom.cc \
    912        graph_displayer_canvas.h \
    1013        graph-displayer.cc \
  • graph_displayer_canvas.cc

    r26 r27  
    9292  writer.run();
    9393}
    94 
    95 int GraphDisplayerCanvas::changeLineWidth (std::string mapname)
    96 {
    97   for (EdgeIt i(g); i!=INVALID; ++i)
    98     {
    99       int w=(int)(*(mapstorage.edgemap_storage)[mapname])[i];
    100       if(w>=0)
    101         {
    102           edgesmap[i]->property_width_pixels().set_value(w);
    103         }
    104     }
    105   return 0;
    106 };
    107 
    108 int GraphDisplayerCanvas::changeColor (std::string mapname)
    109 
    110 
    111   //function maps the range of the maximum and
    112   //the minimum of the nodemap to the range of
    113   //green in RGB
    114 
    115   for (EdgeIt i(g); i!=INVALID; ++i)
    116   {
    117     double w=(*(mapstorage.edgemap_storage)[mapname])[i];
    118     double max=mapstorage.maxOfEdgeMap(mapname);
    119     double min=mapstorage.minOfEdgeMap(mapname);
    120      
    121     //std::cout<<w<<" "<<max<<" "<<min<<" "<<100*(w-min)/(max-min)<<std::endl;
    122     Gdk::Color color;
    123     if(max!=min)
    124     {
    125       color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
    126     }
    127     else
    128     {
    129       color.set_rgb_p (0, 100, 0);
    130     }
    131 
    132     edgesmap[i]->property_fill_color_gdk().set_value(color);
    133   }
    134   return 0;
    135 };
    136 
    137 int GraphDisplayerCanvas::changeText (std::string mapname)
    138 {
    139 
    140   //the number in the map will be written on the edge
    141   //EXCEPT when the name of the map is Text, because
    142   //in that case empty string will be written, because
    143   //that is the deleter map
    144   //\todo isn't it a bit woodcutter?
    145 
    146   for (EdgeIt i(g); i!=INVALID; ++i)
    147     {
    148       if(mapname!="Text")
    149         {
    150           double number=(*(mapstorage.edgemap_storage)[mapname])[i];
    151           int length=1;
    152           //if number is smaller than one, length would be negative, or invalid
    153           if(number>=1)
    154             {
    155               length=(int)(floor(log(number)/log(10)))+1;
    156             }
    157           int maxpos=(int)(pow(10,length-1));
    158           int strl=length+1+RANGE;
    159           char * str=new char[strl];
    160           str[length]='.';
    161           str[strl]='\0';
    162      
    163           for(int j=0;j<strl;j++)
    164             {
    165               if(j!=length)
    166                 {
    167                   int digit=(int)(number/maxpos);
    168                   str[j]=(digit+'0');
    169                   number-=digit*maxpos;
    170                   number*=10;
    171                 }
    172             }
    173      
    174           edgetextmap[i]->property_text().set_value(str);
    175         }
    176       else
    177         {
    178           edgetextmap[i]->property_text().set_value("");
    179         }
    180     }
    181   return 0;
    182 };
    183 
    184 //Deprecated
    185 bool GraphDisplayerCanvas::event_handler(GdkEvent* e, Node n)
    186 {
    187   switch(e->type)
    188   {
    189     case GDK_BUTTON_PRESS:
    190       //we mark the location of the event to be able to calculate parameters of dragging
    191       clicked_x=e->button.x;
    192       clicked_y=e->button.y;
    193       active_item=(get_item_at(e->button.x, e->button.y));
    194       isbutton=1;
    195       break;
    196     case GDK_BUTTON_RELEASE:
    197       isbutton=0;
    198       active_item=NULL;
    199       updateScrollRegion();
    200       break;
    201     case GDK_MOTION_NOTIFY:
    202       //we only have to do sg. if the mouse button is pressed
    203       if(isbutton)
    204       {
    205         //new coordinates will be the old values,
    206         //because the item will be moved to the
    207         //new coordinate therefore the new movement
    208         //has to be calculated from here
    209 
    210         double dx=e->motion.x-clicked_x;
    211         double dy=e->motion.y-clicked_y;
    212         active_item->move(dx, dy);
    213         clicked_x=e->motion.x;
    214         clicked_y=e->motion.y;
    215 
    216         //all the edges connected to the moved point has to be redrawn
    217 
    218         EdgeIt e;
    219         g.firstOut(e,n);
    220         for(;e!=INVALID;g.nextOut(e))
    221         {
    222             Gnome::Canvas::Points coos;
    223             double x1, x2, y1, y2;
    224 
    225             nodesmap[g.source(e)]->get_bounds(x1, y1, x2, y2);
    226             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    227 
    228             nodesmap[g.target(e)]->get_bounds(x1, y1, x2, y2);
    229             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    230 
    231             edgesmap[e]->property_points().set_value(coos);
    232 
    233             edgesmap[e]->get_bounds(x1, y1, x2, y2);
    234 
    235             edgetextmap[e]->property_x().set_value((x1+x2)/2);
    236             edgetextmap[e]->property_y().set_value((y1+y2)/2);
    237         }
    238 
    239         g.firstIn(e,n);
    240         for(;e!=INVALID;g.nextIn(e))
    241         {
    242             Gnome::Canvas::Points coos;
    243             double x1, x2, y1, y2;
    244 
    245             nodesmap[g.source(e)]->get_bounds(x1, y1, x2, y2);
    246             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    247 
    248             nodesmap[g.target(e)]->get_bounds(x1, y1, x2, y2);
    249             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    250 
    251             edgesmap[e]->property_points().set_value(coos);
    252 
    253             edgesmap[e]->get_bounds(x1, y1, x2, y2);
    254 
    255             edgetextmap[e]->property_x().set_value((x1+x2)/2);
    256             edgetextmap[e]->property_y().set_value((y1+y2)/2);
    257         }
    258       }
    259     default: break;
    260   }
    261   return true;
    262 }
    263 
    264 bool GraphDisplayerCanvas::on_expose_event(GdkEventExpose *event)
    265 {
    266   Gnome::Canvas::CanvasAA::on_expose_event(event);
    267   //usleep(10000);
    268   //rezoom();
    269   return true;
    270 }
    271 
    272 void GraphDisplayerCanvas::zoomIn()
    273 {
    274   set_pixels_per_unit(
    275       (1.0 + (double) zoom_step / 100.0) * get_pixels_per_unit());
    276 }
    277 
    278 void GraphDisplayerCanvas::zoomOut()
    279 {
    280   set_pixels_per_unit(
    281       (1.0 - (double) zoom_step / 100.0) * get_pixels_per_unit());
    282 }
    283 
    284 void GraphDisplayerCanvas::zoomFit()
    285 {
    286   // get the height and width of the canvas
    287   Gtk::Allocation a = get_allocation();
    288   int aw = a.get_width();
    289   int ah = a.get_height();
    290   // add some space
    291   aw -= 5; if (aw < 0) aw = 0;
    292   ah -= 5; if (ah < 0) ah = 0;
    293 
    294   // get the bounding box of the graph
    295   double wx1, wy1, wx2, wy2;
    296   Gnome::Canvas::Item* pCanvasItem = root();
    297   pCanvasItem->get_bounds(wx1, wy1, wx2, wy2);
    298 
    299   // fit the graph to the window
    300   double ppu1 = (double) aw / fabs(wx2 - wx1);
    301   double ppu2 = (double) ah / fabs(wy2 - wy1);
    302   set_pixels_per_unit((ppu1 < ppu2) ? ppu1 : ppu2);
    303 }
    304 
    305 void GraphDisplayerCanvas::zoom100()
    306 {
    307   set_pixels_per_unit(1.0);
    308 }
    309 
    310 void GraphDisplayerCanvas::updateScrollRegion()
    311 {
    312   double wx1, wy1, wx2, wy2;
    313   Gnome::Canvas::Item* pCanvasItem = root();
    314   pCanvasItem->get_bounds(wx1, wy1, wx2, wy2);
    315   set_scroll_region(wx1, wy1, wx2, wy2);
    316 }
    317 
    318 void GraphDisplayerCanvas::changeEditorialTool(int newtool)
    319 {
    320   actual_handler.disconnect();
    321 
    322   if(actual_tool==CREATE_EDGE)
    323     {
    324         GdkEvent * generated=new GdkEvent();
    325         generated->type=GDK_BUTTON_RELEASE;
    326         generated->button.button=3;
    327         create_edge_event_handler(generated);     
    328     }
    329 
    330   actual_tool=newtool;
    331 
    332   switch(newtool)
    333     {
    334     case MOVE:
    335       actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::move_event_handler), false);
    336       break;
    337 
    338       //it has to assigned to canvas, because all the canvas has to be monitored, not only the elements of the already drawn group
    339     case CREATE_NODE:
    340       actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::create_node_event_handler), false);
    341       break;
    342 
    343     case CREATE_EDGE:
    344       actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::create_edge_event_handler), false);
    345       break;
    346 
    347     case ERASER:
    348       actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraser_event_handler), false);
    349       break;
    350 
    351     default:
    352       break;
    353     }
    354 }
    355 
    356 int GraphDisplayerCanvas::get_actual_tool()
    357 {
    358   return actual_tool;
    359 }
    360 
    361 bool GraphDisplayerCanvas::move_event_handler(GdkEvent* e)
    362 {
    363   switch(e->type)
    364   {
    365     case GDK_BUTTON_PRESS:
    366       //we mark the location of the event to be able to calculate parameters of dragging
    367       clicked_x=e->button.x;
    368       clicked_y=e->button.y;
    369       active_item=(get_item_at(e->button.x, e->button.y));
    370       active_node=INVALID;
    371       for (NodeIt i(g); i!=INVALID; ++i)
    372         {
    373           if(nodesmap[i]==active_item)
    374             {
    375               active_node=i;
    376             }
    377         }
    378       switch(e->button.button)
    379         {
    380         case 3:     
    381           isbutton=3;
    382           break;
    383         default:
    384           isbutton=1;
    385           break;
    386         }
    387       break;
    388     case GDK_BUTTON_RELEASE:
    389       isbutton=0;
    390       active_item=NULL;
    391       active_node=INVALID;
    392       updateScrollRegion();
    393       break;
    394     case GDK_MOTION_NOTIFY:
    395       //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
    396       if(active_node!=INVALID)
    397       {
    398         //new coordinates will be the old values,
    399         //because the item will be moved to the
    400         //new coordinate therefore the new movement
    401         //has to be calculated from here
    402 
    403         double dx=e->motion.x-clicked_x;
    404         double dy=e->motion.y-clicked_y;
    405 
    406         active_item->move(dx, dy);
    407 
    408         clicked_x=e->motion.x;
    409         clicked_y=e->motion.y;
    410 
    411         //all the edges connected to the moved point has to be redrawn
    412         EdgeIt ei;
    413 
    414         g.firstOut(ei,active_node);
    415 
    416         for(;ei!=INVALID;g.nextOut(ei))
    417         {
    418             Gnome::Canvas::Points coos;
    419             double x1, x2, y1, y2;
    420 
    421             nodesmap[g.source(ei)]->get_bounds(x1, y1, x2, y2);
    422             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    423 
    424             nodesmap[g.target(ei)]->get_bounds(x1, y1, x2, y2);
    425             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    426 
    427             if(isbutton==3)
    428               {
    429                 edgesmap[ei]->set_points(coos);
    430               }
    431             else
    432               {
    433                 edgesmap[ei]->set_points(coos,true);
    434               }
    435 
    436             xy<double> text_pos=edgesmap[ei]->get_arrow_pos();
    437             text_pos+=(xy<double>(10,10));
    438             edgetextmap[ei]->property_x().set_value(text_pos.x);
    439             edgetextmap[ei]->property_y().set_value(text_pos.y);
    440         }
    441 
    442         g.firstIn(ei,active_node);
    443         for(;ei!=INVALID;g.nextIn(ei))
    444         {
    445             Gnome::Canvas::Points coos;
    446             double x1, x2, y1, y2;
    447 
    448             nodesmap[g.source(ei)]->get_bounds(x1, y1, x2, y2);
    449             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    450 
    451             nodesmap[g.target(ei)]->get_bounds(x1, y1, x2, y2);
    452             coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    453 
    454             if(isbutton==3)
    455               {
    456                 edgesmap[ei]->set_points(coos);
    457               }
    458             else
    459               {
    460                 edgesmap[ei]->set_points(coos,true);
    461               }
    462 
    463             xy<double> text_pos=edgesmap[ei]->get_arrow_pos();
    464             text_pos+=(xy<double>(10,10));
    465             edgetextmap[ei]->property_x().set_value(text_pos.x);
    466             edgetextmap[ei]->property_y().set_value(text_pos.y);
    467         }
    468       }
    469     default: break;
    470   }
    471 
    472   return true;
    473 }
    474 
    475 bool GraphDisplayerCanvas::create_node_event_handler(GdkEvent* e)
    476 {
    477   switch(e->type)
    478     {
    479 
    480       //draw the new node in red at the clicked place
    481     case GDK_BUTTON_PRESS:
    482       isbutton=1;
    483 
    484       active_node=NodeIt(g,g.addNode());
    485 
    486       //initiating values corresponding to new node in maps
    487      
    488 
    489       window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
    490 
    491       nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph, clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
    492       active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
    493       *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
    494       *(nodesmap[active_node]) << Gnome::Canvas::Properties::outline_color("black");
    495       (nodesmap[active_node])->show();
    496       break;
    497 
    498       //move the new node
    499     case GDK_MOTION_NOTIFY:
    500       {
    501         double world_motion_x, world_motion_y;
    502         GdkEvent * generated=new GdkEvent();
    503         window_to_world (e->motion.x, e->motion.y, world_motion_x, world_motion_y);
    504         generated->motion.x=world_motion_x;
    505         generated->motion.y=world_motion_y;
    506         generated->type=GDK_MOTION_NOTIFY;
    507         move_event_handler(generated);     
    508         break;
    509       }
    510 
    511       //finalize the new node
    512     case GDK_BUTTON_RELEASE:
    513       isbutton=0;
    514       *active_item << Gnome::Canvas::Properties::fill_color("blue");
    515       active_item=NULL;
    516       active_node=INVALID;
    517       updateScrollRegion();
    518       break;
    519     default:
    520       break;
    521     }
    522   return false;
    523 }
    524 
    525 bool GraphDisplayerCanvas::create_edge_event_handler(GdkEvent* e)
    526 {
    527   switch(e->type)
    528     {
    529     case GDK_BUTTON_PRESS:
    530       //in edge creation right button has special meaning
    531       if(e->button.button!=3)
    532         {
    533           //there is not yet selected node
    534           if(active_node==INVALID)
    535             {
    536               //we mark the location of the event to be able to calculate parameters of dragging
    537               clicked_x=e->button.x;
    538               clicked_y=e->button.y;
    539               active_item=(get_item_at(e->button.x, e->button.y));
    540               active_node=INVALID;
    541               for (NodeIt i(g); i!=INVALID; ++i)
    542                 {
    543                   if(nodesmap[i]==active_item)
    544                     {
    545                       active_node=i;
    546                     }
    547                 }
    548               //the clicked item is really a node
    549               if(active_node!=INVALID)
    550                 {
    551                   *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
    552                   isbutton=1;
    553                 }
    554               //clicked item was not a node. It could be e.g. edge.
    555               else
    556                 {
    557                   active_item=NULL;
    558                 }
    559             }
    560           //we only have to do sg. if the mouse button
    561           // is pressed already once AND the click was
    562           // on a node that was found in the set of
    563           //nodes, and now we only search for the second
    564           //node
    565           else
    566             {
    567               target_item=(get_item_at(e->button.x, e->button.y));
    568               Graph::NodeIt target_node=INVALID;
    569               for (NodeIt i(g); i!=INVALID; ++i)
    570                 {
    571                   if(nodesmap[i]==target_item)
    572                     {
    573                       target_node=i;
    574                     }
    575                 }
    576               //the clicked item is a node, the edge can be drawn
    577               if(target_node!=INVALID)
    578                 {
    579                   *(nodesmap[target_node]) << Gnome::Canvas::Properties::fill_color("red");
    580 
    581                   //creating new edge
    582                   active_edge=EdgeIt(g,g.addEdge(active_node, target_node));
    583 
    584                   //initiating values corresponding to new edge in maps
    585                   mapstorage.init_maps_for_edge(active_edge);
    586          
    587                   //calculating coordinates of new edge
    588                   Gnome::Canvas::Points coos;
    589                   double x1, x2, y1, y2;
    590          
    591                   active_item->get_bounds(x1, y1, x2, y2);
    592                   coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    593 
    594                   target_item->get_bounds(x1, y1, x2, y2);
    595                   coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
    596 
    597                   //drawing new edge
    598                   edgesmap[active_edge]=new BrokenEdge(displayed_graph, coos, *this);
    599                   *(edgesmap[active_edge]) << Gnome::Canvas::Properties::fill_color("green");
    600                   edgesmap[active_edge]->property_width_pixels().set_value(10);
    601 
    602                   //redraw nodes to blank terminations of the new edge
    603                   target_item->raise_to_top();
    604                   active_item->raise_to_top();
    605 
    606                   //initializing edge-text as well, to empty string
    607                   xy<double> text_pos=edgesmap[active_edge]->get_arrow_pos();
    608                   text_pos+=(xy<double>(10,10));
    609 
    610                   edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
    611                   edgetextmap[active_edge]->property_fill_color().set_value("black");
    612                 }
    613               //clicked item was not a node. it could be an e.g. edge. we do not deal with it furthermore.
    614               else
    615                 {
    616                   target_item=NULL;
    617                 }
    618             }
    619         }
    620       break;
    621     case GDK_BUTTON_RELEASE:
    622       isbutton=0;
    623       //we clear settings in two cases
    624       //1: the edge is ready (target_item has valid value)
    625       //2: the edge creation is cancelled with right button
    626       if((target_item)||(e->button.button==3))
    627         {
    628           if(active_item)
    629             {
    630               *active_item << Gnome::Canvas::Properties::fill_color("blue");
    631               active_item=NULL;
    632             }
    633           if(target_item)
    634             {
    635               *target_item << Gnome::Canvas::Properties::fill_color("blue");
    636               target_item=NULL;
    637             }
    638           active_node=INVALID;
    639           active_edge=INVALID;
    640         }
    641       break;
    642     default:
    643       break;
    644     }
    645   return false;
    646 }
    647 
    648 bool GraphDisplayerCanvas::eraser_event_handler(GdkEvent* e)
    649 {
    650   switch(e->type)
    651     {
    652     case GDK_BUTTON_PRESS:
    653       active_item=(get_item_at(e->button.x, e->button.y));
    654       active_node=INVALID;
    655       active_edge=INVALID;
    656       for (NodeIt i(g); i!=INVALID; ++i)
    657         {
    658           if(nodesmap[i]==active_item)
    659             {
    660               active_node=i;
    661             }
    662         }
    663       if(active_node==INVALID)
    664         {
    665           for (EdgeIt i(g); i!=INVALID; ++i)
    666             {
    667               if(edgesmap[i]==active_item)
    668                 {
    669                   active_edge=i;
    670                 }
    671             }
    672         }
    673     *active_item << Gnome::Canvas::Properties::fill_color("red");
    674       break;
    675 
    676     case GDK_BUTTON_RELEASE:
    677       if(active_item==(get_item_at(e->button.x, e->button.y)))
    678         {
    679           if(active_node!=INVALID)
    680             {
    681 
    682               //collecting edges to delete
    683               EdgeIt e;
    684               std::set<Graph::Edge> edges_to_delete;
    685 
    686               g.firstOut(e,active_node);
    687               for(;e!=INVALID;g.nextOut(e))
    688                 {
    689                       edges_to_delete.insert(e);
    690                 }
    691 
    692               g.firstIn(e,active_node);
    693               for(;e!=INVALID;g.nextIn(e))
    694                 {
    695                       edges_to_delete.insert(e);
    696                 }
    697 
    698               //deleting collected edges
    699               for(std::set<Graph::Edge>::iterator edge_set_it=edges_to_delete.begin();edge_set_it!=edges_to_delete.end();edge_set_it++)
    700                 {
    701                   delete_item(*edge_set_it);
    702                 }
    703               delete_item(active_node);
    704             }
    705           //a simple edge was chosen
    706           else
    707             {
    708               delete_item(active_edge);
    709             }
    710 
    711          
    712         }
    713       //pointer was moved, deletion is cancelled
    714       else
    715         {
    716           if(active_node!=INVALID)
    717             {
    718               *active_item << Gnome::Canvas::Properties::fill_color("blue");
    719             }
    720           else
    721             {
    722               *active_item << Gnome::Canvas::Properties::fill_color("green");
    723             }
    724         }
    725       //reseting datas
    726       active_item=NULL;
    727       active_edge=INVALID;
    728       active_node=INVALID;
    729       break;
    730 
    731     case GDK_MOTION_NOTIFY:
    732       break;
    733 
    734     default:
    735       break;
    736     }
    737   return true;
    738 }
    739 
    740 void GraphDisplayerCanvas::delete_item(NodeIt node_to_delete)
    741 {
    742   delete(nodesmap[node_to_delete]);
    743   g.erase(node_to_delete);
    744 }
    745 
    746 void GraphDisplayerCanvas::delete_item(EdgeIt edge_to_delete)
    747 {
    748   delete(edgesmap[edge_to_delete]);
    749   g.erase(edge_to_delete);
    750 }
    751 
    752 void GraphDisplayerCanvas::delete_item(Graph::Edge edge_to_delete)
    753 {
    754   delete(edgesmap[edge_to_delete]);
    755   g.erase(edge_to_delete);
    756 }
    757 
    758 void GraphDisplayerCanvas::text_reposition(xy<double> new_place)
    759 {
    760   new_place+=(xy<double>(10,10));
    761   edgetextmap[active_edge]->property_x().set_value(new_place.x);
    762   edgetextmap[active_edge]->property_y().set_value(new_place.y);
    763 }
    764 
    765 void GraphDisplayerCanvas::toggle_edge_activity(BrokenEdge* active_bre, bool on)
    766 {
    767   if(on)
    768     {
    769       if(active_edge!=INVALID)
    770         {
    771           std::cout << "ERROR!!!! Valid edge found!" << std::endl;
    772         }
    773       else
    774         {
    775           for (EdgeIt i(g); i!=INVALID; ++i)
    776             {
    777               if(edgesmap[i]==active_bre)
    778                 {
    779                   active_edge=i;
    780                 }
    781             }
    782         }
    783     }
    784   else
    785     {
    786       if(active_edge!=INVALID)
    787         {
    788           active_edge=INVALID;
    789         }
    790       else
    791         {
    792           std::cout << "ERROR!!!! Invalid edge found!" << std::endl;
    793         }
    794     }
    795 
    796 }
Note: See TracChangeset for help on using the changeset viewer.