source: lemon-0.x/gui/mapselector.cc @ 1731:616bc933c2bc

#include "mapselector.h"

MapSelector::MapSelector(GraphDisplayerCanvas & grdispc, MapStorage & mapst, MapWin & mapw, int identifier, bool edge):gdc(grdispc),ms(mapst),mw(mapw),id(identifier),itisedge(edge),default_state(true),node_to_update(INVALID),edge_to_update(INVALID)
{
  update_list();

  cbt.set_active(0);

  //binding signal to the actual entry
  cbt.signal_changed().connect
    (
     sigc::mem_fun((*this), &MapSelector::comboChanged),
     false
     );
  
  if(itisedge)
    {
      label=new Gtk::Label(edge_property_strings[id]);
    }
  else
    {
      label=new Gtk::Label(node_property_strings[id]);
    }

  label->set_width_chars(longest_property_string_length);

  defbut=new Gtk::Button();
  defbut->set_label("Reset");

  defbut->signal_pressed().connect
    (
     sigc::mem_fun(*this, &MapSelector::reset)
     );

  newbut=new Gtk::Button(Gtk::Stock::NEW);

  add(*label);

  add(cbt);

  add(*defbut);
  add(*newbut);
}

void MapSelector::update_list()
{
  cbt.clear();
  if(itisedge)
    {
      std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=ms.beginOfEdgeMaps();
      for(;emsi!=ms.endOfEdgeMaps();emsi++)
        {
          cbt.append_text(emsi->first);
        }
    }
  else
    {
      std::map< std::string,Graph::NodeMap<double> * >::iterator emsi=ms.beginOfNodeMaps();
      for(;emsi!=ms.endOfNodeMaps();emsi++)
        {
          cbt.append_text(emsi->first);
        }
    }
  cbt.prepend_text("Default values");
}

void MapSelector::comboChanged()
{
  if(cbt.get_active_row_number()!=0)
    {
      default_state=false;
      Glib::ustring mapname = cbt.get_active_text();
      if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.
        {
          if(itisedge)
            {
              if( ( (ms.edgemap_storage).find(mapname) != (ms.edgemap_storage).end() ) )
                {
                  Edge edge=edge_to_update;
                  switch(id)
                    {
                    case E_WIDTH:
                      gdc.changeEdgeWidth(mapname, edge);
                      break;
                    case E_COLOR:
                      gdc.changeEdgeColor(mapname, edge);
                      break;
                    case E_TEXT:
                      gdc.changeEdgeText(mapname, edge);
                      break;
                    default:
                      std::cerr<<"Error\n";
                    }
                }
            }
          else
            {
              if( ( (ms.nodemap_storage).find(mapname) != (ms.nodemap_storage).end() ) )
                {
                  Node node=node_to_update;
                  switch(id)
                    {
                    case N_RADIUS:
                      gdc.changeNodeRadius(mapname, node);
                      break;
                    case N_COLOR:
                      gdc.changeNodeColor(mapname, node);
                      break;
                    case N_TEXT:
                      gdc.changeNodeText(mapname, node);
                      break;
                    default:
                      std::cerr<<"Error\n";
                    }
                }
            }
        }
    }
  else if((!default_state)&&(cbt.get_active_row_number()==0))
    {
      reset();
    }
}

void MapSelector::reset()
{
  default_state=true;
  cbt.set_active(0);

  if(itisedge)
    {
      Edge edge=edge_to_update;
      switch(id)
        {
        case E_WIDTH:
          gdc.resetEdgeWidth(edge);
          break;
        case E_COLOR:
          gdc.resetEdgeColor(edge);
          break;
        case E_TEXT:
          gdc.resetEdgeText(edge);
          break;
        default:
          std::cerr<<"Error\n";
        }
    }
  else
    {
      Node node=node_to_update; 
      switch(id)
        {
        case N_RADIUS:
          gdc.resetNodeRadius(node);
          break;
        case N_COLOR:
          gdc.resetNodeColor(node);
          break;
        case N_TEXT:
          gdc.resetNodeText(node);
          break;
        default:
          std::cerr<<"Error\n";
        }
    }
}

void MapSelector::update(Node node)
{
  node_to_update=node;
  if(default_state)
    {
      reset();
    }
  else
    {
      comboChanged();
    }
  node_to_update=INVALID;
}

void MapSelector::update(Edge edge)
{
  edge_to_update=edge;
  if(default_state)
    {
      reset();
    }
  else
    {
      comboChanged();
    }
  edge_to_update=INVALID;
}

Glib::ustring MapSelector::get_active_text()
{
  return cbt.get_active_text();
}

void MapSelector::set_active_text(Glib::ustring text)
{
  cbt.set_active_text(text);
}

void MapSelector::append_text(Glib::ustring text)
{
  cbt.append_text(text);
}