COIN-OR::LEMON - Graph Library

Context Navigation

source: glemon-0.x/graph_displayer_canvas-event.cc @ 64:7a32d528857f

gui

Last change on this file since 64:7a32d528857f was 64:7a32d528857f, checked in by Akos Ladanyi, 19 years ago
handle the case when there is no id map in the edgeset section do not use ListGraph?.id() to determine the id of a new node/edge
Property exe set to ``*
File size: 26.0 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	GdkEvent * generated=new GdkEvent();
	36	generated->type=GDK_KEY_PRESS;
	37	((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
	38	entryWidgetChangeHandler(generated);
	39	entrywidget.hide();
	40	break;
	41	}
[34]	42	default:
	43	break;
	44	}
[27]	45
[34]	46	active_item=NULL;
	47	target_item=NULL;
	48	active_edge=INVALID;
	49	active_node=INVALID;
[33]	50
[27]	51
[34]	52	actual_tool=newtool;
	53
	54	switch(newtool)
	55	{
	56	case MOVE:
	57	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
	58	break;
[27]	59
[34]	60	case CREATE_NODE:
	61	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
	62	break;
[27]	63
[34]	64	case CREATE_EDGE:
	65	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
	66	break;
[27]	67
[34]	68	case ERASER:
	69	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
	70	break;
[32]	71
[34]	72	case EDGE_MAP_EDIT:
	73	grab_focus();
	74	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::edgeMapEditEventHandler), false);
	75	break;
[32]	76
[34]	77	case NODE_MAP_EDIT:
	78	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::nodeMapEditEventHandler), false);
	79	break;
	80
	81	default:
	82	break;
	83	}
[27]	84	}
	85	}
	86
[30]	87	int GraphDisplayerCanvas::getActualTool()
[27]	88	{
	89	return actual_tool;
	90	}
	91
[30]	92	bool GraphDisplayerCanvas::moveEventHandler(GdkEvent* e)
[27]	93	{
	94	switch(e->type)
	95	{
	96	case GDK_BUTTON_PRESS:
	97	//we mark the location of the event to be able to calculate parameters of dragging
[31]	98	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	99
	100	active_item=(get_item_at(clicked_x, clicked_y));
[27]	101	active_node=INVALID;
[53]	102	for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
[27]	103	{
	104	if(nodesmap[i]==active_item)
	105	{
	106	active_node=i;
	107	}
	108	}
	109	switch(e->button.button)
	110	{
	111	case 3:
	112	isbutton=3;
	113	break;
	114	default:
	115	isbutton=1;
	116	break;
	117	}
	118	break;
	119	case GDK_BUTTON_RELEASE:
	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	{
[53]	128	mapstorage.modified = true;
	129	mapstorage.coords.set(active_node, xy<double>(clicked_x, clicked_y));
[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
[31]	146	clicked_x=new_x;
	147	clicked_y=new_y;
[27]	148
	149	//all the edges connected to the moved point has to be redrawn
	150	EdgeIt ei;
	151
[53]	152	mapstorage.graph.firstOut(ei,active_node);
[27]	153
[53]	154	for(;ei!=INVALID;mapstorage.graph.nextOut(ei))
[27]	155	{
	156	Gnome::Canvas::Points coos;
	157	double x1, x2, y1, y2;
	158
[53]	159	nodesmap[mapstorage.graph.source(ei)]->get_bounds(x1, y1, x2, y2);
[27]	160	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	161
[53]	162	nodesmap[mapstorage.graph.target(ei)]->get_bounds(x1, y1, x2, y2);
[27]	163	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	164
	165	if(isbutton==3)
	166	{
[30]	167	edgesmap[ei]->setPoints(coos);
[27]	168	}
	169	else
	170	{
[30]	171	edgesmap[ei]->setPoints(coos,true);
[27]	172	}
	173
[28]	174	//reposition of edgetext
[30]	175	xy<double> text_pos=edgesmap[ei]->getArrowPos();
[27]	176	text_pos+=(xy<double>(10,10));
	177	edgetextmap[ei]->property_x().set_value(text_pos.x);
	178	edgetextmap[ei]->property_y().set_value(text_pos.y);
	179	}
	180
[53]	181	mapstorage.graph.firstIn(ei,active_node);
	182	for(;ei!=INVALID;mapstorage.graph.nextIn(ei))
[27]	183	{
	184	Gnome::Canvas::Points coos;
	185	double x1, x2, y1, y2;
	186
[53]	187	nodesmap[mapstorage.graph.source(ei)]->get_bounds(x1, y1, x2, y2);
[27]	188	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	189
[53]	190	nodesmap[mapstorage.graph.target(ei)]->get_bounds(x1, y1, x2, y2);
[27]	191	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
	192
	193	if(isbutton==3)
	194	{
[30]	195	edgesmap[ei]->setPoints(coos);
[27]	196	}
	197	else
	198	{
[30]	199	edgesmap[ei]->setPoints(coos,true);
[27]	200	}
	201
[30]	202	xy<double> text_pos=edgesmap[ei]->getArrowPos();
[27]	203	text_pos+=(xy<double>(10,10));
	204	edgetextmap[ei]->property_x().set_value(text_pos.x);
	205	edgetextmap[ei]->property_y().set_value(text_pos.y);
	206	}
	207	}
	208	default: break;
	209	}
	210
[31]	211	return false;
[27]	212	}
	213
[30]	214	bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
[27]	215	{
	216	switch(e->type)
[63]	217	{
	218	//move the new node
	219	case GDK_MOTION_NOTIFY:
	220	{
	221	GdkEvent * generated=new GdkEvent();
	222	generated->motion.x=e->motion.x;
	223	generated->motion.y=e->motion.y;
	224	generated->type=GDK_MOTION_NOTIFY;
	225	moveEventHandler(generated);
	226	break;
	227	}
[27]	228
[63]	229	case GDK_BUTTON_RELEASE:
[53]	230	mapstorage.modified = true;
	231
[27]	232	isbutton=1;
	233
[62]	234	active_node=mapstorage.graph.addNode();
[27]	235
	236	//initiating values corresponding to new node in maps
	237
	238	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	239
[63]	240	// update coordinates
[53]	241	mapstorage.coords.set(active_node, xy<double>(clicked_x, clicked_y));
[63]	242
	243	// update all other maps
	244	for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
	245	mapstorage.nodemap_storage.begin(); it !=
	246	mapstorage.nodemap_storage.end(); ++it)
	247	{
[64]	248	if ((it->first != "coordinates_x") &&
	249	(it->first != "coordinates_y"))
[63]	250	{
	251	(*(it->second))[active_node] =
	252	mapstorage.nodemap_default[it->first];
	253	}
	254	}
[64]	255	// increment the id map's default value
	256	mapstorage.nodemap_default["id"] += 1.0;
[63]	257
[53]	258	nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
[63]	259	clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
[27]	260	active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
[63]	261	*(nodesmap[active_node]) <<
	262	Gnome::Canvas::Properties::fill_color("blue");
	263	*(nodesmap[active_node]) <<
	264	Gnome::Canvas::Properties::outline_color("black");
	265	active_item->raise_to_top();
	266
[27]	267	(nodesmap[active_node])->show();
[28]	268
[53]	269	nodetextmap[active_node]=new Gnome::Canvas::Text(displayed_graph,
[63]	270	clicked_x+node_property_defaults[N_RADIUS]+5,
	271	clicked_y+node_property_defaults[N_RADIUS]+5, "");
[28]	272	nodetextmap[active_node]->property_fill_color().set_value("darkblue");
[63]	273	nodetextmap[active_node]->raise_to_top();
[28]	274
[53]	275	mapwin.updateNode(active_node);
[28]	276
[27]	277	isbutton=0;
[31]	278	target_item=NULL;
[27]	279	active_item=NULL;
	280	active_node=INVALID;
[63]	281
[27]	282	break;
	283	default:
	284	break;
[63]	285	}
[27]	286	return false;
	287	}
	288
[30]	289	bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
[27]	290	{
	291	switch(e->type)
[63]	292	{
[27]	293	case GDK_BUTTON_PRESS:
	294	//in edge creation right button has special meaning
	295	if(e->button.button!=3)
[63]	296	{
	297	//there is not yet selected node
	298	if(active_node==INVALID)
	299	{
	300	//we mark the location of the event to be able to calculate parameters of dragging
[31]	301
[63]	302	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
[31]	303
[63]	304	active_item=(get_item_at(clicked_x, clicked_y));
	305	active_node=INVALID;
	306	for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
	307	{
	308	if(nodesmap[i]==active_item)
	309	{
	310	active_node=i;
	311	}
	312	}
	313	//the clicked item is really a node
	314	if(active_node!=INVALID)
	315	{
	316	*(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
	317	isbutton=1;
	318	}
	319	//clicked item was not a node. It could be e.g. edge.
	320	else
	321	{
	322	active_item=NULL;
	323	}
	324	}
	325	//we only have to do sg. if the mouse button
	326	// is pressed already once AND the click was
	327	// on a node that was found in the set of
	328	//nodes, and now we only search for the second
	329	//node
	330	else
	331	{
	332	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	333	target_item=(get_item_at(clicked_x, clicked_y));
	334	Node target_node=INVALID;
	335	for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
	336	{
	337	if(nodesmap[i]==target_item)
	338	{
	339	target_node=i;
	340	}
	341	}
	342	//the clicked item is a node, the edge can be drawn
	343	if(target_node!=INVALID)
	344	{
	345	if(target_node!=active_node)
	346	{
	347	mapstorage.modified = true;
[53]	348
[63]	349	*(nodesmap[target_node]) <<
	350	Gnome::Canvas::Properties::fill_color("red");
[27]	351
[63]	352	//creating new edge
	353	active_edge=mapstorage.graph.addEdge(active_node,
	354	target_node);
[27]	355
[64]	356	// update maps
[63]	357	for (std::map<std::string,
	358	Graph::EdgeMap<double>*>::const_iterator it =
	359	mapstorage.edgemap_storage.begin(); it !=
	360	mapstorage.edgemap_storage.end(); ++it)
	361	{
[64]	362	(*(it->second))[active_edge] =
	363	mapstorage.edgemap_default[it->first];
[63]	364	}
[64]	365	// increment the id map's default value
	366	mapstorage.edgemap_default["id"] += 1.0;
[27]	367
[63]	368	//calculating coordinates of new edge
	369	Gnome::Canvas::Points coos;
	370	double x1, x2, y1, y2;
[27]	371
[63]	372	active_item->get_bounds(x1, y1, x2, y2);
	373	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
[27]	374
[63]	375	target_item->get_bounds(x1, y1, x2, y2);
	376	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
[27]	377
[63]	378	//drawing new edge
	379	edgesmap[active_edge]=new BrokenEdge(displayed_graph, coos,
	380	*this);
	381	*(edgesmap[active_edge]) <<
	382	Gnome::Canvas::Properties::fill_color("green");
	383	edgesmap[active_edge]->property_width_pixels().set_value(10);
[27]	384
[63]	385	edgesmap[active_edge]->lower_to_bottom();
[28]	386
[63]	387	//initializing edge-text as well, to empty string
	388	xy<double> text_pos=edgesmap[active_edge]->getArrowPos();
	389	text_pos+=(xy<double>(10,10));
	390
	391	edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph,
	392	text_pos.x, text_pos.y, "");
	393	edgetextmap[active_edge]->property_fill_color().set_value(
	394	"darkgreen");
	395	edgetextmap[active_edge]->raise_to_top();
	396
	397	//updating its properties
	398	mapwin.updateEdge(active_edge);
	399	}
	400	else
	401	{
	402	target_node=INVALID;
	403	std::cerr << "Loop edge is not yet implemented!" << std::endl;
	404	}
	405	}
	406	//clicked item was not a node. it could be an e.g. edge. we do not
	407	//deal with it furthermore.
	408	else
	409	{
	410	target_item=NULL;
	411	}
	412	}
	413	}
[27]	414	break;
	415	case GDK_BUTTON_RELEASE:
	416	isbutton=0;
	417	//we clear settings in two cases
	418	//1: the edge is ready (target_item has valid value)
	419	//2: the edge creation is cancelled with right button
	420	if((target_item)\|\|(e->button.button==3))
[63]	421	{
	422	if(active_item)
	423	{
	424	*active_item << Gnome::Canvas::Properties::fill_color("blue");
	425	active_item=NULL;
	426	}
	427	if(target_item)
	428	{
	429	*target_item << Gnome::Canvas::Properties::fill_color("blue");
	430	target_item=NULL;
	431	}
	432	active_node=INVALID;
	433	active_edge=INVALID;
	434	}
[27]	435	break;
	436	default:
	437	break;
[63]	438	}
[27]	439	return false;
	440	}
	441
[30]	442	bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
[27]	443	{
	444	switch(e->type)
	445	{
	446	case GDK_BUTTON_PRESS:
[43]	447	//finding the clicked items
[31]	448	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	449	active_item=(get_item_at(clicked_x, clicked_y));
[27]	450	active_node=INVALID;
	451	active_edge=INVALID;
[43]	452	//was it a node?
[53]	453	for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
[27]	454	{
	455	if(nodesmap[i]==active_item)
	456	{
	457	active_node=i;
	458	}
	459	}
[43]	460	//or was it an edge?
[27]	461	if(active_node==INVALID)
	462	{
[53]	463	for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
[27]	464	{
	465	if(edgesmap[i]==active_item)
	466	{
	467	active_edge=i;
	468	}
	469	}
	470	}
[43]	471
	472	//recolor activated item
[31]	473	if(active_item)
	474	{
	475	*active_item << Gnome::Canvas::Properties::fill_color("red");
	476	}
[27]	477	break;
	478
	479	case GDK_BUTTON_RELEASE:
[31]	480	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	481	if(active_item)
[27]	482	{
[43]	483	//the cursor was not moved since pressing it
[31]	484	if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
[27]	485	{
[43]	486	//a node was found
[31]	487	if(active_node!=INVALID)
	488	{
[53]	489	mapstorage.modified = true;
[27]	490
[31]	491	//collecting edges to delete
	492	EdgeIt e;
	493	std::set<Graph::Edge> edges_to_delete;
[27]	494
[53]	495	mapstorage.graph.firstOut(e,active_node);
	496	for(;e!=INVALID;mapstorage.graph.nextOut(e))
[31]	497	{
	498	edges_to_delete.insert(e);
	499	}
	500
[53]	501	mapstorage.graph.firstIn(e,active_node);
	502	for(;e!=INVALID;mapstorage.graph.nextIn(e))
[31]	503	{
	504	edges_to_delete.insert(e);
	505	}
	506
	507	//deleting collected edges
	508	for(std::set<Graph::Edge>::iterator edge_set_it=edges_to_delete.begin();edge_set_it!=edges_to_delete.end();edge_set_it++)
	509	{
	510	deleteItem(*edge_set_it);
	511	}
	512	deleteItem(active_node);
	513	}
	514	//a simple edge was chosen
	515	else
[27]	516	{
[31]	517	deleteItem(active_edge);
[27]	518	}
	519	}
[31]	520	//pointer was moved, deletion is cancelled
[27]	521	else
	522	{
[31]	523	if(active_node!=INVALID)
	524	{
	525	*active_item << Gnome::Canvas::Properties::fill_color("blue");
	526	}
	527	else
	528	{
	529	*active_item << Gnome::Canvas::Properties::fill_color("green");
	530	}
[27]	531	}
	532	}
	533	//reseting datas
	534	active_item=NULL;
	535	active_edge=INVALID;
	536	active_node=INVALID;
	537	break;
	538
	539	case GDK_MOTION_NOTIFY:
	540	break;
	541
	542	default:
	543	break;
	544	}
[31]	545	return false;
[27]	546	}
	547
[32]	548	bool GraphDisplayerCanvas::edgeMapEditEventHandler(GdkEvent* e)
	549	{
[48]	550	if(actual_tool==EDGE_MAP_EDIT)
[32]	551	{
[48]	552	switch(e->type)
	553	{
	554	case GDK_KEY_PRESS:
	555	//for Escape or Enter hide the displayed widget
	556	{
	557	nodeMapEditEventHandler(e);
	558	break;
	559	}
	560	case GDK_BUTTON_PRESS:
	561	//If the click happened on an edge we place the entrywidget there and fill in the value of the activated map at that edge.
	562	{
	563	//for determine, whether it was an edge
[62]	564	Edge clicked_edge=INVALID;
[43]	565
[48]	566	//find the activated item between texts
	567	active_item=(get_item_at(e->button.x, e->button.y));
[53]	568	for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
[34]	569	{
[48]	570	if(edgetextmap[i]==active_item)
	571	{
	572	clicked_edge=i;
	573	}
[34]	574	}
[48]	575
	576	//if it was not between texts, search for it between edges
	577	if(clicked_edge==INVALID)
[34]	578	{
[48]	579	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	580	active_item=(get_item_at(clicked_x, clicked_y));
	581
[53]	582	for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
[48]	583	{
	584	//at the same time only one can be active
	585	if((edgesmap[i]==active_item)\|\|(edgetextmap[i]==active_item))
	586	{
	587	clicked_edge=i;
	588	}
	589	}
	590	}
	591	//if it was really an edge...
	592	if(clicked_edge!=INVALID)
	593	{
[63]	594	// the id map is not editable
	595	if (nodemap_to_edit == "id") return 0;
[48]	596	//If there is already edited edge, it has to be saved first
	597	if(entrywidget.is_visible())
	598	{
	599	GdkEvent * generated=new GdkEvent();
	600	generated->type=GDK_KEY_PRESS;
	601	((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
	602	entryWidgetChangeHandler(generated);
	603	}
	604	//If the previous value could be saved, we can go further, otherwise not
	605	if(!entrywidget.is_visible())
	606	{
	607	//and there is activated map
	608	if(edgetextmap[clicked_edge]->property_text().get_value()!="")
	609	{
	610	//activate the general variable for it
	611	active_edge=clicked_edge;
	612	//delete visible widget if there is
	613	if(canvasentrywidget)
	614	{
	615	delete(canvasentrywidget);
	616	}
	617
	618	//initialize the entry
	619	entrywidget.show();
	620
	621	//fill in the correct value
	622	entrywidget.set_text(edgetextmap[active_edge]->property_text().get_value());
	623
	624	//replace and resize the entry to the activated edge and put it in a Canvas::Widget to be able to display it on gdc
	625	xy<double> entry_coos;
	626	entry_coos.x=(edgetextmap[active_edge])->property_x().get_value();
	627	entry_coos.x-=edgetextmap[active_edge]->property_text_width().get_value()/2;
	628	entry_coos.y=(edgetextmap[active_edge])->property_y().get_value();
	629	entry_coos.y-=edgetextmap[active_edge]->property_text_height().get_value()*1.5/2;
	630	canvasentrywidget=new Gnome::Canvas::Widget(displayed_graph, entry_coos.x, entry_coos.y, entrywidget);
	631	canvasentrywidget->property_width().set_value(edgetextmap[active_edge]->property_text_width().get_value()*4);
	632	canvasentrywidget->property_height().set_value(edgetextmap[active_edge]->property_text_height().get_value()*1.5);
[55]	633
	634	//setting the focus to newly created widget
	635	parentwin->set_focus(entrywidget);
	636	parentwin->activate_focus();
[48]	637	}
	638	}
	639	}
	640	//if it was not an edge...
	641	else
	642	{
	643	//In this case the click did not happen on an edge
	644	//if there is visible entry we save the value in it
	645	//we pretend like an Enter was presse din the Entry widget
[43]	646	GdkEvent * generated=new GdkEvent();
	647	generated->type=GDK_KEY_PRESS;
	648	((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
	649	entryWidgetChangeHandler(generated);
	650	}
[48]	651	break;
[34]	652	}
[48]	653	default:
	654	break;
	655	}
[32]	656	}
	657	return false;
	658	}
	659
	660	bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
	661	{
[48]	662	if(actual_tool==NODE_MAP_EDIT)
[35]	663	{
[48]	664	switch(e->type)
	665	{
	666	case GDK_KEY_PRESS:
	667	//for Escape or Enter hide the displayed widget
[35]	668	{
[48]	669	switch(((GdkEventKey*)e)->keyval)
	670	{
	671	case GDK_Escape:
	672	entrywidget.hide();
	673	break;
	674	case GDK_Return:
	675	case GDK_KP_Enter:
	676	entrywidget.hide();
	677	break;
	678	default:
	679	break;
	680	}
	681
[35]	682	break;
	683	}
[48]	684	case GDK_BUTTON_PRESS:
	685	//If the click happened on an edge we place the entrywidget there and fill in the value of the activated map at that edge.
	686	{
	687	//for determine, whether it was a node
[62]	688	Node clicked_node=INVALID;
[43]	689
[48]	690	//find the activated item between texts
	691	active_item=(get_item_at(e->button.x, e->button.y));
[53]	692	for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
[35]	693	{
[48]	694	//at the same time only one can be active
	695	if(nodetextmap[i]==active_item)
	696	{
	697	clicked_node=i;
	698	}
[35]	699	}
[43]	700
[48]	701	//if there was not, search for it between nodes
	702	if(clicked_node==INVALID)
[35]	703	{
[48]	704	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	705	active_item=(get_item_at(clicked_x, clicked_y));
	706
[53]	707	for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
[48]	708	{
	709	//at the same time only one can be active
	710	if(nodesmap[i]==active_item)
	711	{
	712	clicked_node=i;
	713	}
	714	}
	715	}
	716	//if it was really an edge...
	717	if(clicked_node!=INVALID)
	718	{
[63]	719	// the id map is not editable
	720	if (nodemap_to_edit == "id") return 0;
[48]	721	//If there is already edited edge, it has to be saved first
	722	if(entrywidget.is_visible())
	723	{
	724	GdkEvent * generated=new GdkEvent();
	725	generated->type=GDK_KEY_PRESS;
	726	((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
	727	entryWidgetChangeHandler(generated);
	728	}
	729	//If the previous value could be saved, we can go further, otherwise not
	730	if(!entrywidget.is_visible())
	731	{
	732	//and there is activated map
	733	if(nodetextmap[clicked_node]->property_text().get_value()!="")
	734	{
	735	//activate the general variable for it
	736	active_node=clicked_node;
	737	//delete visible widget if there is
	738	if(canvasentrywidget)
	739	{
	740	delete(canvasentrywidget);
	741	}
	742
	743	//initialize the entry
	744	entrywidget.show();
	745
	746	//fill in the correct value
	747	entrywidget.set_text(nodetextmap[active_node]->property_text().get_value());
	748
	749	//replace and resize the entry to the activated node and put it in a Canvas::Widget to be able to display it on gdc
	750	xy<double> entry_coos;
	751	entry_coos.x=(nodetextmap[active_node])->property_x().get_value();
	752	entry_coos.x-=nodetextmap[active_node]->property_text_width().get_value()/2;
	753	entry_coos.y=(nodetextmap[active_node])->property_y().get_value();
	754	entry_coos.y-=nodetextmap[active_node]->property_text_height().get_value()*1.5/2;
	755	canvasentrywidget=new Gnome::Canvas::Widget(displayed_graph, entry_coos.x, entry_coos.y, entrywidget);
	756	canvasentrywidget->property_width().set_value(nodetextmap[active_node]->property_text_width().get_value()*4);
	757	canvasentrywidget->property_height().set_value(nodetextmap[active_node]->property_text_height().get_value()*1.5);
	758	}
	759	}
	760	}
	761	//if it was not an edge...
	762	else
	763	{
	764	//In this case the click did not happen on an edge
	765	//if there is visible entry we save the value in it
	766	//we pretend like an Enter was presse din the Entry widget
[35]	767	GdkEvent * generated=new GdkEvent();
	768	generated->type=GDK_KEY_PRESS;
	769	((GdkEventKey*)generated)->keyval=GDK_KP_Enter;
	770	entryWidgetChangeHandler(generated);
	771	}
[48]	772	break;
[35]	773	}
[48]	774	default:
	775	break;
	776	}
[35]	777	}
	778	return false;
[32]	779	}
	780
[34]	781	bool GraphDisplayerCanvas::entryWidgetChangeHandler(GdkEvent* e)
	782	{
[35]	783	if(entrywidget.is_visible())
	784	{
	785	if(e->type==GDK_KEY_PRESS)
	786	{
	787	switch(((GdkEventKey*)e)->keyval)
	788	{
	789	case GDK_Escape:
	790	entrywidget.hide();
	791	break;
	792	case GDK_KP_Enter:
	793	case GDK_Return:
	794	{
[43]	795	//these variables check whether the text in the entry is valid
[41]	796	bool valid_double=true;
	797	int point_num=0;
[43]	798
	799	//getting the value from the entry and converting it to double
[41]	800	Glib::ustring mapvalue_str = entrywidget.get_text();
[35]	801
[41]	802	char * mapvalue_ch=new char [mapvalue_str.length()];
	803	for(int i=0;i<(int)(mapvalue_str.length());i++)
[35]	804	{
[41]	805	if(((mapvalue_str[i]<'0')\|\|(mapvalue_str[i]>'9'))&&(mapvalue_str[i]!='.'))
[35]	806	{
[41]	807	valid_double=false;
[35]	808	}
	809	else
	810	{
[41]	811	if(mapvalue_str[i]=='.')
	812	{
	813	point_num++;
	814	}
[35]	815	}
[41]	816	mapvalue_ch[i]=mapvalue_str[i];
[35]	817	}
[45]	818
[43]	819	//if the text in the entry was correct
[41]	820	if((point_num<=1)&&(valid_double))
[35]	821	{
[45]	822	double mapvalue_d=atof(mapvalue_ch);
	823
	824	//reconvert the double to string for the correct format
	825	std::ostringstream ostr;
	826	ostr << mapvalue_d;
	827
[43]	828	//save the value to the correct place
[35]	829	switch(actual_tool)
	830	{
	831	case EDGE_MAP_EDIT:
[45]	832	edgetextmap[active_edge]->property_text().set_value(ostr.str());
[41]	833	(*(mapstorage.edgemap_storage)[edgemap_to_edit])[active_edge]=mapvalue_d;
[53]	834	mapwin.updateEdge(active_edge);
[35]	835	break;
	836	case NODE_MAP_EDIT:
[45]	837	nodetextmap[active_node]->property_text().set_value(ostr.str());
[41]	838	(*(mapstorage.nodemap_storage)[nodemap_to_edit])[active_node]=mapvalue_d;
[53]	839	mapwin.updateNode(active_node);
[35]	840	break;
	841	default:
	842	break;
	843	}
	844	entrywidget.hide();
	845	}
[43]	846	//the text in the entry was not correct for a double
[35]	847	else
	848	{
[48]	849	std::cerr << "ERROR: only handling of double values is implemented yet!" << std::endl;
[35]	850	}
	851
	852	break;
	853	}
	854	default:
	855	break;
	856	}
	857	}
	858	}
[34]	859	return false;
	860	}
	861
[62]	862	void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
[27]	863	{
[28]	864	delete(nodetextmap[node_to_delete]);
[27]	865	delete(nodesmap[node_to_delete]);
[53]	866	mapstorage.graph.erase(node_to_delete);
[27]	867	}
	868
[62]	869	void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
[27]	870	{
[28]	871	delete(edgetextmap[edge_to_delete]);
[27]	872	delete(edgesmap[edge_to_delete]);
[53]	873	mapstorage.graph.erase(edge_to_delete);
[27]	874	}
	875
[30]	876	void GraphDisplayerCanvas::textReposition(xy<double> new_place)
[27]	877	{
	878	new_place+=(xy<double>(10,10));
[35]	879	edgetextmap[forming_edge]->property_x().set_value(new_place.x);
	880	edgetextmap[forming_edge]->property_y().set_value(new_place.y);
[27]	881	}
	882
[30]	883	void GraphDisplayerCanvas::toggleEdgeActivity(BrokenEdge* active_bre, bool on)
[27]	884	{
	885	if(on)
	886	{
[35]	887	if(forming_edge!=INVALID)
[27]	888	{
[48]	889	std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
[27]	890	}
	891	else
	892	{
[53]	893	for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
[27]	894	{
	895	if(edgesmap[i]==active_bre)
	896	{
[35]	897	forming_edge=i;
[27]	898	}
	899	}
	900	}
	901	}
	902	else
	903	{
[35]	904	if(forming_edge!=INVALID)
[27]	905	{
[35]	906	forming_edge=INVALID;
[27]	907	}
	908	else
	909	{
[48]	910	std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
[27]	911	}
	912	}
	913
	914	}
[32]	915
[46]	916	int GraphDisplayerCanvas::addNewEdgeMap(double default_value, std::string mapname)
[37]	917	{
[43]	918	//create the new map
[53]	919	Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> (mapstorage.graph, default_value);
[46]	920
	921	//if addition was not successful addEdgeMap returns one.
	922	//cause can be that there is already a map named like the new one
[63]	923	if(mapstorage.addEdgeMap(mapname,emptr, default_value))
[46]	924	{
	925	return 1;
	926	}
	927
[43]	928
	929	//add it to the list of the displayable maps
[53]	930	mapwin.registerNewEdgeMap(mapname);
[43]	931
	932	//display it
[41]	933	changeEdgeText(mapname);
[46]	934
	935	return 0;
[37]	936	}
	937
[46]	938	int GraphDisplayerCanvas::addNewNodeMap(double default_value, std::string mapname)
[37]	939	{
[43]	940	//create the new map
[53]	941	Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> (mapstorage.graph,default_value);
[46]	942
	943	//if addition was not successful addNodeMap returns one.
	944	//cause can be that there is already a map named like the new one
[63]	945	if(mapstorage.addNodeMap(mapname,emptr, default_value))
[46]	946	{
	947	return 1;
	948	}
[43]	949
	950	//add it to the list of the displayable maps
[53]	951	mapwin.registerNewNodeMap(mapname);
[43]	952
	953	//display it
[41]	954	changeNodeText(mapname);
[46]	955
	956	return 0;
[37]	957	}
	958

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

Download in other formats: