COIN-OR::LEMON - Graph Library

Context Navigation

source: glemon-0.x/graph_displayer_canvas-event.cc @ 96:e664d8aa3f72

gui

Last change on this file since 96:e664d8aa3f72 was 96:e664d8aa3f72, checked in by Hegyi Péter, 18 years ago
Notebook style is provided. Without opportunity to close tabs. :-) But with all other necessary things (I think).
Property exe set to ``*
File size: 24.0 KB

Rev	Line
[53]	1	#include "graph_displayer_canvas.h"
[59]	2	#include <cmath>
[27]	3
	4
	5	bool GraphDisplayerCanvas::on_expose_event(GdkEventExpose *event)
	6	{
	7	Gnome::Canvas::CanvasAA::on_expose_event(event);
	8	//usleep(10000);
	9	//rezoom();
	10	return true;
	11	}
	12
	13	void GraphDisplayerCanvas::changeEditorialTool(int newtool)
	14	{
[34]	15	if(actual_tool!=newtool)
	16	{
[27]	17
[34]	18	actual_handler.disconnect();
[27]	19
[34]	20	switch(actual_tool)
	21	{
	22	case CREATE_EDGE:
	23	{
	24	GdkEvent * generated=new GdkEvent();
	25	generated->type=GDK_BUTTON_RELEASE;
	26	generated->button.button=3;
	27	createEdgeEventHandler(generated);
	28	break;
	29	}
	30	case EDGE_MAP_EDIT:
[35]	31	//has to do the same thing as in the case of NODE_MAP_EDIT
	32	case NODE_MAP_EDIT:
	33	{
	34	break;
	35	}
[34]	36	default:
	37	break;
	38	}
[27]	39
[34]	40	active_item=NULL;
	41	target_item=NULL;
	42	active_edge=INVALID;
	43	active_node=INVALID;
[33]	44
[27]	45
[34]	46	actual_tool=newtool;
	47
	48	switch(newtool)
	49	{
	50	case MOVE:
	51	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
	52	break;
[27]	53
[34]	54	case CREATE_NODE:
	55	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
	56	break;
[27]	57
[34]	58	case CREATE_EDGE:
	59	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
	60	break;
[27]	61
[34]	62	case ERASER:
	63	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
	64	break;
[32]	65
[34]	66	case EDGE_MAP_EDIT:
	67	grab_focus();
	68	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::edgeMapEditEventHandler), false);
	69	break;
[32]	70
[34]	71	case NODE_MAP_EDIT:
	72	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::nodeMapEditEventHandler), false);
	73	break;
	74
	75	default:
	76	break;
	77	}
[27]	78	}
	79	}
	80
[30]	81	int GraphDisplayerCanvas::getActualTool()
[27]	82	{
	83	return actual_tool;
	84	}
	85
[30]	86	bool GraphDisplayerCanvas::moveEventHandler(GdkEvent* e)
[27]	87	{
[70]	88	static Gnome::Canvas::Text *coord_text = 0;
[27]	89	switch(e->type)
	90	{
	91	case GDK_BUTTON_PRESS:
	92	//we mark the location of the event to be able to calculate parameters of dragging
[31]	93	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	94
	95	active_item=(get_item_at(clicked_x, clicked_y));
[27]	96	active_node=INVALID;
[96]	97	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	98	{
	99	if(nodesmap[i]==active_item)
	100	{
	101	active_node=i;
	102	}
	103	}
	104	switch(e->button.button)
	105	{
	106	case 3:
	107	isbutton=3;
	108	break;
	109	default:
	110	isbutton=1;
	111	break;
	112	}
	113	break;
	114	case GDK_BUTTON_RELEASE:
[70]	115	if (coord_text)
	116	{
	117	delete coord_text;
	118	coord_text = 0;
	119	}
[27]	120	isbutton=0;
	121	active_item=NULL;
	122	active_node=INVALID;
	123	break;
	124	case GDK_MOTION_NOTIFY:
	125	//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
	126	if(active_node!=INVALID)
	127	{
[96]	128	(mytab.mapstorage).modified = true;
[70]	129
[27]	130	//new coordinates will be the old values,
	131	//because the item will be moved to the
	132	//new coordinate therefore the new movement
	133	//has to be calculated from here
	134
[31]	135	double new_x, new_y;
	136
	137	window_to_world (e->motion.x, e->motion.y, new_x, new_y);
	138
	139	double dx=new_x-clicked_x;
	140	double dy=new_y-clicked_y;
[27]	141
[28]	142	//repositioning node and its text
[27]	143	active_item->move(dx, dy);
[28]	144	nodetextmap[active_node]->move(dx, dy);
[27]	145
[70]	146	// the new coordinates of the centre of the node
[96]	147	double coord_x = new_x - (clicked_x - (mytab.mapstorage).coords[active_node].x);
	148	double coord_y = new_y - (clicked_y - (mytab.mapstorage).coords[active_node].y);
[70]	149
[31]	150	clicked_x=new_x;
	151	clicked_y=new_y;
[27]	152
[70]	153	// write back the new coordinates to the coords map
[96]	154	(mytab.mapstorage).coords.set(active_node, xy<double>(coord_x, coord_y));
[27]	155
[70]	156	// reposition the coordinates text
	157	std::ostringstream ostr;
	158	ostr << "(" <<
[96]	159	(mytab.mapstorage).coords[active_node].x << ", " <<
	160	(mytab.mapstorage).coords[active_node].y << ")";
[72]	161	double radius =
	162	(nodesmap[active_node]->property_x2().get_value() -
	163	nodesmap[active_node]->property_x1().get_value()) / 2.0;
[70]	164	if (coord_text)
	165	{
	166	coord_text->property_text().set_value(ostr.str());
[96]	167	coord_text->property_x().set_value((mytab.mapstorage).coords[active_node].x +
[72]	168	radius);
[96]	169	coord_text->property_y().set_value((mytab.mapstorage).coords[active_node].y -
[72]	170	radius);
[70]	171	}
	172	else
	173	{
	174	coord_text = new Gnome::Canvas::Text(
	175	displayed_graph,
[96]	176	(mytab.mapstorage).coords[active_node].x + radius,
	177	(mytab.mapstorage).coords[active_node].y - radius,
[70]	178	ostr.str());
	179	coord_text->property_fill_color().set_value("black");
[72]	180	coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
[70]	181	}
	182
	183	//all the edges connected to the moved point has to be redrawn
[96]	184	for(OutEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
[27]	185	{
	186	Gnome::Canvas::Points coos;
	187	double x1, x2, y1, y2;
	188
[96]	189	nodesmap[(mytab.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
[27]	190	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	191
[96]	192	nodesmap[(mytab.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
[27]	193	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	194
	195	if(isbutton==3)
	196	{
[30]	197	edgesmap[ei]->setPoints(coos);
[27]	198	}
	199	else
	200	{
[30]	201	edgesmap[ei]->setPoints(coos,true);
[27]	202	}
	203
[28]	204	//reposition of edgetext
[30]	205	xy<double> text_pos=edgesmap[ei]->getArrowPos();
[27]	206	text_pos+=(xy<double>(10,10));
	207	edgetextmap[ei]->property_x().set_value(text_pos.x);
	208	edgetextmap[ei]->property_y().set_value(text_pos.y);
	209	}
	210
[96]	211	for(InEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
[27]	212	{
	213	Gnome::Canvas::Points coos;
	214	double x1, x2, y1, y2;
	215
[96]	216	nodesmap[(mytab.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
[27]	217	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	218
[96]	219	nodesmap[(mytab.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
[27]	220	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	221
	222	if(isbutton==3)
	223	{
[30]	224	edgesmap[ei]->setPoints(coos);
[27]	225	}
	226	else
	227	{
[30]	228	edgesmap[ei]->setPoints(coos,true);
[27]	229	}
	230
[30]	231	xy<double> text_pos=edgesmap[ei]->getArrowPos();
[27]	232	text_pos+=(xy<double>(10,10));
	233	edgetextmap[ei]->property_x().set_value(text_pos.x);
	234	edgetextmap[ei]->property_y().set_value(text_pos.y);
	235	}
	236	}
	237	default: break;
	238	}
	239
[31]	240	return false;
[27]	241	}
	242
[30]	243	bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
[27]	244	{
	245	switch(e->type)
[63]	246	{
	247	//move the new node
	248	case GDK_MOTION_NOTIFY:
	249	{
	250	GdkEvent * generated=new GdkEvent();
	251	generated->motion.x=e->motion.x;
	252	generated->motion.y=e->motion.y;
	253	generated->type=GDK_MOTION_NOTIFY;
	254	moveEventHandler(generated);
	255	break;
	256	}
[27]	257
[63]	258	case GDK_BUTTON_RELEASE:
[96]	259	(mytab.mapstorage).modified = true;
[53]	260
[27]	261	isbutton=1;
	262
[96]	263	active_node=(mytab.mapstorage).graph.addNode();
[27]	264
	265	//initiating values corresponding to new node in maps
	266
	267	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	268
[63]	269	// update coordinates
[96]	270	(mytab.mapstorage).coords.set(active_node, xy<double>(clicked_x, clicked_y));
[63]	271
	272	// update all other maps
	273	for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
[96]	274	(mytab.mapstorage).nodemap_storage.begin(); it !=
	275	(mytab.mapstorage).nodemap_storage.end(); ++it)
[63]	276	{
[64]	277	if ((it->first != "coordinates_x") &&
	278	(it->first != "coordinates_y"))
[63]	279	{
	280	(*(it->second))[active_node] =
[96]	281	(mytab.mapstorage).nodemap_default[it->first];
[63]	282	}
	283	}
[64]	284	// increment the id map's default value
[96]	285	(mytab.mapstorage).nodemap_default["id"] += 1.0;
[63]	286
[53]	287	nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
[63]	288	clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
[27]	289	active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
[63]	290	*(nodesmap[active_node]) <<
	291	Gnome::Canvas::Properties::fill_color("blue");
	292	*(nodesmap[active_node]) <<
	293	Gnome::Canvas::Properties::outline_color("black");
	294	active_item->raise_to_top();
	295
[27]	296	(nodesmap[active_node])->show();
[28]	297
[53]	298	nodetextmap[active_node]=new Gnome::Canvas::Text(displayed_graph,
[63]	299	clicked_x+node_property_defaults[N_RADIUS]+5,
	300	clicked_y+node_property_defaults[N_RADIUS]+5, "");
[28]	301	nodetextmap[active_node]->property_fill_color().set_value("darkblue");
[63]	302	nodetextmap[active_node]->raise_to_top();
[28]	303
[94]	304	// mapwin.updateNode(active_node);
	305	propertyUpdate(active_node);
[28]	306
[27]	307	isbutton=0;
[31]	308	target_item=NULL;
[27]	309	active_item=NULL;
	310	active_node=INVALID;
	311	break;
	312	default:
	313	break;
[63]	314	}
[27]	315	return false;
	316	}
	317
[30]	318	bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
[27]	319	{
	320	switch(e->type)
[63]	321	{
[27]	322	case GDK_BUTTON_PRESS:
	323	//in edge creation right button has special meaning
	324	if(e->button.button!=3)
[63]	325	{
	326	//there is not yet selected node
	327	if(active_node==INVALID)
	328	{
	329	//we mark the location of the event to be able to calculate parameters of dragging
[31]	330
[63]	331	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
[31]	332
[63]	333	active_item=(get_item_at(clicked_x, clicked_y));
	334	active_node=INVALID;
[96]	335	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[63]	336	{
	337	if(nodesmap[i]==active_item)
	338	{
	339	active_node=i;
	340	}
	341	}
	342	//the clicked item is really a node
	343	if(active_node!=INVALID)
	344	{
	345	*(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
	346	isbutton=1;
	347	}
	348	//clicked item was not a node. It could be e.g. edge.
	349	else
	350	{
	351	active_item=NULL;
	352	}
	353	}
	354	//we only have to do sg. if the mouse button
	355	// is pressed already once AND the click was
	356	// on a node that was found in the set of
	357	//nodes, and now we only search for the second
	358	//node
	359	else
	360	{
	361	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	362	target_item=(get_item_at(clicked_x, clicked_y));
	363	Node target_node=INVALID;
[96]	364	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[63]	365	{
	366	if(nodesmap[i]==target_item)
	367	{
	368	target_node=i;
	369	}
	370	}
	371	//the clicked item is a node, the edge can be drawn
	372	if(target_node!=INVALID)
	373	{
	374	if(target_node!=active_node)
	375	{
[96]	376	(mytab.mapstorage).modified = true;
[53]	377
[63]	378	*(nodesmap[target_node]) <<
	379	Gnome::Canvas::Properties::fill_color("red");
[27]	380
[63]	381	//creating new edge
[96]	382	active_edge=(mytab.mapstorage).graph.addEdge(active_node,
[63]	383	target_node);
[27]	384
[64]	385	// update maps
[63]	386	for (std::map<std::string,
	387	Graph::EdgeMap<double>*>::const_iterator it =
[96]	388	(mytab.mapstorage).edgemap_storage.begin(); it !=
	389	(mytab.mapstorage).edgemap_storage.end(); ++it)
[63]	390	{
[64]	391	(*(it->second))[active_edge] =
[96]	392	(mytab.mapstorage).edgemap_default[it->first];
[63]	393	}
[64]	394	// increment the id map's default value
[96]	395	(mytab.mapstorage).edgemap_default["id"] += 1.0;
[27]	396
[63]	397	//calculating coordinates of new edge
	398	Gnome::Canvas::Points coos;
	399	double x1, x2, y1, y2;
[27]	400
[63]	401	active_item->get_bounds(x1, y1, x2, y2);
	402	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
[27]	403
[63]	404	target_item->get_bounds(x1, y1, x2, y2);
	405	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
[27]	406
[63]	407	//drawing new edge
	408	edgesmap[active_edge]=new BrokenEdge(displayed_graph, coos,
	409	*this);
	410	*(edgesmap[active_edge]) <<
	411	Gnome::Canvas::Properties::fill_color("green");
	412	edgesmap[active_edge]->property_width_pixels().set_value(10);
[27]	413
[63]	414	edgesmap[active_edge]->lower_to_bottom();
[28]	415
[63]	416	//initializing edge-text as well, to empty string
	417	xy<double> text_pos=edgesmap[active_edge]->getArrowPos();
	418	text_pos+=(xy<double>(10,10));
	419
	420	edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph,
	421	text_pos.x, text_pos.y, "");
	422	edgetextmap[active_edge]->property_fill_color().set_value(
	423	"darkgreen");
	424	edgetextmap[active_edge]->raise_to_top();
	425
	426	//updating its properties
[94]	427	// mapwin.updateEdge(active_edge);
	428	propertyUpdate(active_edge);
[63]	429	}
	430	else
	431	{
	432	target_node=INVALID;
	433	std::cerr << "Loop edge is not yet implemented!" << std::endl;
	434	}
	435	}
	436	//clicked item was not a node. it could be an e.g. edge. we do not
	437	//deal with it furthermore.
	438	else
	439	{
	440	target_item=NULL;
	441	}
	442	}
	443	}
[27]	444	break;
	445	case GDK_BUTTON_RELEASE:
	446	isbutton=0;
	447	//we clear settings in two cases
	448	//1: the edge is ready (target_item has valid value)
	449	//2: the edge creation is cancelled with right button
	450	if((target_item)\|\|(e->button.button==3))
[63]	451	{
	452	if(active_item)
	453	{
	454	*active_item << Gnome::Canvas::Properties::fill_color("blue");
	455	active_item=NULL;
	456	}
	457	if(target_item)
	458	{
	459	*target_item << Gnome::Canvas::Properties::fill_color("blue");
	460	target_item=NULL;
	461	}
	462	active_node=INVALID;
	463	active_edge=INVALID;
	464	}
[27]	465	break;
	466	default:
	467	break;
[63]	468	}
[27]	469	return false;
	470	}
	471
[30]	472	bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
[27]	473	{
	474	switch(e->type)
	475	{
	476	case GDK_BUTTON_PRESS:
[43]	477	//finding the clicked items
[31]	478	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	479	active_item=(get_item_at(clicked_x, clicked_y));
[27]	480	active_node=INVALID;
	481	active_edge=INVALID;
[43]	482	//was it a node?
[96]	483	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	484	{
	485	if(nodesmap[i]==active_item)
	486	{
	487	active_node=i;
	488	}
	489	}
[43]	490	//or was it an edge?
[27]	491	if(active_node==INVALID)
	492	{
[96]	493	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	494	{
	495	if(edgesmap[i]==active_item)
	496	{
	497	active_edge=i;
	498	}
	499	}
	500	}
[43]	501
	502	//recolor activated item
[31]	503	if(active_item)
	504	{
	505	*active_item << Gnome::Canvas::Properties::fill_color("red");
	506	}
[27]	507	break;
	508
	509	case GDK_BUTTON_RELEASE:
[31]	510	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	511	if(active_item)
[27]	512	{
[43]	513	//the cursor was not moved since pressing it
[31]	514	if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
[27]	515	{
[43]	516	//a node was found
[31]	517	if(active_node!=INVALID)
	518	{
[96]	519	(mytab.mapstorage).modified = true;
[27]	520
[31]	521	std::set<Graph::Edge> edges_to_delete;
[27]	522
[96]	523	for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
[31]	524	{
	525	edges_to_delete.insert(e);
	526	}
[69]	527
[96]	528	for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
[31]	529	{
	530	edges_to_delete.insert(e);
	531	}
[69]	532
[31]	533	//deleting collected edges
[69]	534	for(std::set<Graph::Edge>::iterator
	535	edge_set_it=edges_to_delete.begin();
	536	edge_set_it!=edges_to_delete.end();
	537	++edge_set_it)
[31]	538	{
	539	deleteItem(*edge_set_it);
	540	}
	541	deleteItem(active_node);
	542	}
	543	//a simple edge was chosen
	544	else
[27]	545	{
[31]	546	deleteItem(active_edge);
[27]	547	}
	548	}
[31]	549	//pointer was moved, deletion is cancelled
[27]	550	else
	551	{
[31]	552	if(active_node!=INVALID)
	553	{
	554	*active_item << Gnome::Canvas::Properties::fill_color("blue");
	555	}
	556	else
	557	{
	558	*active_item << Gnome::Canvas::Properties::fill_color("green");
	559	}
[27]	560	}
	561	}
	562	//reseting datas
	563	active_item=NULL;
	564	active_edge=INVALID;
	565	active_node=INVALID;
	566	break;
	567
	568	case GDK_MOTION_NOTIFY:
	569	break;
	570
	571	default:
	572	break;
	573	}
[31]	574	return false;
[27]	575	}
	576
[32]	577	bool GraphDisplayerCanvas::edgeMapEditEventHandler(GdkEvent* e)
	578	{
[48]	579	if(actual_tool==EDGE_MAP_EDIT)
[66]	580	{
	581	switch(e->type)
[32]	582	{
[66]	583	case GDK_BUTTON_PRESS:
	584	{
	585	//for determine, whether it was an edge
	586	Edge clicked_edge=INVALID;
[43]	587
[66]	588	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	589	active_item=(get_item_at(clicked_x, clicked_y));
[48]	590
[66]	591	//find the activated item between texts
[96]	592	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	593	{
	594	//at the same time only one can be active
	595	if(edgetextmap[i]==active_item)
	596	{
	597	clicked_edge=i;
	598	}
	599	}
[65]	600
[66]	601	//if it was not between texts, search for it between edges
	602	if(clicked_edge==INVALID)
	603	{
[96]	604	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	605	{
	606	//at the same time only one can be active
	607	if((edgesmap[i]==active_item)\|\|(edgetextmap[i]==active_item))
	608	{
	609	clicked_edge=i;
	610	}
	611	}
	612	}
	613
	614	//if it was really an edge...
	615	if(clicked_edge!=INVALID)
	616	{
	617	// the id map is not editable
	618	if (edgemap_to_edit == "id") return 0;
[48]	619
[66]	620	//and there is activated map
	621	if(edgetextmap[clicked_edge]->property_text().get_value()!="")
	622	{
	623	//activate the general variable for it
	624	active_edge=clicked_edge;
[48]	625
[66]	626	//create a dialog
[96]	627	Gtk::Dialog dialog("Edit value", true);
[66]	628	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	629	dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
	630	Gtk::VBox* vbox = dialog.get_vbox();
[92]	631	Gtk::SpinButton spin(0.0, 4);
	632	spin.set_increments(1.0, 10.0);
	633	spin.set_range(-1000000.0, 1000000.0);
[66]	634	spin.set_numeric(true);
	635	vbox->add(spin);
	636	spin.show();
	637	switch (dialog.run())
	638	{
	639	case Gtk::RESPONSE_NONE:
	640	case Gtk::RESPONSE_CANCEL:
	641	break;
	642	case Gtk::RESPONSE_ACCEPT:
	643	double new_value = spin.get_value();
[96]	644	(*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
[66]	645	new_value;
	646	std::ostringstream ostr;
	647	ostr << new_value;
	648	edgetextmap[active_edge]->property_text().set_value(
	649	ostr.str());
	650	//mapwin.updateEdge(active_edge);
[94]	651	// mapwin.updateEdge(Edge(INVALID));
	652	propertyUpdate(Edge(INVALID));
[66]	653	}
	654	}
	655	}
	656	break;
	657	}
	658	default:
	659	break;
[32]	660	}
[66]	661	}
[32]	662	return false;
	663	}
	664
	665	bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
	666	{
[48]	667	if(actual_tool==NODE_MAP_EDIT)
[66]	668	{
	669	switch(e->type)
[35]	670	{
[66]	671	case GDK_BUTTON_PRESS:
	672	{
	673	//for determine, whether it was a node
	674	Node clicked_node=INVALID;
[43]	675
[66]	676	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	677	active_item=(get_item_at(clicked_x, clicked_y));
[43]	678
[66]	679	//find the activated item between texts
[96]	680	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	681	{
	682	//at the same time only one can be active
	683	if(nodetextmap[i]==active_item)
	684	{
	685	clicked_node=i;
	686	}
	687	}
[48]	688
[66]	689	//if there was not, search for it between nodes
	690	if(clicked_node==INVALID)
	691	{
[96]	692	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	693	{
	694	//at the same time only one can be active
	695	if(nodesmap[i]==active_item)
	696	{
	697	clicked_node=i;
	698	}
	699	}
	700	}
[48]	701
[66]	702	//if it was really a node...
	703	if(clicked_node!=INVALID)
	704	{
	705	// the id map is not editable
	706	if (nodemap_to_edit == "id") return 0;
[48]	707
[66]	708	//and there is activated map
	709	if(nodetextmap[clicked_node]->property_text().get_value()!="")
	710	{
	711	//activate the general variable for it
	712	active_node=clicked_node;
[48]	713
[66]	714	//create a dialog
[96]	715	Gtk::Dialog dialog("Edit value", true);
[66]	716	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	717	dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
	718	Gtk::VBox* vbox = dialog.get_vbox();
[92]	719	Gtk::SpinButton spin(0.0, 4);
	720	spin.set_increments(1.0, 10.0);
	721	spin.set_range(-1000000.0, 1000000.0);
[66]	722	spin.set_numeric(true);
	723	vbox->add(spin);
	724	spin.show();
	725	switch (dialog.run())
	726	{
	727	case Gtk::RESPONSE_NONE:
	728	case Gtk::RESPONSE_CANCEL:
	729	break;
	730	case Gtk::RESPONSE_ACCEPT:
	731	double new_value = spin.get_value();
[96]	732	(*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
[66]	733	new_value;
	734	std::ostringstream ostr;
	735	ostr << new_value;
	736	nodetextmap[active_node]->property_text().set_value(
	737	ostr.str());
	738	//mapwin.updateNode(active_node);
[94]	739	// mapwin.updateNode(Node(INVALID));
	740	propertyUpdate(Node(INVALID));
[66]	741	}
	742	}
	743	}
	744	break;
	745	}
	746	default:
	747	break;
[35]	748	}
[66]	749	}
[35]	750	return false;
[32]	751	}
	752
[62]	753	void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
[27]	754	{
[28]	755	delete(nodetextmap[node_to_delete]);
[27]	756	delete(nodesmap[node_to_delete]);
[96]	757	(mytab.mapstorage).graph.erase(node_to_delete);
[27]	758	}
	759
[62]	760	void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
[27]	761	{
[28]	762	delete(edgetextmap[edge_to_delete]);
[27]	763	delete(edgesmap[edge_to_delete]);
[96]	764	(mytab.mapstorage).graph.erase(edge_to_delete);
[27]	765	}
	766
[30]	767	void GraphDisplayerCanvas::textReposition(xy<double> new_place)
[27]	768	{
	769	new_place+=(xy<double>(10,10));
[35]	770	edgetextmap[forming_edge]->property_x().set_value(new_place.x);
	771	edgetextmap[forming_edge]->property_y().set_value(new_place.y);
[27]	772	}
	773
[30]	774	void GraphDisplayerCanvas::toggleEdgeActivity(BrokenEdge* active_bre, bool on)
[27]	775	{
	776	if(on)
	777	{
[35]	778	if(forming_edge!=INVALID)
[27]	779	{
[48]	780	std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
[27]	781	}
	782	else
	783	{
[96]	784	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	785	{
	786	if(edgesmap[i]==active_bre)
	787	{
[35]	788	forming_edge=i;
[27]	789	}
	790	}
	791	}
	792	}
	793	else
	794	{
[35]	795	if(forming_edge!=INVALID)
[27]	796	{
[35]	797	forming_edge=INVALID;
[27]	798	}
	799	else
	800	{
[48]	801	std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
[27]	802	}
	803	}
	804
	805	}
[32]	806
[46]	807	int GraphDisplayerCanvas::addNewEdgeMap(double default_value, std::string mapname)
[37]	808	{
[43]	809	//create the new map
[96]	810	Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> ((mytab.mapstorage).graph, default_value);
[46]	811
	812	//if addition was not successful addEdgeMap returns one.
	813	//cause can be that there is already a map named like the new one
[96]	814	if((mytab.mapstorage).addEdgeMap(mapname,emptr, default_value))
[46]	815	{
	816	return 1;
	817	}
	818
[43]	819
	820	//add it to the list of the displayable maps
[96]	821	mytab.registerNewEdgeMap(mapname);
[43]	822
	823	//display it
[41]	824	changeEdgeText(mapname);
[46]	825
	826	return 0;
[37]	827	}
	828
[46]	829	int GraphDisplayerCanvas::addNewNodeMap(double default_value, std::string mapname)
[37]	830	{
[43]	831	//create the new map
[96]	832	Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> ((mytab.mapstorage).graph,default_value);
[46]	833
	834	//if addition was not successful addNodeMap returns one.
	835	//cause can be that there is already a map named like the new one
[96]	836	if((mytab.mapstorage).addNodeMap(mapname,emptr, default_value))
[46]	837	{
	838	return 1;
	839	}
[43]	840
	841	//add it to the list of the displayable maps
[96]	842	mytab.registerNewNodeMap(mapname);
[43]	843
	844	//display it
[41]	845	changeNodeText(mapname);
[46]	846
	847	return 0;
[37]	848	}
	849

Note: See TracBrowser for help on using the repository browser.

Download in other formats: