[Lemon-commits] ladanyi: r3083 - glemon/branches/akos
Lemon SVN
svn at lemon.cs.elte.hu
Wed Nov 22 15:13:54 CET 2006
Author: ladanyi
Date: Wed Nov 22 15:13:49 2006
New Revision: 3083
Modified:
glemon/branches/akos/gdc-broken_edge.cc
glemon/branches/akos/graph_displayer_canvas-edge.cc
glemon/branches/akos/graph_displayer_canvas-event.cc
glemon/branches/akos/graph_displayer_canvas.cc
glemon/branches/akos/mapstorage.cc
glemon/branches/akos/mapstorage.h
Log:
Make some public data members of MapStorage private.
Modified: glemon/branches/akos/gdc-broken_edge.cc
==============================================================================
--- glemon/branches/akos/gdc-broken_edge.cc (original)
+++ glemon/branches/akos/gdc-broken_edge.cc Wed Nov 22 15:13:49 2006
@@ -34,7 +34,7 @@
void GraphDisplayerCanvas::EdgeBase::drawArrow(XY unit_vector_in_dir)
{
MapStorage& ms = canvas.mytab.mapstorage;
- XY center(ms.arrow_pos[edge]);
+ XY center(ms.getArrowCoords(edge));
XY unit_norm_vector(0-unit_vector_in_dir.y, unit_vector_in_dir.x);
// /\ // top
@@ -87,8 +87,8 @@
MapStorage& ms = canvas.mytab.mapstorage;
//calculating coordinates of the direction indicator arrow
- XY head(ms.coords[ms.graph.target(edge)]);
- XY center(ms.arrow_pos[edge]);
+ XY head(ms.getNodeCoords(ms.graph.target(edge)));
+ XY center(ms.getArrowCoords(edge));
XY unit_vector_in_dir(head-center);
double length=sqrt( unit_vector_in_dir.normSquare() );
@@ -102,12 +102,12 @@
Gnome::Canvas::Points points;
Node source = ms.graph.source(edge);
Node target = ms.graph.target(edge);
- points.push_back(Gnome::Art::Point(ms.coords[source].x,
- ms.coords[source].y));
- points.push_back(Gnome::Art::Point(ms.arrow_pos[edge].x,
- ms.arrow_pos[edge].y));
- points.push_back(Gnome::Art::Point(ms.coords[target].x,
- ms.coords[target].y));
+ points.push_back(Gnome::Art::Point(ms.getNodeCoords(source).x,
+ ms.getNodeCoords(source).y));
+ points.push_back(Gnome::Art::Point(ms.getArrowCoords(edge).x,
+ ms.getArrowCoords(edge).y));
+ points.push_back(Gnome::Art::Point(ms.getNodeCoords(target).x,
+ ms.getNodeCoords(target).y));
line.property_points().set_value(points);
}
@@ -147,10 +147,10 @@
Gnome::Canvas::Points points_new;
- canvas.mytab.mapstorage.arrow_pos.set(edge, canvas.mytab.mapstorage.arrow_pos[edge] + XY(dx, dy));
+ canvas.mytab.mapstorage.setArrowCoords(edge, canvas.mytab.mapstorage.getArrowCoords(edge) + XY(dx, dy));
draw();
- canvas.textReposition(canvas.mytab.mapstorage.arrow_pos[edge]);
+ canvas.textReposition(canvas.mytab.mapstorage.getArrowCoords(edge));
clicked_x=e->motion.x;
clicked_y=e->motion.y;
@@ -194,16 +194,16 @@
MapStorage& ms = canvas.mytab.mapstorage;
Node node = ms.graph.source(edge);
- XY center = (ms.coords[node] + ms.arrow_pos[edge]) / 2.0;
+ XY center = (ms.getNodeCoords(node) + ms.getArrowCoords(edge)) / 2.0;
- XY unit_vector_in_dir(rot90(center - ms.arrow_pos[edge]));
+ XY unit_vector_in_dir(rot90(center - ms.getArrowCoords(edge)));
double length = sqrt(unit_vector_in_dir.normSquare());
unit_vector_in_dir /= length;
drawArrow(unit_vector_in_dir);
double radius =
- sqrt((ms.arrow_pos[edge] - ms.coords[node]).normSquare()) / 2.0;
+ sqrt((ms.getArrowCoords(edge) - ms.getNodeCoords(node)).normSquare()) / 2.0;
XY p1 = center + XY(-radius, radius);
XY p2 = center + XY( radius, -radius);
@@ -244,10 +244,10 @@
case GDK_MOTION_NOTIFY:
if(isbutton)
{
- canvas.mytab.mapstorage.arrow_pos.set(edge, XY(e->motion.x, e->motion.y));
+ canvas.mytab.mapstorage.setArrowCoords(edge, XY(e->motion.x, e->motion.y));
draw();
- canvas.textReposition(canvas.mytab.mapstorage.arrow_pos[edge]);
+ canvas.textReposition(canvas.mytab.mapstorage.getArrowCoords(edge));
}
default: break;
}
Modified: glemon/branches/akos/graph_displayer_canvas-edge.cc
==============================================================================
--- glemon/branches/akos/graph_displayer_canvas-edge.cc (original)
+++ glemon/branches/akos/graph_displayer_canvas-edge.cc Wed Nov 22 15:13:49 2006
@@ -28,99 +28,97 @@
min=edge_property_defaults[E_WIDTH];
max=edge_property_defaults[E_WIDTH];
Graph::EdgeMap<double> actual_map((mytab.mapstorage).graph,edge_property_defaults[E_WIDTH]);
-
+
if(edge==INVALID)
+ {
+ for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
{
- for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- double v=fabs(actual_map[i]);
- int w;
- if(min==max)
- {
- w=(int)(edge_property_defaults[E_WIDTH]);
- }
- else
- {
- w=(int)(MIN_EDGE_WIDTH+(v-min)/(max-min)*(MAX_EDGE_WIDTH-MIN_EDGE_WIDTH));
- }
- if(zoomtrack)
- {
- double actual_ppu=get_pixels_per_unit();
- w=(int)(w/actual_ppu*fixed_zoom_factor);
- }
- edgesmap[i]->setLineWidth(w);
- }
+ double v=fabs(actual_map[i]);
+ int w;
+ if(min==max)
+ {
+ w=(int)(edge_property_defaults[E_WIDTH]);
+ }
+ else
+ {
+ w=(int)(MIN_EDGE_WIDTH+(v-min)/(max-min)*(MAX_EDGE_WIDTH-MIN_EDGE_WIDTH));
+ }
+ if(zoomtrack)
+ {
+ double actual_ppu=get_pixels_per_unit();
+ w=(int)(w/actual_ppu*fixed_zoom_factor);
+ }
+ edgesmap[i]->setLineWidth(w);
}
+ }
else
+ {
+ int w=(int)actual_map[edge];
+ if(w>=0)
{
- int w=(int)actual_map[edge];
- if(w>=0)
- {
- edgesmap[edge]->setLineWidth(w);
- }
+ edgesmap[edge]->setLineWidth(w);
}
+ }
return 0;
}
int GraphDisplayerCanvas::changeEdgeWidth (std::string mapname, Edge edge)
{
- Graph::EdgeMap<double> * actual_map;
double min, max;
min=(mytab.mapstorage).minOfEdgeMap(mapname);
max=(mytab.mapstorage).maxOfEdgeMap(mapname);
- actual_map=((mytab.mapstorage).edgemap_storage)[mapname];
if(edge==INVALID)
+ {
+ for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
{
- for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- double v=(*actual_map)[i];
- int w;
- if(autoscale)
- {
- if(min==max)
- {
- w=(int)(edge_property_defaults[E_WIDTH]);
- }
- else
- {
- w=(int)(minimum_edge_width+(v-min)/(max-min)*(edge_width-minimum_edge_width));
- }
- }
- else
- {
- w=(int)(v*edge_width);
- }
- if(w<0)
- {
- edgesmap[i]->hide();
- }
- else
- {
- edgesmap[i]->show();
- if(w<minimum_edge_width)
- {
- w=minimum_edge_width;
- }
- if(zoomtrack)
- {
- double actual_ppu=get_pixels_per_unit();
- w=(int)(w/actual_ppu*fixed_zoom_factor);
- }
- edgesmap[i]->setLineWidth(w);
- }
- }
+ double v=mytab.mapstorage.get(mapname, i);
+ int w;
+ if(autoscale)
+ {
+ if(min==max)
+ {
+ w=(int)(edge_property_defaults[E_WIDTH]);
+ }
+ else
+ {
+ w=(int)(minimum_edge_width+(v-min)/(max-min)*(edge_width-minimum_edge_width));
+ }
+ }
+ else
+ {
+ w=(int)(v*edge_width);
+ }
+ if(w<0)
+ {
+ edgesmap[i]->hide();
+ }
+ else
+ {
+ edgesmap[i]->show();
+ if(w<minimum_edge_width)
+ {
+ w=minimum_edge_width;
+ }
+ if(zoomtrack)
+ {
+ double actual_ppu=get_pixels_per_unit();
+ w=(int)(w/actual_ppu*fixed_zoom_factor);
+ }
+ edgesmap[i]->setLineWidth(w);
+ }
}
+ }
else
+ {
+ int w=(int)mytab.mapstorage.get(mapname, edge);
+ if(w>=0)
{
- int w=(int)(*actual_map)[edge];
- if(w>=0)
- {
- edgesmap[edge]->setLineWidth(w);
- }
+ edgesmap[edge]->setLineWidth(w);
}
+ }
return 0;
};
@@ -130,8 +128,6 @@
//function maps the range of the maximum and
//the minimum of the nodemap to the range of
//green in RGB
- Graph::EdgeMap<double> * actual_map;
- actual_map=((mytab.mapstorage).edgemap_storage)[mapname];
double max, min;
@@ -142,7 +138,7 @@
{
for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
{
- double w=(*actual_map)[i];
+ double w=mytab.mapstorage.get(mapname, i);
Gdk::Color color;
if(max!=min)
@@ -160,7 +156,7 @@
{
Gdk::Color color;
- double w=(*actual_map)[edge];
+ double w=mytab.mapstorage.get(mapname, edge);
if(max!=min)
{
@@ -190,40 +186,40 @@
min=edge_property_defaults[E_COLOR];
if(edge==INVALID)
+ {
+ for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
{
- for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- double w=actual_map[i];
+ double w=actual_map[i];
- Gdk::Color color;
- if(max!=min)
- {
- color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
- }
- else
- {
- color.set_rgb_p (0, 100, 0);
- }
- edgesmap[i]->setFillColor(color);
- }
- }
- else
- {
Gdk::Color color;
-
- double w=actual_map[edge];
-
if(max!=min)
- {
- color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
- }
+ {
+ color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
+ }
else
- {
- color.set_rgb_p (0, 100, 0);
- }
+ {
+ color.set_rgb_p (0, 100, 0);
+ }
+ edgesmap[i]->setFillColor(color);
+ }
+ }
+ else
+ {
+ Gdk::Color color;
- edgesmap[edge]->setFillColor(color);
+ double w=actual_map[edge];
+
+ if(max!=min)
+ {
+ color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
}
+ else
+ {
+ color.set_rgb_p (0, 100, 0);
+ }
+
+ edgesmap[edge]->setFillColor(color);
+ }
return 0;
};
@@ -239,7 +235,7 @@
for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
{
edgemap_to_edit=mapname;
- double number=(*((mytab.mapstorage).edgemap_storage)[mapname])[i];
+ double number=mytab.mapstorage.get(mapname, i);
std::ostringstream ostr;
ostr << number;
@@ -250,7 +246,7 @@
}
else
{
- double number=(*((mytab.mapstorage).edgemap_storage)[mapname])[edge];
+ double number=mytab.mapstorage.get(mapname, edge);
std::ostringstream ostr;
ostr << number;
Modified: glemon/branches/akos/graph_displayer_canvas-event.cc
==============================================================================
--- glemon/branches/akos/graph_displayer_canvas-event.cc (original)
+++ glemon/branches/akos/graph_displayer_canvas-event.cc Wed Nov 22 15:13:49 2006
@@ -31,63 +31,63 @@
void GraphDisplayerCanvas::changeEditorialTool(int newtool)
{
if(actual_tool!=newtool)
+ {
+
+ actual_handler.disconnect();
+
+ switch(actual_tool)
+ {
+ case CREATE_EDGE:
+ {
+ GdkEvent * generated=new GdkEvent();
+ generated->type=GDK_BUTTON_RELEASE;
+ generated->button.button=3;
+ createEdgeEventHandler(generated);
+ break;
+ }
+ case MAP_EDIT:
+ {
+ break;
+ }
+ default:
+ break;
+ }
+
+ active_item=NULL;
+ target_item=NULL;
+ active_edge=INVALID;
+ active_node=INVALID;
+
+
+ actual_tool=newtool;
+
+ switch(newtool)
{
+ case MOVE:
+ actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
+ break;
+
+ case CREATE_NODE:
+ actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
+ break;
+
+ case CREATE_EDGE:
+ actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
+ break;
+
+ case ERASER:
+ actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
+ break;
- actual_handler.disconnect();
+ case MAP_EDIT:
+ grab_focus();
+ actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
+ break;
- switch(actual_tool)
- {
- case CREATE_EDGE:
- {
- GdkEvent * generated=new GdkEvent();
- generated->type=GDK_BUTTON_RELEASE;
- generated->button.button=3;
- createEdgeEventHandler(generated);
- break;
- }
- case MAP_EDIT:
- {
- break;
- }
- default:
- break;
- }
-
- active_item=NULL;
- target_item=NULL;
- active_edge=INVALID;
- active_node=INVALID;
-
-
- actual_tool=newtool;
-
- switch(newtool)
- {
- case MOVE:
- actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
- break;
-
- case CREATE_NODE:
- actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
- break;
-
- case CREATE_EDGE:
- actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
- break;
-
- case ERASER:
- actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
- break;
-
- case MAP_EDIT:
- grab_focus();
- actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
- break;
-
- default:
- break;
- }
+ default:
+ break;
}
+ }
}
int GraphDisplayerCanvas::getActualTool()
@@ -99,28 +99,28 @@
{
static Gnome::Canvas::Text *coord_text = 0;
switch(e->type)
- {
+ {
case GDK_BUTTON_PRESS:
//we mark the location of the event to be able to calculate parameters of dragging
window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-
+
active_item=(get_item_at(clicked_x, clicked_y));
active_node=INVALID;
for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- if(nodesmap[i]==active_item)
- {
- active_node=i;
- }
- }
+ {
+ if(nodesmap[i]==active_item)
+ {
+ active_node=i;
+ }
+ }
isbutton=e->button.button;
break;
case GDK_BUTTON_RELEASE:
if (coord_text)
- {
- delete coord_text;
- coord_text = 0;
- }
+ {
+ delete coord_text;
+ coord_text = 0;
+ }
isbutton=0;
active_item=NULL;
active_node=INVALID;
@@ -128,65 +128,65 @@
case GDK_MOTION_NOTIFY:
//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
if(active_node!=INVALID)
- {
- (mytab.mapstorage).modified = true;
-
- //new coordinates will be the old values,
- //because the item will be moved to the
- //new coordinate therefore the new movement
- //has to be calculated from here
-
- double new_x, new_y;
-
- window_to_world (e->motion.x, e->motion.y, new_x, new_y);
-
- double dx=new_x-clicked_x;
- double dy=new_y-clicked_y;
-
- moveNode(dx, dy);
-
- clicked_x=new_x;
- clicked_y=new_y;
-
- // reposition the coordinates text
- std::ostringstream ostr;
- ostr << "(" <<
- (mytab.mapstorage).coords[active_node].x << ", " <<
- (mytab.mapstorage).coords[active_node].y << ")";
- double radius =
- (nodesmap[active_node]->property_x2().get_value() -
- nodesmap[active_node]->property_x1().get_value()) / 2.0;
- if (coord_text)
- {
- coord_text->property_text().set_value(ostr.str());
- coord_text->property_x().set_value((mytab.mapstorage).coords[active_node].x +
- radius);
- coord_text->property_y().set_value((mytab.mapstorage).coords[active_node].y -
- radius);
- }
- else
- {
- coord_text = new Gnome::Canvas::Text(
- displayed_graph,
- (mytab.mapstorage).coords[active_node].x + radius,
- (mytab.mapstorage).coords[active_node].y - radius,
- ostr.str());
- coord_text->property_fill_color().set_value("black");
- coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
- }
+ {
+ mytab.mapstorage.setModified();
+
+ //new coordinates will be the old values,
+ //because the item will be moved to the
+ //new coordinate therefore the new movement
+ //has to be calculated from here
+
+ double new_x, new_y;
+
+ window_to_world (e->motion.x, e->motion.y, new_x, new_y);
+
+ double dx=new_x-clicked_x;
+ double dy=new_y-clicked_y;
+
+ moveNode(dx, dy);
+
+ clicked_x=new_x;
+ clicked_y=new_y;
+
+ // reposition the coordinates text
+ std::ostringstream ostr;
+ ostr << "(" <<
+ mytab.mapstorage.getNodeCoords(active_node).x << ", " <<
+ mytab.mapstorage.getNodeCoords(active_node).y << ")";
+ double radius =
+ (nodesmap[active_node]->property_x2().get_value() -
+ nodesmap[active_node]->property_x1().get_value()) / 2.0;
+ if (coord_text)
+ {
+ coord_text->property_text().set_value(ostr.str());
+ coord_text->property_x().set_value(
+ mytab.mapstorage.getNodeCoords(active_node).x + radius);
+ coord_text->property_y().set_value(
+ mytab.mapstorage.getNodeCoords(active_node).y - radius);
+ }
+ else
+ {
+ coord_text = new Gnome::Canvas::Text(
+ displayed_graph,
+ mytab.mapstorage.getNodeCoords(active_node).x + radius,
+ mytab.mapstorage.getNodeCoords(active_node).y - radius,
+ ostr.str());
+ coord_text->property_fill_color().set_value("black");
+ coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
+ }
- }
+ }
default: break;
- }
+ }
-return false;
+ return false;
}
XY GraphDisplayerCanvas::calcArrowPos(XY moved_node_1, XY moved_node_2, XY fix_node, XY old_arrow_pos, int move_code)
{
switch(move_code)
- {
+ {
case 1:
return XY((moved_node_2.x + fix_node.x) / 2.0, (moved_node_2.y + fix_node.y) / 2.0);
break;
@@ -195,52 +195,52 @@
break;
case 3:
{
- //////////////////////////////////////////////////////////////////////////////////////////////////////
- /////////// keeps shape-with scalar multiplication - version 2.
- //////////////////////////////////////////////////////////////////////////////////////////////////////
-
- //old vector from one to the other node - a
- XY a_v(moved_node_1.x-fix_node.x,moved_node_1.y-fix_node.y);
- //new vector from one to the other node - b
- XY b_v(moved_node_2.x-fix_node.x,moved_node_2.y-fix_node.y);
-
- double absa=sqrt(a_v.normSquare());
- double absb=sqrt(b_v.normSquare());
-
- if ((absa == 0.0) || (absb == 0.0))
- {
- return old_arrow_pos;
- }
- else
- {
- //old vector from one node to the breakpoint - c
- XY c_v(old_arrow_pos.x-fix_node.x,old_arrow_pos.y-fix_node.y);
-
- //unit vector with the same direction to a_v
- XY a_v_u(a_v.x/absa,a_v.y/absa);
-
- //normal vector of unit vector with the same direction to a_v
- XY a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
-
- //unit vector with the same direction to b_v
- XY b_v_u(b_v.x/absb,b_v.y/absb);
-
- //normal vector of unit vector with the same direction to b_v
- XY b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
-
- //vector c in a_v_u and a_v_u_n co-ordinate system
- XY c_a(c_v*a_v_u,c_v*a_v_u_n);
-
- //new vector from one node to the breakpoint - d - we have to calculate this one
- XY d_v=absb/absa*(c_a.x*b_v_u+c_a.y*b_v_u_n);
-
- return XY(d_v.x+fix_node.x,d_v.y+fix_node.y);
- }
- break;
+ //////////////////////////////////////////////////////////////////////////////////////////////////////
+ /////////// keeps shape-with scalar multiplication - version 2.
+ //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ //old vector from one to the other node - a
+ XY a_v(moved_node_1.x-fix_node.x,moved_node_1.y-fix_node.y);
+ //new vector from one to the other node - b
+ XY b_v(moved_node_2.x-fix_node.x,moved_node_2.y-fix_node.y);
+
+ double absa=sqrt(a_v.normSquare());
+ double absb=sqrt(b_v.normSquare());
+
+ if ((absa == 0.0) || (absb == 0.0))
+ {
+ return old_arrow_pos;
+ }
+ else
+ {
+ //old vector from one node to the breakpoint - c
+ XY c_v(old_arrow_pos.x-fix_node.x,old_arrow_pos.y-fix_node.y);
+
+ //unit vector with the same direction to a_v
+ XY a_v_u(a_v.x/absa,a_v.y/absa);
+
+ //normal vector of unit vector with the same direction to a_v
+ XY a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
+
+ //unit vector with the same direction to b_v
+ XY b_v_u(b_v.x/absb,b_v.y/absb);
+
+ //normal vector of unit vector with the same direction to b_v
+ XY b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
+
+ //vector c in a_v_u and a_v_u_n co-ordinate system
+ XY c_a(c_v*a_v_u,c_v*a_v_u_n);
+
+ //new vector from one node to the breakpoint - d - we have to calculate this one
+ XY d_v=absb/absa*(c_a.x*b_v_u+c_a.y*b_v_u_n);
+
+ return XY(d_v.x+fix_node.x,d_v.y+fix_node.y);
+ }
+ break;
}
default:
break;
- }
+ }
}
@@ -260,7 +260,7 @@
}
case GDK_BUTTON_RELEASE:
- (mytab.mapstorage).modified = true;
+ mytab.mapstorage.setModified();
is_drawn=true;
@@ -273,7 +273,7 @@
window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
// update coordinates
- (mytab.mapstorage).coords.set(active_node, XY(clicked_x, clicked_y));
+ mytab.mapstorage.setNodeCoords(active_node, XY(clicked_x, clicked_y));
// update all other maps
for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
@@ -307,7 +307,7 @@
nodetextmap[active_node]->property_fill_color().set_value("darkblue");
nodetextmap[active_node]->raise_to_top();
-// mapwin.updateNode(active_node);
+ // mapwin.updateNode(active_node);
propertyUpdate(active_node);
isbutton=0;
@@ -377,7 +377,7 @@
//the clicked item is a node, the edge can be drawn
if(target_node!=INVALID)
{
- (mytab.mapstorage).modified = true;
+ mytab.mapstorage.setModified();
*(nodesmap[target_node]) <<
Gnome::Canvas::Properties::fill_color("red");
@@ -403,8 +403,8 @@
// set the coordinates of the arrow on the new edge
MapStorage& ms = mytab.mapstorage;
ms.arrow_pos.set(active_edge,
- (ms.coords[ms.graph.source(active_edge)] +
- ms.coords[ms.graph.target(active_edge)])/ 2.0);
+ (ms.getNodeCoords(ms.graph.source(active_edge)) +
+ ms.getNodeCoords(ms.graph.target(active_edge)))/ 2.0);
//drawing new edge
edgesmap[active_edge]=new BrokenEdge(displayed_graph, active_edge,
@@ -415,7 +415,7 @@
// set the coordinates of the arrow on the new edge
MapStorage& ms = mytab.mapstorage;
ms.arrow_pos.set(active_edge,
- (ms.coords[ms.graph.source(active_edge)] +
+ (ms.getNodeCoords(ms.graph.source(active_edge)) +
XY(0.0, 80.0)));
//drawing new edge
@@ -453,12 +453,12 @@
{
if(active_item)
{
- propertyUpdate(active_node,N_COLOR);
+ propertyUpdate(active_node,N_COLOR);
active_item=NULL;
}
if(target_item)
{
- propertyUpdate((mytab.mapstorage).graph.target(active_edge),N_COLOR);
+ propertyUpdate((mytab.mapstorage).graph.target(active_edge),N_COLOR);
target_item=NULL;
}
active_node=INVALID;
@@ -474,7 +474,7 @@
bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
{
switch(e->type)
- {
+ {
case GDK_BUTTON_PRESS:
//finding the clicked items
window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
@@ -483,87 +483,87 @@
active_edge=INVALID;
//was it a node?
for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- if(nodesmap[i]==active_item)
- {
- active_node=i;
- }
- }
+ {
+ if(nodesmap[i]==active_item)
+ {
+ active_node=i;
+ }
+ }
//or was it an edge?
if(active_node==INVALID)
- {
- for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- if(edgesmap[i]->getLine()==active_item)
- {
- active_edge=i;
- }
- }
- }
+ {
+ for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
+ {
+ if(edgesmap[i]->getLine()==active_item)
+ {
+ active_edge=i;
+ }
+ }
+ }
// return if the clicked object is neither an edge nor a node
if (active_edge == INVALID) return false;
-
+
//recolor activated item
if(active_item)
- {
- *active_item << Gnome::Canvas::Properties::fill_color("red");
- }
+ {
+ *active_item << Gnome::Canvas::Properties::fill_color("red");
+ }
break;
case GDK_BUTTON_RELEASE:
window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
if(active_item)
- {
- //the cursor was not moved since pressing it
- if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
- {
- //a node was found
- if(active_node!=INVALID)
- {
- (mytab.mapstorage).modified = true;
-
- std::set<Graph::Edge> edges_to_delete;
-
- for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
- {
- edges_to_delete.insert(e);
- }
-
- for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
- {
- edges_to_delete.insert(e);
- }
-
- //deleting collected edges
- for(std::set<Graph::Edge>::iterator
- edge_set_it=edges_to_delete.begin();
- edge_set_it!=edges_to_delete.end();
- ++edge_set_it)
- {
- deleteItem(*edge_set_it);
- }
- deleteItem(active_node);
- }
- //a simple edge was chosen
- else if (active_edge != INVALID)
- {
- deleteItem(active_edge);
- }
- }
- //pointer was moved, deletion is cancelled
- else
- {
- if(active_node!=INVALID)
- {
- *active_item << Gnome::Canvas::Properties::fill_color("blue");
- }
- else if (active_edge != INVALID)
- {
- *active_item << Gnome::Canvas::Properties::fill_color("green");
- }
- }
- }
+ {
+ //the cursor was not moved since pressing it
+ if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
+ {
+ //a node was found
+ if(active_node!=INVALID)
+ {
+ mytab.mapstorage.setModified();
+
+ std::set<Graph::Edge> edges_to_delete;
+
+ for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
+ {
+ edges_to_delete.insert(e);
+ }
+
+ for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
+ {
+ edges_to_delete.insert(e);
+ }
+
+ //deleting collected edges
+ for(std::set<Graph::Edge>::iterator
+ edge_set_it=edges_to_delete.begin();
+ edge_set_it!=edges_to_delete.end();
+ ++edge_set_it)
+ {
+ deleteItem(*edge_set_it);
+ }
+ deleteItem(active_node);
+ }
+ //a simple edge was chosen
+ else if (active_edge != INVALID)
+ {
+ deleteItem(active_edge);
+ }
+ }
+ //pointer was moved, deletion is cancelled
+ else
+ {
+ if(active_node!=INVALID)
+ {
+ *active_item << Gnome::Canvas::Properties::fill_color("blue");
+ }
+ else if (active_edge != INVALID)
+ {
+ *active_item << Gnome::Canvas::Properties::fill_color("green");
+ }
+ }
+ }
//reseting datas
active_item=NULL;
active_edge=INVALID;
@@ -575,167 +575,167 @@
default:
break;
- }
+ }
return false;
}
bool GraphDisplayerCanvas::mapEditEventHandler(GdkEvent* e)
{
if(actual_tool==MAP_EDIT)
+ {
+ switch(e->type)
{
- switch(e->type)
- {
- case GDK_BUTTON_PRESS:
- {
- //for determine, whether it was an edge
- Edge clicked_edge=INVALID;
- //for determine, whether it was a node
- Node clicked_node=INVALID;
-
- window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
- active_item=(get_item_at(clicked_x, clicked_y));
-
- //find the activated item between text of nodes
- for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- //at the same time only one can be active
- if(nodetextmap[i]==active_item)
- {
- clicked_node=i;
- }
- }
-
- //if there was not, search for it between nodes
- if(clicked_node==INVALID)
- {
- for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- //at the same time only one can be active
- if(nodesmap[i]==active_item)
- {
- clicked_node=i;
- }
- }
- }
-
- if(clicked_node==INVALID)
- {
- //find the activated item between texts
- for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- //at the same time only one can be active
- if(edgetextmap[i]==active_item)
- {
- clicked_edge=i;
- }
- }
-
- //if it was not between texts, search for it between edges
- if(clicked_edge==INVALID)
- {
- for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
- {
- //at the same time only one can be active
- if((edgesmap[i]->getLine())==active_item)
- {
- clicked_edge=i;
- }
- }
- }
- }
-
- //if it was really a node...
- if(clicked_node!=INVALID)
- {
- // the id map is not editable
- if (nodemap_to_edit == "label") return 0;
-
- //and there is activated map
- if(nodetextmap[clicked_node]->property_text().get_value()!="")
- {
- //activate the general variable for it
- active_node=clicked_node;
-
- //create a dialog
- Gtk::Dialog dialog("Edit value", true);
- dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
- dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
- Gtk::VBox* vbox = dialog.get_vbox();
- Gtk::SpinButton spin(0.0, 4);
- spin.set_increments(1.0, 10.0);
- spin.set_range(-1000000.0, 1000000.0);
- spin.set_numeric(true);
- spin.set_value(atof(nodetextmap[active_node]->property_text().get_value().c_str()));
- vbox->add(spin);
- spin.show();
- switch (dialog.run())
- {
- case Gtk::RESPONSE_NONE:
- case Gtk::RESPONSE_CANCEL:
- break;
- case Gtk::RESPONSE_ACCEPT:
- double new_value = spin.get_value();
- (*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
- new_value;
- std::ostringstream ostr;
- ostr << new_value;
- nodetextmap[active_node]->property_text().set_value(ostr.str());
- //mapwin.updateNode(active_node);
- //mapwin.updateNode(Node(INVALID));
- propertyUpdate(Node(INVALID));
- }
- }
- }
- else
- //if it was really an edge...
- if(clicked_edge!=INVALID)
- {
- // the id map is not editable
- if (edgemap_to_edit == "label") return 0;
-
- //and there is activated map
- if(edgetextmap[clicked_edge]->property_text().get_value()!="")
- {
- //activate the general variable for it
- active_edge=clicked_edge;
-
- //create a dialog
- Gtk::Dialog dialog("Edit value", true);
- dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
- dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
- Gtk::VBox* vbox = dialog.get_vbox();
- Gtk::SpinButton spin(0.0, 4);
- spin.set_increments(1.0, 10.0);
- spin.set_range(-1000000.0, 1000000.0);
- spin.set_numeric(true);
- spin.set_value(atof(edgetextmap[active_edge]->property_text().get_value().c_str()));
- vbox->add(spin);
- spin.show();
- switch (dialog.run())
- {
- case Gtk::RESPONSE_NONE:
- case Gtk::RESPONSE_CANCEL:
- break;
- case Gtk::RESPONSE_ACCEPT:
- double new_value = spin.get_value();
- (*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
- new_value;
- std::ostringstream ostr;
- ostr << new_value;
- edgetextmap[active_edge]->property_text().set_value(
- ostr.str());
- //mapwin.updateEdge(active_edge);
- // mapwin.updateEdge(Edge(INVALID));
- propertyUpdate(Edge(INVALID));
- }
- }
- }
- break;
- }
- default:
- break;
- }
+ case GDK_BUTTON_PRESS:
+ {
+ //for determine, whether it was an edge
+ Edge clicked_edge=INVALID;
+ //for determine, whether it was a node
+ Node clicked_node=INVALID;
+
+ window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
+ active_item=(get_item_at(clicked_x, clicked_y));
+
+ //find the activated item between text of nodes
+ for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
+ {
+ //at the same time only one can be active
+ if(nodetextmap[i]==active_item)
+ {
+ clicked_node=i;
+ }
+ }
+
+ //if there was not, search for it between nodes
+ if(clicked_node==INVALID)
+ {
+ for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
+ {
+ //at the same time only one can be active
+ if(nodesmap[i]==active_item)
+ {
+ clicked_node=i;
+ }
+ }
+ }
+
+ if(clicked_node==INVALID)
+ {
+ //find the activated item between texts
+ for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
+ {
+ //at the same time only one can be active
+ if(edgetextmap[i]==active_item)
+ {
+ clicked_edge=i;
+ }
+ }
+
+ //if it was not between texts, search for it between edges
+ if(clicked_edge==INVALID)
+ {
+ for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
+ {
+ //at the same time only one can be active
+ if((edgesmap[i]->getLine())==active_item)
+ {
+ clicked_edge=i;
+ }
+ }
+ }
+ }
+
+ //if it was really a node...
+ if(clicked_node!=INVALID)
+ {
+ // the id map is not editable
+ if (nodemap_to_edit == "label") return 0;
+
+ //and there is activated map
+ if(nodetextmap[clicked_node]->property_text().get_value()!="")
+ {
+ //activate the general variable for it
+ active_node=clicked_node;
+
+ //create a dialog
+ Gtk::Dialog dialog("Edit value", true);
+ dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
+ dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
+ Gtk::VBox* vbox = dialog.get_vbox();
+ Gtk::SpinButton spin(0.0, 4);
+ spin.set_increments(1.0, 10.0);
+ spin.set_range(-1000000.0, 1000000.0);
+ spin.set_numeric(true);
+ spin.set_value(atof(nodetextmap[active_node]->property_text().get_value().c_str()));
+ vbox->add(spin);
+ spin.show();
+ switch (dialog.run())
+ {
+ case Gtk::RESPONSE_NONE:
+ case Gtk::RESPONSE_CANCEL:
+ break;
+ case Gtk::RESPONSE_ACCEPT:
+ double new_value = spin.get_value();
+ (*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
+ new_value;
+ std::ostringstream ostr;
+ ostr << new_value;
+ nodetextmap[active_node]->property_text().set_value(ostr.str());
+ //mapwin.updateNode(active_node);
+ //mapwin.updateNode(Node(INVALID));
+ propertyUpdate(Node(INVALID));
+ }
+ }
+ }
+ else
+ //if it was really an edge...
+ if(clicked_edge!=INVALID)
+ {
+ // the id map is not editable
+ if (edgemap_to_edit == "label") return 0;
+
+ //and there is activated map
+ if(edgetextmap[clicked_edge]->property_text().get_value()!="")
+ {
+ //activate the general variable for it
+ active_edge=clicked_edge;
+
+ //create a dialog
+ Gtk::Dialog dialog("Edit value", true);
+ dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
+ dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
+ Gtk::VBox* vbox = dialog.get_vbox();
+ Gtk::SpinButton spin(0.0, 4);
+ spin.set_increments(1.0, 10.0);
+ spin.set_range(-1000000.0, 1000000.0);
+ spin.set_numeric(true);
+ spin.set_value(atof(edgetextmap[active_edge]->property_text().get_value().c_str()));
+ vbox->add(spin);
+ spin.show();
+ switch (dialog.run())
+ {
+ case Gtk::RESPONSE_NONE:
+ case Gtk::RESPONSE_CANCEL:
+ break;
+ case Gtk::RESPONSE_ACCEPT:
+ double new_value = spin.get_value();
+ (*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
+ new_value;
+ std::ostringstream ostr;
+ ostr << new_value;
+ edgetextmap[active_edge]->property_text().set_value(
+ ostr.str());
+ //mapwin.updateEdge(active_edge);
+ // mapwin.updateEdge(Edge(INVALID));
+ propertyUpdate(Edge(INVALID));
+ }
+ }
+ }
+ break;
+ }
+ default:
+ break;
}
+ }
return false;
}
@@ -780,16 +780,16 @@
}
}
else
+ {
+ if(forming_edge!=INVALID)
+ {
+ forming_edge=INVALID;
+ }
+ else
{
- if(forming_edge!=INVALID)
- {
- forming_edge=INVALID;
- }
- else
- {
- std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
- }
+ std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
}
+ }
}
void GraphDisplayerCanvas::moveNode(double dx, double dy, Gnome::Canvas::Item * item, Node node)
@@ -798,46 +798,68 @@
Node moved_node=node;
if(item==NULL && node==INVALID)
- {
- moved_item=active_item;
- moved_node=active_node;
- }
+ {
+ moved_item=active_item;
+ moved_node=active_node;
+ }
else
- {
- isbutton=1;
- }
+ {
+ isbutton=1;
+ }
//repositioning node and its text
moved_item->move(dx, dy);
nodetextmap[moved_node]->move(dx, dy);
// the new coordinates of the centre of the node
- double coord_x = dx + (mytab.mapstorage).coords[moved_node].x;
- double coord_y = dy + (mytab.mapstorage).coords[moved_node].y;
+ double coord_x = dx + mytab.mapstorage.getNodeCoords(moved_node).x;
+ double coord_y = dy + mytab.mapstorage.getNodeCoords(moved_node).y;
// write back the new coordinates to the coords map
- (mytab.mapstorage).coords.set(moved_node, XY(coord_x, coord_y));
+ mytab.mapstorage.setNodeCoords(moved_node, XY(coord_x, coord_y));
//all the edges connected to the moved point has to be redrawn
for(OutEdgeIt ei((mytab.mapstorage).graph,moved_node);ei!=INVALID;++ei)
+ {
+ XY arrow_pos;
+
+ if (mytab.mapstorage.graph.source(ei) == mytab.mapstorage.graph.target(ei))
{
- XY arrow_pos;
+ arrow_pos = mytab.mapstorage.arrow_pos[ei] + XY(dx, dy);
+ }
+ else
+ {
+ XY moved_node_1(coord_x - dx, coord_y - dy);
+ XY moved_node_2(coord_x, coord_y);
+ Node target = mytab.mapstorage.graph.target(ei);
+ XY fix_node = mytab.mapstorage.getNodeCoords(target);
+ XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
+
+ arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
+ }
+
+ mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
+ edgesmap[ei]->draw();
+
+ //reposition of edgetext
+ XY text_pos=mytab.mapstorage.arrow_pos[ei];
+ text_pos+=(XY(10,10));
+ edgetextmap[ei]->property_x().set_value(text_pos.x);
+ edgetextmap[ei]->property_y().set_value(text_pos.y);
+ }
- if (mytab.mapstorage.graph.source(ei) == mytab.mapstorage.graph.target(ei))
- {
- arrow_pos = mytab.mapstorage.arrow_pos[ei] + XY(dx, dy);
- }
- else
- {
- XY moved_node_1(coord_x - dx, coord_y - dy);
- XY moved_node_2(coord_x, coord_y);
- Node target = mytab.mapstorage.graph.target(ei);
- XY fix_node(mytab.mapstorage.coords[target].x,
- mytab.mapstorage.coords[target].y);
- XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
+ for(InEdgeIt ei((mytab.mapstorage).graph,moved_node);ei!=INVALID;++ei)
+ {
+ if (mytab.mapstorage.graph.source(ei) != mytab.mapstorage.graph.target(ei))
+ {
+ XY moved_node_1(coord_x - dx, coord_y - dy);
+ XY moved_node_2(coord_x, coord_y);
+ Node source = mytab.mapstorage.graph.source(ei);
+ XY fix_node = mytab.mapstorage.getNodeCoords(source);
+ XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
- arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
- }
+ XY arrow_pos;
+ arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
edgesmap[ei]->draw();
@@ -848,31 +870,7 @@
edgetextmap[ei]->property_x().set_value(text_pos.x);
edgetextmap[ei]->property_y().set_value(text_pos.y);
}
-
- for(InEdgeIt ei((mytab.mapstorage).graph,moved_node);ei!=INVALID;++ei)
- {
- if (mytab.mapstorage.graph.source(ei) != mytab.mapstorage.graph.target(ei))
- {
- XY moved_node_1(coord_x - dx, coord_y - dy);
- XY moved_node_2(coord_x, coord_y);
- Node source = mytab.mapstorage.graph.source(ei);
- XY fix_node(mytab.mapstorage.coords[source].x,
- mytab.mapstorage.coords[source].y);
- XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
-
- XY arrow_pos;
- arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
-
- mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
- edgesmap[ei]->draw();
-
- //reposition of edgetext
- XY text_pos=mytab.mapstorage.arrow_pos[ei];
- text_pos+=(XY(10,10));
- edgetextmap[ei]->property_x().set_value(text_pos.x);
- edgetextmap[ei]->property_y().set_value(text_pos.y);
- }
- }
+ }
}
Gdk::Color GraphDisplayerCanvas::rainbowColorCounter(double min, double max, double w)
@@ -887,48 +885,48 @@
//first we determine the phase, in which
//the actual value belongs to
for (int i=0;i<=5;i++)
+ {
+ if(((double)i/6<pos)&&(pos<=(double(i+1)/6)))
{
- if(((double)i/6<pos)&&(pos<=(double(i+1)/6)))
- {
- phase=i;
- }
+ phase=i;
}
+ }
if(phase<6)
+ {
+ //within its 1/6 long phase the relativ position
+ //determines the power of the color changed in
+ //that phase
+ //we normalize that to one, to be able to give percentage
+ //value for the function
+ double rel_pos=(pos-(phase/6))*6;
+
+ switch(phase)
{
- //within its 1/6 long phase the relativ position
- //determines the power of the color changed in
- //that phase
- //we normalize that to one, to be able to give percentage
- //value for the function
- double rel_pos=(pos-(phase/6))*6;
-
- switch(phase)
- {
- case 0:
- color.set_rgb_p (1, 0, 1-rel_pos);
- break;
- case 1:
- color.set_rgb_p (1, rel_pos, 0);
- break;
- case 2:
- color.set_rgb_p (1-rel_pos, 1, 0);
- break;
- case 3:
- color.set_rgb_p (0, 1, rel_pos);
- break;
- case 4:
- color.set_rgb_p (0, 1-rel_pos, 1);
- break;
- case 5:
- color.set_rgb_p ((rel_pos/3), 0, 1);
- break;
- default:
- std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
- }
+ case 0:
+ color.set_rgb_p (1, 0, 1-rel_pos);
+ break;
+ case 1:
+ color.set_rgb_p (1, rel_pos, 0);
+ break;
+ case 2:
+ color.set_rgb_p (1-rel_pos, 1, 0);
+ break;
+ case 3:
+ color.set_rgb_p (0, 1, rel_pos);
+ break;
+ case 4:
+ color.set_rgb_p (0, 1-rel_pos, 1);
+ break;
+ case 5:
+ color.set_rgb_p ((rel_pos/3), 0, 1);
+ break;
+ default:
+ std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
}
+ }
else
- {
- std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
- }
+ {
+ std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
+ }
return color;
}
Modified: glemon/branches/akos/graph_displayer_canvas.cc
==============================================================================
--- glemon/branches/akos/graph_displayer_canvas.cc (original)
+++ glemon/branches/akos/graph_displayer_canvas.cc Wed Nov 22 15:13:49 2006
@@ -84,46 +84,57 @@
std::string mapname=mytab.getActiveNodeMap(prop);
if(is_drawn)
+ {
+ if(mapname!="")
{
- if(mapname!="")
- {
- if( ( ((mytab.mapstorage).nodemap_storage).find(mapname) != ((mytab.mapstorage).nodemap_storage).end() ) )
- {
- switch(prop)
- {
- case N_RADIUS:
- changeNodeRadius(mapname, node);
- break;
- case N_COLOR:
- changeNodeColor(mapname, node);
- break;
- case N_TEXT:
- changeNodeText(mapname, node);
- break;
- default:
- std::cerr<<"Error\n";
- }
- }
- }
- else //mapname==""
- {
- Node node=INVALID;
- switch(prop)
- {
- case N_RADIUS:
- resetNodeRadius(node);
- break;
- case N_COLOR:
- resetNodeColor(node);
- break;
- case N_TEXT:
- resetNodeText(node);
- break;
- default:
- std::cerr<<"Error\n";
- }
- }
+ std::vector<std::string> nodemaps = mytab.mapstorage.getNodeMapList();
+ bool found = false;
+ for (std::vector<std::string>::const_iterator it = nodemaps.begin();
+ it != nodemaps.end(); ++it)
+ {
+ if (*it == mapname)
+ {
+ found = true;
+ break;
+ }
+ }
+ if (found)
+ {
+ switch(prop)
+ {
+ case N_RADIUS:
+ changeNodeRadius(mapname, node);
+ break;
+ case N_COLOR:
+ changeNodeColor(mapname, node);
+ break;
+ case N_TEXT:
+ changeNodeText(mapname, node);
+ break;
+ default:
+ std::cerr<<"Error\n";
+ }
+ }
+ }
+ else //mapname==""
+ {
+ Node node=INVALID;
+ switch(prop)
+ {
+ case N_RADIUS:
+ resetNodeRadius(node);
+ break;
+ case N_COLOR:
+ resetNodeColor(node);
+ break;
+ case N_TEXT:
+ resetNodeText(node);
+ break;
+ default:
+ std::cerr<<"Error\n";
+ }
}
+ }
}
void GraphDisplayerCanvas::propertyUpdate(Edge edge, int prop)
@@ -131,45 +142,56 @@
std::string mapname=mytab.getActiveEdgeMap(prop);
if(is_drawn)
+ {
+ if(mapname!="")
{
- if(mapname!="")
- {
- if( ( ((mytab.mapstorage).edgemap_storage).find(mapname) != ((mytab.mapstorage).edgemap_storage).end() ) )
- {
- switch(prop)
- {
- case E_WIDTH:
- changeEdgeWidth(mapname, edge);
- break;
- case E_COLOR:
- changeEdgeColor(mapname, edge);
- break;
- case E_TEXT:
- changeEdgeText(mapname, edge);
- break;
- default:
- std::cerr<<"Error\n";
- }
- }
- }
- else //mapname==""
- {
- switch(prop)
- {
- case E_WIDTH:
- resetEdgeWidth(edge);
- break;
- case E_COLOR:
- resetEdgeColor(edge);
- break;
- case E_TEXT:
- resetEdgeText(edge);
- break;
- default:
- std::cerr<<"Error\n";
- }
- }
+ std::vector<std::string> edgemaps = mytab.mapstorage.getEdgeMapList();
+ bool found = false;
+ for (std::vector<std::string>::const_iterator it = edgemaps.begin();
+ it != edgemaps.end(); ++it)
+ {
+ if (*it == mapname)
+ {
+ found = true;
+ break;
+ }
+ }
+ if (found)
+ {
+ switch(prop)
+ {
+ case E_WIDTH:
+ changeEdgeWidth(mapname, edge);
+ break;
+ case E_COLOR:
+ changeEdgeColor(mapname, edge);
+ break;
+ case E_TEXT:
+ changeEdgeText(mapname, edge);
+ break;
+ default:
+ std::cerr<<"Error\n";
+ }
+ }
+ }
+ else //mapname==""
+ {
+ switch(prop)
+ {
+ case E_WIDTH:
+ resetEdgeWidth(edge);
+ break;
+ case E_COLOR:
+ resetEdgeColor(edge);
+ break;
+ case E_TEXT:
+ resetEdgeText(edge);
+ break;
+ default:
+ std::cerr<<"Error\n";
+ }
}
+ }
}
void GraphDisplayerCanvas::drawGraph()
@@ -188,7 +210,7 @@
}
//initializing edge-text as well, to empty string
- XY text_pos=mytab.mapstorage.arrow_pos[i];
+ XY text_pos=mytab.mapstorage.getArrowCoords(i);
text_pos+=(XY(10,10));
edgetextmap[i]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
@@ -205,10 +227,10 @@
nodesmap[i]=new Gnome::Canvas::Ellipse(
displayed_graph,
- (mytab.mapstorage).coords[i].x-20,
- (mytab.mapstorage).coords[i].y-20,
- (mytab.mapstorage).coords[i].x+20,
- (mytab.mapstorage).coords[i].y+20);
+ mytab.mapstorage.getNodeCoords(i).x-20,
+ mytab.mapstorage.getNodeCoords(i).y-20,
+ mytab.mapstorage.getNodeCoords(i).x+20,
+ mytab.mapstorage.getNodeCoords(i).y+20);
*(nodesmap[i]) << Gnome::Canvas::Properties::fill_color("blue");
*(nodesmap[i]) << Gnome::Canvas::Properties::outline_color("black");
nodesmap[i]->raise_to_top();
@@ -216,8 +238,8 @@
//initializing edge-text as well, to empty string
XY text_pos(
- ((mytab.mapstorage).coords[i].x+node_property_defaults[N_RADIUS]+5),
- ((mytab.mapstorage).coords[i].y+node_property_defaults[N_RADIUS]+5));
+ (mytab.mapstorage.getNodeCoords(i).x+node_property_defaults[N_RADIUS]+5),
+ (mytab.mapstorage.getNodeCoords(i).y+node_property_defaults[N_RADIUS]+5));
nodetextmap[i]=new Gnome::Canvas::Text(displayed_graph,
text_pos.x, text_pos.y, "");
@@ -329,8 +351,8 @@
if(i!=j)
{
lemon::dim2::Point<double> delta =
- ((mytab.mapstorage).coords[i]-
- (mytab.mapstorage).coords[j]);
+ (mytab.mapstorage.getNodeCoords(i)-
+ mytab.mapstorage.getNodeCoords(j));
const double length_sqr=std::max(delta.normSquare(),min_dist);
@@ -346,31 +368,29 @@
}
//attraction of nodes, to which actual node is bound
for(OutEdgeIt ei((mytab.mapstorage).graph,i);ei!=INVALID;++ei)
- {
- lemon::dim2::Point<double> delta =
- ((mytab.mapstorage).coords[i]-
- (mytab.mapstorage).coords[mytab.mapstorage.
- graph.target(ei)]);
-
- //calculating attraction strength
- //greater distance means greater strength
- delta*=attraction;
-
- actual_forces.set(i,actual_forces[i]-delta);
- }
+ {
+ lemon::dim2::Point<double> delta =
+ (mytab.mapstorage.getNodeCoords(i)-
+ mytab.mapstorage.getNodeCoords(mytab.mapstorage.graph.target(ei)));
+
+ //calculating attraction strength
+ //greater distance means greater strength
+ delta*=attraction;
+
+ actual_forces.set(i,actual_forces[i]-delta);
+ }
for(InEdgeIt ei((mytab.mapstorage).graph,i);ei!=INVALID;++ei)
- {
- lemon::dim2::Point<double> delta =
- ((mytab.mapstorage).coords[i]-
- (mytab.mapstorage).coords[mytab.mapstorage.
- graph.source(ei)]);
-
- //calculating attraction strength
- //greater distance means greater strength
- delta*=attraction;
-
- actual_forces.set(i,actual_forces[i]-delta);
- }
+ {
+ lemon::dim2::Point<double> delta =
+ (mytab.mapstorage.getNodeCoords(i)-
+ mytab.mapstorage.getNodeCoords(mytab.mapstorage.graph.source(ei)));
+
+ //calculating attraction strength
+ //greater distance means greater strength
+ delta*=attraction;
+
+ actual_forces.set(i,actual_forces[i]-delta);
+ }
}
for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
{
Modified: glemon/branches/akos/mapstorage.cc
==============================================================================
--- glemon/branches/akos/mapstorage.cc (original)
+++ glemon/branches/akos/mapstorage.cc Wed Nov 22 15:13:49 2006
@@ -27,7 +27,7 @@
#include <string>
#include <gtkmm.h>
-const double i_d=20;
+const int i_d=20;
const double a_d=0.05;
const double p_d=40000;
@@ -610,3 +610,63 @@
{
signal_design_win.emit(attraction, propulsation, iterations);
}
+
+XY MapStorage::getNodeCoords(Node n) const
+{
+ return coords[n];
+}
+
+void MapStorage::setNodeCoords(Node n, XY c)
+{
+ coords.set(n, c);
+}
+
+XY MapStorage::getArrowCoords(Edge e) const
+{
+ return arrow_pos[e];
+}
+
+void MapStorage::setArrowCoords(Edge e, XY c)
+{
+ arrow_pos.set(e, c);
+}
+
+double MapStorage::get(const std::string& map, Node n) const
+{
+ return nodemap_storage.find(map)->second->operator[](n);
+}
+
+void MapStorage::set(const std::string& map, Node n, double val)
+{
+ nodemap_storage[map]->set(n, val);
+}
+
+double MapStorage::get(const std::string& map, Edge e) const
+{
+ return edgemap_storage.find(map)->second->operator[](e);
+}
+
+void MapStorage::set(const std::string& map, Edge e, double val)
+{
+ edgemap_storage[map]->set(e, val);
+}
+
+const std::string& MapStorage::getFileName() const
+{
+ return file_name;
+}
+
+void MapStorage::setFileName(const std::string& fn)
+{
+ file_name = fn;
+}
+
+bool MapStorage::getModified() const
+{
+ return modified;
+}
+
+void MapStorage::setModified(bool m)
+{
+ modified = m;
+}
Modified: glemon/branches/akos/mapstorage.h
==============================================================================
--- glemon/branches/akos/mapstorage.h (original)
+++ glemon/branches/akos/mapstorage.h Wed Nov 22 15:13:49 2006
@@ -38,28 +38,31 @@
///\todo too many things are public!!
class MapStorage
{
-public:
- enum value {DOUBLE, STRING};
- enum type {NORMAL, GUI};
-
- ///The graph for which the datas are stored.
- Graph graph;
+private:
/// the coordinates of the nodes
XYMap<Graph::NodeMap<double> > coords;
+
/// the coordinates of the arrows on the edges
XYMap<Graph::EdgeMap<double> > arrow_pos;
+ ///Stores double type EdgeMaps
+ std::map< std::string,Graph::EdgeMap<double> * > edgemap_storage;
+
+ ///Stores double type NodeMaps
+ std::map< std::string,Graph::NodeMap<double> * > nodemap_storage;
+
///The content of the object has changed, update is needed.
bool modified;
///Name of file loaded in object.
std::string file_name;
- ///Stores double type NodeMaps
- std::map< std::string,Graph::NodeMap<double> * > nodemap_storage;
+public:
+ enum value {DOUBLE, STRING};
+ enum type {NORMAL, GUI};
- ///Stores double type EdgeMaps
- std::map< std::string,Graph::EdgeMap<double> * > edgemap_storage;
+ ///The graph for which the datas are stored.
+ Graph graph;
///Stores the default values for the different visualization node attributes
std::vector<Graph::NodeMap<double> > default_nodemaps;
@@ -282,6 +285,22 @@
void set_iteration(int);
void redesign_data_changed();
+
+ XY getNodeCoords(Node n) const;
+ void setNodeCoords(Node n, XY c);
+ XY getArrowCoords(Edge e) const;
+ void setArrowCoords(Edge e, XY c);
+
+ double get(const std::string& map, Node n) const;
+ void set(const std::string& map, Node n, double val);
+ double get(const std::string& map, Edge e) const;
+ void set(const std::string& map, Edge e, double val);
+
+ const std::string& getFileName() const;
+ void setFileName(const std::string& fn);
+
+ bool getModified() const;
+ void setModified(bool m = true);
};
#endif //MAPSTORAGE_H
More information about the Lemon-commits
mailing list