Changeset 1579:ed7da82bbecf in lemon-0.x

Timestamp:

07/21/05 21:28:29 (19 years ago)

Author:

Hegyi Péter

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2081

Message:

Edge and nodemap edition is done.

Location:

gui

Files:

• graph_displayer_canvas-edge.cc (modified) (2 diffs)
• graph_displayer_canvas-event.cc (modified) (10 diffs)
• graph_displayer_canvas-node.cc (modified) (4 diffs)
• graph_displayer_canvas.cc (modified) (2 diffs)
• graph_displayer_canvas.h (modified) (2 diffs)
• graphocska.lgf (modified) (1 diff)

gui/graph_displayer_canvas-edge.cc

@@ -119 +119 @@
           if(mapname!="Default")
             {
+              edgemap_to_edit=mapname;
               double number=(*(mapstorage.edgemap_storage)[mapname])[i];
               int length=1;
@@ -147 +148 @@
           else
             {
+              edgemap_to_edit="";
               edgetextmap[i]->property_text().set_value("");
             }

gui/graph_displayer_canvas-event.cc

@@ -30 +30 @@
           }
         case EDGE_MAP_EDIT:
-          break;
+          //has to do the same thing as in the case of NODE_MAP_EDIT
+        case NODE_MAP_EDIT:
+          {
+            GdkEvent * generated=new GdkEvent();
+            generated->type=GDK_KEY_PRESS;
+            ((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
+            entryWidgetChangeHandler(generated);
+            entrywidget.hide();
+            break;
+          }
         default:
           break;
@@ -218 +227 @@
 
       window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-
-      target_item=NULL;
-      target_item=get_item_at(clicked_x, clicked_y);
 
       nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph, clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
@@ -248 +254 @@
       //finalize the new node
     case GDK_BUTTON_RELEASE:
+      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
+
+      active_item->lower_to_bottom();
+
+      target_item=NULL;
+      target_item=get_item_at(clicked_x, clicked_y);
+
+      active_item->raise_to_top();
+
       isbutton=0;
-      if(!target_item)
+      if(target_item==active_item)
         {
           //Its appropriate color is given by update.
-          //*active_item << Gnome::Canvas::Properties::fill_color("blue");
+          *active_item << Gnome::Canvas::Properties::fill_color("blue");
         }
       else
@@ -509 +524 @@
     case GDK_KEY_PRESS:
       {
-        std::cout << "Any button was pressed" << std::endl;
-        switch(((GdkEventKey*)e)->keyval)
-          {
-          case GDK_A:
-            std::cout << "A button was pressed" << std::endl;
-            break;
-          default:
-            break;
-          }
-  
+        nodeMapEditEventHandler(e);
         break;
       }
@@ -556 +562 @@
         else
           {
-            //mentse el -> problema, hogy nem tudja melyik map-be
-            entrywidget.hide();
+            GdkEvent * generated=new GdkEvent();
+            generated->type=GDK_KEY_PRESS;
+            ((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
+            entryWidgetChangeHandler(generated);
           }
         break;
@@ -569 +577 @@
 bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
 {
-  e=e;
-  return false;
+  switch(e->type)
+    {
+    case GDK_KEY_PRESS:
+      {
+        switch(((GdkEventKey*)e)->keyval)
+          {
+          case GDK_Escape:
+            entrywidget.hide();
+            break;
+          case GDK_Return:
+          case GDK_KP_Enter:
+            entrywidget.hide();
+            break;
+          default:
+            break;
+          }
+  
+        break;
+      }
+    case GDK_BUTTON_PRESS:
+      {
+        window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
+        active_item=(get_item_at(clicked_x, clicked_y));
+        Graph::NodeIt clicked_node=INVALID;
+        for (NodeIt i(g); i!=INVALID; ++i)
+          {
+            if(nodesmap[i]==active_item)
+              {
+                clicked_node=i;
+              }
+          }
+        if(clicked_node!=INVALID)
+          {
+            //If there is already edited edge, it has to be saved first
+            if(entrywidget.is_visible())
+              {
+                GdkEvent * generated=new GdkEvent();
+                generated->type=GDK_KEY_PRESS;
+                ((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
+                entryWidgetChangeHandler(generated);
+              }
+            //If the previous value could be saved, we can go further, otherwise not
+            if(!entrywidget.is_visible())
+              {
+
+                if(nodetextmap[clicked_node]->property_text().get_value()!="")
+                  {
+                    active_node=clicked_node;
+                    if(canvasentrywidget)
+                      {
+                        delete(canvasentrywidget);
+                      }
+                    entrywidget.show();
+                    entrywidget.set_text(nodetextmap[active_node]->property_text().get_value());
+                    xy<double> entry_coos;
+                    entry_coos.x=(nodetextmap[active_node])->property_x().get_value();
+                    entry_coos.x-=nodetextmap[active_node]->property_text_width().get_value()/2;
+                    entry_coos.y=(nodetextmap[active_node])->property_y().get_value();
+                    entry_coos.y-=nodetextmap[active_node]->property_text_height().get_value()*1.5/2;
+                    canvasentrywidget=new Gnome::Canvas::Widget(displayed_graph, entry_coos.x, entry_coos.y, entrywidget);
+                    canvasentrywidget->property_width().set_value(nodetextmap[active_node]->property_text_width().get_value()*1.5);
+                    canvasentrywidget->property_height().set_value(nodetextmap[active_node]->property_text_height().get_value()*1.5);
+                  }
+              }
+          }
+        else
+          {
+            GdkEvent * generated=new GdkEvent();
+            generated->type=GDK_KEY_PRESS;
+            ((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
+            entryWidgetChangeHandler(generated);
+          }
+        break;
+      }
+    default:
+      break;
+    }
+  return false;  
 }
 
 bool GraphDisplayerCanvas::entryWidgetChangeHandler(GdkEvent* e)
 {
-  Glib::ustring mapvalue = entrywidget.get_text();
-  std::cout << mapvalue << std::endl;
-  e=e;
+  if(entrywidget.is_visible())
+    {
+      if(e->type==GDK_KEY_PRESS)
+        {
+          switch(((GdkEventKey*)e)->keyval)
+            {
+            case GDK_Escape:
+              entrywidget.hide();
+              break;
+            case GDK_KP_Enter:
+            case GDK_Return:
+              {
+                Glib::ustring mapvalue = entrywidget.get_text();
+
+                double double_map_fract_value=0;
+                double double_map_value=0;
+                int offset=0;
+                int found_letter=0;
+                //converting text to double
+                for(int i=0;i<(int)(mapvalue.length());i++)
+                  {
+                    if(((mapvalue[i]<='9')&&(mapvalue[i]>='0'))||(mapvalue[i]=='.'))
+                      {
+                        if(mapvalue[i]=='.')
+                          {
+                            //for calculating non-integer part of double we step backward from the end
+                            //after each step the number will be divided by ten, and the new value will be added
+                            //to step backward from the end until the point the actual character of the string is the following:
+                            // mapvalue.length()-(i-position_of_point)
+                            //if i was the number of the first character after the decimal point the selected character will be the last
+                            //if i was the number of the last character, the selected character will be the first after the decimal point
+                            offset=mapvalue.length()+i;
+                          }
+                        else
+                          {
+                            if(!offset)
+                              {
+                                double_map_value=10*double_map_value+mapvalue[i]-'0';
+                              }
+                            else
+                              {
+                                double_map_fract_value=double_map_fract_value/10+(double)(mapvalue[offset-i]-'0')/10;
+                              }
+                          }
+                      }
+                    else
+                      {
+                        found_letter++;
+                        continue;
+                      }
+                  }
+
+                if(!found_letter)
+                  {
+                    switch(actual_tool)
+                      {
+                      case EDGE_MAP_EDIT:
+                        edgetextmap[active_edge]->property_text().set_value(mapvalue);
+                        (*(mapstorage.edgemap_storage)[edgemap_to_edit])[active_edge]=double_map_value+double_map_fract_value;
+                        break;
+                      case NODE_MAP_EDIT:
+                        nodetextmap[active_node]->property_text().set_value(mapvalue);
+                        (*(mapstorage.nodemap_storage)[nodemap_to_edit])[active_node]=double_map_value+double_map_fract_value;
+                        break;
+                      default:
+                        break;
+                      }
+                    entrywidget.hide();
+                  }
+                else
+                  {
+                    std::cout << "ERROR: only handling of double values is implemented yet!" << std::endl;
+                  }
+
+                break;
+              }
+            default:
+              break;
+            }
+        }
+    }
   return false;
 }
@@ -605 +767 @@
 {
   new_place+=(xy<double>(10,10));
-  edgetextmap[active_edge]->property_x().set_value(new_place.x);
-  edgetextmap[active_edge]->property_y().set_value(new_place.y);
+  edgetextmap[forming_edge]->property_x().set_value(new_place.x);
+  edgetextmap[forming_edge]->property_y().set_value(new_place.y);
 }
 
@@ -613 +775 @@
   if(on)
     {
-      if(active_edge!=INVALID)
+      if(forming_edge!=INVALID)
         {
           std::cout << "ERROR!!!! Valid edge found!" << std::endl;
@@ -623 +785 @@
               if(edgesmap[i]==active_bre)
                 {
-                  active_edge=i;
+                  forming_edge=i;
                 }
             }
@@ -630 +792 @@
   else
     {
-      if(active_edge!=INVALID)
-        {
-          active_edge=INVALID;
+      if(forming_edge!=INVALID)
+        {
+          forming_edge=INVALID;
         }
       else

gui/graph_displayer_canvas-node.cc

@@ -137 +137 @@
 
   Graph::NodeMap<double> * actual_map;
-  if(mapname=="Default")
-    {
-      actual_map=new Graph::NodeMap<double>(g,node_property_defaults[N_COLOR]);
-    }
-  else
+  if(mapname!="Default")
     {
       actual_map=(mapstorage.nodemap_storage)[mapname];
@@ -152 +148 @@
           if(mapname!="Default")
             {
+              nodemap_to_edit=mapname;
               double number=(*actual_map)[i];
               int length=1;
@@ -169 +166 @@
                   if(j!=length)
                     {
-                      int digit=(int)(number/maxpos);
+                      int digit=(int)round(number/maxpos);
                       str[j]=(digit+'0');
                       number-=digit*maxpos;
@@ -180 +177 @@
           else
             {
+              nodemap_to_edit="";
               nodetextmap[i]->property_text().set_value("");
             }

gui/graph_displayer_canvas.cc

@@ -3 +3 @@
 #include <math.h>
 
-GraphDisplayerCanvas::GraphDisplayerCanvas(Graph & gr, CoordinatesMap & cm, MapStorage & ms, MapWin * mw):g(gr),nodesmap(g),edgesmap(g),edgetextmap(g),nodetextmap(g),displayed_graph(*(root()), 0, 0),canvasentrywidget(NULL),mapstorage(ms),isbutton(0),active_item(NULL),target_item(NULL),mapwin(mw)
+GraphDisplayerCanvas::GraphDisplayerCanvas(Graph & gr, CoordinatesMap & cm, MapStorage & ms, MapWin * mw):g(gr),nodesmap(g),edgesmap(g),edgetextmap(g),nodetextmap(g),displayed_graph(*(root()), 0, 0),canvasentrywidget(NULL),mapstorage(ms),isbutton(0),active_item(NULL),target_item(NULL),edgemap_to_edit(""),nodemap_to_edit(""),mapwin(mw)
 {
+  
   
   active_node=INVALID;
   active_edge=INVALID;
+  forming_edge=INVALID;
 
   //setting event handler for the editor widget
@@ -14 +16 @@
   //base event handler is move tool
   actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
-  actual_tool=CREATE_NODE;
+  actual_tool=MOVE;
 
   //set_center_scroll_region(true);

gui/graph_displayer_canvas.h

@@ -98 +98 @@
   void textReposition(xy<double>);
   ///Activates an edge belonging to a BrokenEdge
+  ///
+  ///After we have activated an edge this way,
+  ///the GDC object will know, which edge is under forming
+  ///therefore it can redraw the necessarz elementy on the canvas,
+  ///for example the text belonging to the \ref BrokenEdge can be
+  ///redrawn (\ref textReposition).
   void toggleEdgeActivity(BrokenEdge*, bool);
 
@@ -158 +164 @@
   Graph::NodeIt active_node;
   Graph::EdgeIt active_edge;
+  Graph::EdgeIt forming_edge;
+
+  std::string nodemap_to_edit, edgemap_to_edit;
 
   static const int zoom_step = 5;

gui/graphocska.lgf

@@ -1 +1 @@
 @nodeset
 id      coordinates_x   coordinates_y data
-1       230     -80     1
+1       230     -80     1.123
 2       230     100     3
 3       120     -80     5