COIN-OR::LEMON - Graph Library

Context Navigation

source: glemon-0.x/graph_displayer_canvas-event.cc @ 70:2ee22e690853

gui

Last change on this file since 70:2ee22e690853 was 70:2ee22e690853, checked in by Akos Ladanyi, 19 years ago
Display the node's coordinates while moving it.
Property exe set to ``*
File size: 23.9 KB

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

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

Download in other formats: