COIN-OR::LEMON - Graph Library

Changeset 149:930e838ad5b6 in glemon-0.x


Ignore:
Timestamp:
09/19/06 09:43:55 (13 years ago)
Author:
Hegyi Péter
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/glemon/trunk@2950
Message:

Node and edge editor button are the same furthermore.

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • all_include.h

    r98 r149  
    1919enum {E_WIDTH, E_COLOR, E_TEXT, EDGE_PROPERTY_NUM}; // edge properties;
    2020enum {N_RADIUS, N_COLOR, N_TEXT, NODE_PROPERTY_NUM}; // node properties;
    21 enum {MOVE, CREATE_NODE, CREATE_EDGE, ERASER, EDGE_MAP_EDIT, NODE_MAP_EDIT, TOOL_NUM}; // tools;
     21enum {MOVE, CREATE_NODE, CREATE_EDGE, ERASER, MAP_EDIT, TOOL_NUM}; // tools;
    2222#define RANGE 3
    2323#define WIN_WIDTH 900
  • graph_displayer_canvas-event.cc

    r148 r149  
    2828            break;
    2929          }
    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:
     30        case MAP_EDIT:
    3331          {
    3432            break;
     
    6462          break;
    6563
    66         case EDGE_MAP_EDIT:
     64        case MAP_EDIT:
    6765          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);
     66          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
    7367          break;
    7468
     
    623617}
    624618
    625 bool GraphDisplayerCanvas::edgeMapEditEventHandler(GdkEvent* e)
    626 {
    627   if(actual_tool==EDGE_MAP_EDIT)
    628   {
    629     switch(e->type)
     619bool GraphDisplayerCanvas::mapEditEventHandler(GdkEvent* e)
     620{
     621  if(actual_tool==MAP_EDIT)
    630622    {
    631       case GDK_BUTTON_PRESS:
    632         {
    633           //for determine, whether it was an edge
    634           Edge clicked_edge=INVALID;
    635 
    636           window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
    637           active_item=(get_item_at(clicked_x, clicked_y));
    638 
    639           //find the activated item between texts
    640           for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
    641           {
    642             //at the same time only one can be active
    643             if(edgetextmap[i]==active_item)
    644             {
    645               clicked_edge=i;
    646             }
    647           }
    648 
    649           //if it was not between texts, search for it between edges
    650           if(clicked_edge==INVALID)
    651           {
    652             for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
    653             {
    654               //at the same time only one can be active
    655               if((edgesmap[i]==active_item)||(edgetextmap[i]==active_item))
    656               {
    657                 clicked_edge=i;
    658               }
    659             }
    660           }
    661  
    662           //if it was really an edge...
    663           if(clicked_edge!=INVALID)
    664           {
    665             // the id map is not editable
    666             if (edgemap_to_edit == "label") return 0;
    667 
    668             //and there is activated map
    669             if(edgetextmap[clicked_edge]->property_text().get_value()!="")
    670             {
    671               //activate the general variable for it
    672               active_edge=clicked_edge;
    673 
    674               //create a dialog
    675               Gtk::Dialog dialog("Edit value", true);
    676               dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    677               dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
    678               Gtk::VBox* vbox = dialog.get_vbox();
    679               Gtk::SpinButton spin(0.0, 4);
    680               spin.set_increments(1.0, 10.0);
    681               spin.set_range(-1000000.0, 1000000.0);
    682               spin.set_numeric(true);
    683               vbox->add(spin);
    684               spin.show();
    685               switch (dialog.run())
    686               {
    687                 case Gtk::RESPONSE_NONE:
    688                 case Gtk::RESPONSE_CANCEL:
    689                   break;
    690                 case Gtk::RESPONSE_ACCEPT:
    691                   double new_value = spin.get_value();
    692                   (*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
    693                     new_value;
    694                   std::ostringstream ostr;
    695                   ostr << new_value;
    696                   edgetextmap[active_edge]->property_text().set_value(
    697                       ostr.str());
    698                   //mapwin.updateEdge(active_edge);
    699 //                   mapwin.updateEdge(Edge(INVALID));
    700                   propertyUpdate(Edge(INVALID));
    701               }
    702             }
    703           }
    704           break;
    705         }
    706       default:
    707         break;
     623      switch(e->type)
     624        {
     625        case GDK_BUTTON_PRESS:
     626          {
     627            //for determine, whether it was an edge
     628            Edge clicked_edge=INVALID;
     629            //for determine, whether it was a node
     630            Node clicked_node=INVALID;
     631
     632            window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
     633            active_item=(get_item_at(clicked_x, clicked_y));
     634
     635            //find the activated item between text of nodes
     636            for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
     637              {
     638                //at the same time only one can be active
     639                if(nodetextmap[i]==active_item)
     640                  {
     641                    clicked_node=i;
     642                  }
     643              }
     644
     645            //if there was not, search for it between nodes
     646            if(clicked_node==INVALID)
     647              {
     648                for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
     649                  {
     650                    //at the same time only one can be active
     651                    if(nodesmap[i]==active_item)
     652                      {
     653                        clicked_node=i;
     654                      }
     655                  }
     656              }
     657
     658            if(clicked_node==INVALID)
     659              {
     660                //find the activated item between texts
     661                for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
     662                  {
     663                    //at the same time only one can be active
     664                    if(edgetextmap[i]==active_item)
     665                      {
     666                        clicked_edge=i;
     667                      }
     668                  }
     669
     670                //if it was not between texts, search for it between edges
     671                if(clicked_edge==INVALID)
     672                  {
     673                    for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
     674                      {
     675                        //at the same time only one can be active
     676                        if((edgesmap[i]->getLine())==active_item)
     677                          {
     678                            clicked_edge=i;
     679                          }
     680                      }
     681                  }
     682              }
     683
     684            //if it was really a node...
     685            if(clicked_node!=INVALID)
     686              {
     687                // the id map is not editable
     688                if (nodemap_to_edit == "label") return 0;
     689
     690                //and there is activated map
     691                if(nodetextmap[clicked_node]->property_text().get_value()!="")
     692                  {
     693                    //activate the general variable for it
     694                    active_node=clicked_node;
     695
     696                    //create a dialog
     697                    Gtk::Dialog dialog("Edit value", true);
     698                    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
     699                    dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
     700                    Gtk::VBox* vbox = dialog.get_vbox();
     701                    Gtk::SpinButton spin(0.0, 4);
     702                    spin.set_increments(1.0, 10.0);
     703                    spin.set_range(-1000000.0, 1000000.0);
     704                    spin.set_numeric(true);
     705                    spin.set_value(atof(nodetextmap[active_node]->property_text().get_value().c_str()));
     706                    vbox->add(spin);
     707                    spin.show();
     708                    switch (dialog.run())
     709                      {
     710                      case Gtk::RESPONSE_NONE:
     711                      case Gtk::RESPONSE_CANCEL:
     712                        break;
     713                      case Gtk::RESPONSE_ACCEPT:
     714                        double new_value = spin.get_value();
     715                        (*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
     716                          new_value;
     717                        std::ostringstream ostr;
     718                        ostr << new_value;
     719                        nodetextmap[active_node]->property_text().set_value(ostr.str());
     720                        //mapwin.updateNode(active_node);
     721                        //mapwin.updateNode(Node(INVALID));
     722                        propertyUpdate(Node(INVALID));
     723                      }
     724                  }
     725              }
     726            else
     727              //if it was really an edge...
     728              if(clicked_edge!=INVALID)
     729                {
     730                  // the id map is not editable
     731                  if (edgemap_to_edit == "label") return 0;
     732
     733                  //and there is activated map
     734                  if(edgetextmap[clicked_edge]->property_text().get_value()!="")
     735                    {
     736                      //activate the general variable for it
     737                      active_edge=clicked_edge;
     738
     739                      //create a dialog
     740                      Gtk::Dialog dialog("Edit value", true);
     741                      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
     742                      dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
     743                      Gtk::VBox* vbox = dialog.get_vbox();
     744                      Gtk::SpinButton spin(0.0, 4);
     745                      spin.set_increments(1.0, 10.0);
     746                      spin.set_range(-1000000.0, 1000000.0);
     747                      spin.set_numeric(true);
     748                      spin.set_value(atof(edgetextmap[active_edge]->property_text().get_value().c_str()));
     749                      vbox->add(spin);
     750                      spin.show();
     751                      switch (dialog.run())
     752                        {
     753                        case Gtk::RESPONSE_NONE:
     754                        case Gtk::RESPONSE_CANCEL:
     755                          break;
     756                        case Gtk::RESPONSE_ACCEPT:
     757                          double new_value = spin.get_value();
     758                          (*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
     759                            new_value;
     760                          std::ostringstream ostr;
     761                          ostr << new_value;
     762                          edgetextmap[active_edge]->property_text().set_value(
     763                                                                              ostr.str());
     764                          //mapwin.updateEdge(active_edge);
     765                          //                   mapwin.updateEdge(Edge(INVALID));
     766                          propertyUpdate(Edge(INVALID));
     767                        }
     768                    }
     769                }
     770            break;
     771          }
     772        default:
     773          break;
     774        }
    708775    }
    709   }
    710   return false; 
    711 }
    712 
    713 bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
    714 {
    715   if(actual_tool==NODE_MAP_EDIT)
    716   {
    717     switch(e->type)
    718     {
    719       case GDK_BUTTON_PRESS:
    720         {
    721           //for determine, whether it was a node
    722           Node clicked_node=INVALID;
    723 
    724           window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
    725           active_item=(get_item_at(clicked_x, clicked_y));
    726 
    727           //find the activated item between texts
    728           for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
    729           {
    730             //at the same time only one can be active
    731             if(nodetextmap[i]==active_item)
    732             {
    733               clicked_node=i;
    734             }
    735           }
    736 
    737           //if there was not, search for it between nodes
    738           if(clicked_node==INVALID)
    739           {
    740             for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
    741             {
    742               //at the same time only one can be active
    743               if(nodesmap[i]==active_item)
    744               {
    745                 clicked_node=i;
    746               }
    747             }
    748           }
    749 
    750           //if it was really a node...
    751           if(clicked_node!=INVALID)
    752           {
    753             // the id map is not editable
    754             if (nodemap_to_edit == "label") return 0;
    755 
    756             //and there is activated map
    757             if(nodetextmap[clicked_node]->property_text().get_value()!="")
    758             {
    759               //activate the general variable for it
    760               active_node=clicked_node;
    761 
    762               //create a dialog
    763               Gtk::Dialog dialog("Edit value", true);
    764               dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    765               dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
    766               Gtk::VBox* vbox = dialog.get_vbox();
    767               Gtk::SpinButton spin(0.0, 4);
    768               spin.set_increments(1.0, 10.0);
    769               spin.set_range(-1000000.0, 1000000.0);
    770               spin.set_numeric(true);
    771               vbox->add(spin);
    772               spin.show();
    773               switch (dialog.run())
    774               {
    775                 case Gtk::RESPONSE_NONE:
    776                 case Gtk::RESPONSE_CANCEL:
    777                   break;
    778                 case Gtk::RESPONSE_ACCEPT:
    779                   double new_value = spin.get_value();
    780                   (*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
    781                     new_value;
    782                   std::ostringstream ostr;
    783                   ostr << new_value;
    784                   nodetextmap[active_node]->property_text().set_value(
    785                       ostr.str());
    786                   //mapwin.updateNode(active_node);
    787 //                   mapwin.updateNode(Node(INVALID));
    788                   propertyUpdate(Node(INVALID));
    789               }
    790             }
    791           }
    792           break;
    793         }
    794       default:
    795         break;
    796     }
    797   }
    798776  return false; 
    799777}
  • graph_displayer_canvas.cc

    r147 r149  
    178178    edgetextmap[i]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
    179179    edgetextmap[i]->property_fill_color().set_value("darkgreen");
    180     edgetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::edgeMapEditEventHandler), false);
     180    edgetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
    181181    edgetextmap[i]->raise_to_top();
    182182  }
     
    207207        text_pos.x, text_pos.y, "");
    208208    nodetextmap[i]->property_fill_color().set_value("darkblue");
    209     nodetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::nodeMapEditEventHandler), false);
     209    nodetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
    210210    nodetextmap[i]->raise_to_top();
    211211  }
  • graph_displayer_canvas.h

    r148 r149  
    4444      virtual void setLineWidth(int) = 0;
    4545      virtual void setFillColor(Gdk::Color) = 0;
     46      virtual Gnome::Canvas::Item * getLine() = 0;
    4647  };
    4748
     
    9899      void setLineWidth(int);
    99100      void setFillColor(Gdk::Color);
     101
     102      Gnome::Canvas::Item * getLine() { return (Gnome::Canvas::Item *)(&line); };
    100103  };
    101104
     
    110113      void setLineWidth(int);
    111114      void setFillColor(Gdk::Color);
     115      Gnome::Canvas::Item * getLine() { return (Gnome::Canvas::Item *)(&line); };
    112116  };
    113117
     
    260264  ///event handler for the case when eraser-tool is active
    261265  bool eraserEventHandler(GdkEvent*);
    262   ///event handler for the case when edge map editor tool is active
    263   bool edgeMapEditEventHandler(GdkEvent*);
    264   ///event handler for the case when node map editor tool is active
    265   bool nodeMapEditEventHandler(GdkEvent*);
     266  ///event handler for the case when map editor tool is active
     267  bool mapEditEventHandler(GdkEvent*);
    266268
    267269public:
  • main_win.cc

    r140 r149  
    2727  Glib::RefPtr<Gdk::Pixbuf> p_editlink_pixbuf = Gdk::Pixbuf::create_from_inline(
    2828      2328, gui_icons_editlink);
    29   Glib::RefPtr<Gdk::Pixbuf> p_editnode_pixbuf = Gdk::Pixbuf::create_from_inline(
    30       2328, gui_icons_editnode);
    3129  Glib::RefPtr<Gdk::Pixbuf> p_newmap_pixbuf = Gdk::Pixbuf::create_from_inline(
    3230      2328, gui_icons_newmap);
     
    6159  editlink_icon_set.add_source(editlink_icon_source);
    6260  p_icon_factory->add(Gtk::StockID("gd-editlink"), editlink_icon_set);
    63 
    64   Gtk::IconSource editnode_icon_source;
    65   editnode_icon_source.set_pixbuf(p_editnode_pixbuf);
    66   Gtk::IconSet editnode_icon_set;
    67   editnode_icon_set.add_source(editnode_icon_source);
    68   p_icon_factory->add(Gtk::StockID("gd-editnode"), editnode_icon_set);
    6961
    7062  Gtk::IconSource newmap_icon_source;
     
    126118  ag->add( Gtk::RadioAction::create(tool_group, "EditEdgeMap", Gtk::StockID("gd-editlink"), _("Edit edge map")),
    127119      sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 4) );
    128   ag->add( Gtk::RadioAction::create(tool_group, "EditNodeMap", Gtk::StockID("gd-editnode"), _("Edit node map")),
    129       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 5) );
    130120
    131121  ag->add( Gtk::Action::create("AddMap", Gtk::StockID("gd-newmap")),
     
    181171      "    <toolitem action='EraseItem' />"
    182172      "    <toolitem action='EditEdgeMap' />"
    183       "    <toolitem action='EditNodeMap' />"
    184173      "    <separator />"
    185174      "    <toolitem action='AddMap' />"
Note: See TracChangeset for help on using the changeset viewer.