COIN-OR::LEMON - Graph Library

Context Navigation

source: glemon-0.x/graph_displayer_canvas-event.cc @ 134:82e19031c319

gui

Last change on this file since 134:82e19031c319 was 134:82e19031c319, checked in by Akos Ladanyi, 18 years ago
id->label
Property exe set to ``*
File size: 25.5 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
[98]	150	// write back the new coordinates to the coords map
	151	(mytab.mapstorage).coords.set(active_node, xy<double>(coord_x, coord_y));
	152
[31]	153	clicked_x=new_x;
	154	clicked_y=new_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	{
[98]	186	XY moved_node_1(coord_x - dx, coord_y - dy);
	187	XY moved_node_2(coord_x, coord_y);
	188	Node target = mytab.mapstorage.graph.target(ei);
	189	XY fix_node(mytab.mapstorage.coords[target].x,
	190	mytab.mapstorage.coords[target].y);
	191	XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
[27]	192
[98]	193	XY arrow_pos;
	194	if(isbutton==3)
	195	arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, false);
	196	else
	197	arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, true);
[27]	198
[98]	199	mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
	200	edgesmap[ei]->draw();
[27]	201
[28]	202	//reposition of edgetext
[98]	203	XY text_pos=mytab.mapstorage.arrow_pos[ei];
	204	text_pos+=(XY(10,10));
[27]	205	edgetextmap[ei]->property_x().set_value(text_pos.x);
	206	edgetextmap[ei]->property_y().set_value(text_pos.y);
	207	}
	208
[96]	209	for(InEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
[27]	210	{
[98]	211	XY moved_node_1(coord_x - dx, coord_y - dy);
	212	XY moved_node_2(coord_x, coord_y);
	213	Node source = mytab.mapstorage.graph.source(ei);
	214	XY fix_node(mytab.mapstorage.coords[source].x,
	215	mytab.mapstorage.coords[source].y);
	216	XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
[27]	217
[98]	218	XY arrow_pos;
	219	if(isbutton==3)
	220	arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, false);
	221	else
	222	arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, true);
[27]	223
[98]	224	mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
	225	edgesmap[ei]->draw();
[27]	226
[98]	227	//reposition of edgetext
	228	XY text_pos=mytab.mapstorage.arrow_pos[ei];
	229	text_pos+=(XY(10,10));
[27]	230	edgetextmap[ei]->property_x().set_value(text_pos.x);
	231	edgetextmap[ei]->property_y().set_value(text_pos.y);
	232	}
	233	}
	234	default: break;
	235	}
	236
[31]	237	return false;
[27]	238	}
	239
[98]	240	XY GraphDisplayerCanvas::calcArrowPos(XY moved_node_1, XY moved_node_2, XY fix_node, XY old_arrow_pos, bool move)
	241	{
	242	if(!move)
	243	{
	244	return XY((moved_node_2.x + fix_node.x) / 2.0, (moved_node_2.y + fix_node.y) / 2.0);
	245	}
	246	else
	247	{
	248	//////////////////////////////////////////////////////////////////////////////////////////////////////
	249	/////////// keeps shape-with scalar multiplication - version 2.
	250	//////////////////////////////////////////////////////////////////////////////////////////////////////
	251
	252	//old vector from one to the other node - a
	253	xy<double> a_v(moved_node_1.x-fix_node.x,moved_node_1.y-fix_node.y);
	254	//new vector from one to the other node - b
	255	xy<double> b_v(moved_node_2.x-fix_node.x,moved_node_2.y-fix_node.y);
	256
	257	double absa=sqrt(a_v.normSquare());
	258	double absb=sqrt(b_v.normSquare());
	259
	260	if ((absa == 0.0) \|\| (absb == 0.0))
	261	{
	262	return old_arrow_pos;
	263	}
	264	else
	265	{
	266	//old vector from one node to the breakpoint - c
	267	xy<double> c_v(old_arrow_pos.x-fix_node.x,old_arrow_pos.y-fix_node.y);
	268
	269	//unit vector with the same direction to a_v
	270	xy<double> a_v_u(a_v.x/absa,a_v.y/absa);
	271
	272	//normal vector of unit vector with the same direction to a_v
	273	xy<double> a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
	274
	275	//unit vector with the same direction to b_v
	276	xy<double> b_v_u(b_v.x/absb,b_v.y/absb);
	277
	278	//normal vector of unit vector with the same direction to b_v
	279	xy<double> b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
	280
	281	//vector c in a_v_u and a_v_u_n co-ordinate system
	282	xy<double> c_a(c_va_v_u,c_va_v_u_n);
	283
	284	//new vector from one node to the breakpoint - d - we have to calculate this one
	285	xy<double> d_v=absb/absa(c_a.xb_v_u+c_a.y*b_v_u_n);
	286
	287	return XY(d_v.x+fix_node.x,d_v.y+fix_node.y);
	288	}
	289	}
	290	}
	291
[30]	292	bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
[27]	293	{
	294	switch(e->type)
[63]	295	{
	296	//move the new node
	297	case GDK_MOTION_NOTIFY:
	298	{
	299	GdkEvent * generated=new GdkEvent();
	300	generated->motion.x=e->motion.x;
	301	generated->motion.y=e->motion.y;
	302	generated->type=GDK_MOTION_NOTIFY;
	303	moveEventHandler(generated);
	304	break;
	305	}
[27]	306
[63]	307	case GDK_BUTTON_RELEASE:
[96]	308	(mytab.mapstorage).modified = true;
[53]	309
[27]	310	isbutton=1;
	311
[96]	312	active_node=(mytab.mapstorage).graph.addNode();
[27]	313
	314	//initiating values corresponding to new node in maps
	315
	316	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	317
[63]	318	// update coordinates
[96]	319	(mytab.mapstorage).coords.set(active_node, xy<double>(clicked_x, clicked_y));
[63]	320
	321	// update all other maps
	322	for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
[96]	323	(mytab.mapstorage).nodemap_storage.begin(); it !=
	324	(mytab.mapstorage).nodemap_storage.end(); ++it)
[63]	325	{
[64]	326	if ((it->first != "coordinates_x") &&
	327	(it->first != "coordinates_y"))
[63]	328	{
	329	(*(it->second))[active_node] =
[96]	330	(mytab.mapstorage).nodemap_default[it->first];
[63]	331	}
	332	}
[64]	333	// increment the id map's default value
[134]	334	(mytab.mapstorage).nodemap_default["label"] += 1.0;
[63]	335
[53]	336	nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
[63]	337	clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
[27]	338	active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
[63]	339	*(nodesmap[active_node]) <<
	340	Gnome::Canvas::Properties::fill_color("blue");
	341	*(nodesmap[active_node]) <<
	342	Gnome::Canvas::Properties::outline_color("black");
	343	active_item->raise_to_top();
	344
[27]	345	(nodesmap[active_node])->show();
[28]	346
[53]	347	nodetextmap[active_node]=new Gnome::Canvas::Text(displayed_graph,
[63]	348	clicked_x+node_property_defaults[N_RADIUS]+5,
	349	clicked_y+node_property_defaults[N_RADIUS]+5, "");
[28]	350	nodetextmap[active_node]->property_fill_color().set_value("darkblue");
[63]	351	nodetextmap[active_node]->raise_to_top();
[28]	352
[94]	353	// mapwin.updateNode(active_node);
	354	propertyUpdate(active_node);
[28]	355
[27]	356	isbutton=0;
[31]	357	target_item=NULL;
[27]	358	active_item=NULL;
	359	active_node=INVALID;
	360	break;
	361	default:
	362	break;
[63]	363	}
[27]	364	return false;
	365	}
	366
[30]	367	bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
[27]	368	{
	369	switch(e->type)
[63]	370	{
[27]	371	case GDK_BUTTON_PRESS:
	372	//in edge creation right button has special meaning
	373	if(e->button.button!=3)
[63]	374	{
	375	//there is not yet selected node
	376	if(active_node==INVALID)
	377	{
	378	//we mark the location of the event to be able to calculate parameters of dragging
[31]	379
[63]	380	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
[31]	381
[63]	382	active_item=(get_item_at(clicked_x, clicked_y));
	383	active_node=INVALID;
[96]	384	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[63]	385	{
	386	if(nodesmap[i]==active_item)
	387	{
	388	active_node=i;
	389	}
	390	}
	391	//the clicked item is really a node
	392	if(active_node!=INVALID)
	393	{
	394	*(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
	395	isbutton=1;
	396	}
	397	//clicked item was not a node. It could be e.g. edge.
	398	else
	399	{
	400	active_item=NULL;
	401	}
	402	}
	403	//we only have to do sg. if the mouse button
	404	// is pressed already once AND the click was
	405	// on a node that was found in the set of
	406	//nodes, and now we only search for the second
	407	//node
	408	else
	409	{
	410	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	411	target_item=(get_item_at(clicked_x, clicked_y));
	412	Node target_node=INVALID;
[96]	413	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[63]	414	{
	415	if(nodesmap[i]==target_item)
	416	{
	417	target_node=i;
	418	}
	419	}
	420	//the clicked item is a node, the edge can be drawn
	421	if(target_node!=INVALID)
	422	{
	423	if(target_node!=active_node)
	424	{
[96]	425	(mytab.mapstorage).modified = true;
[53]	426
[63]	427	*(nodesmap[target_node]) <<
	428	Gnome::Canvas::Properties::fill_color("red");
[27]	429
[63]	430	//creating new edge
[96]	431	active_edge=(mytab.mapstorage).graph.addEdge(active_node,
[63]	432	target_node);
[27]	433
[64]	434	// update maps
[63]	435	for (std::map<std::string,
	436	Graph::EdgeMap<double>*>::const_iterator it =
[96]	437	(mytab.mapstorage).edgemap_storage.begin(); it !=
	438	(mytab.mapstorage).edgemap_storage.end(); ++it)
[63]	439	{
[64]	440	(*(it->second))[active_edge] =
[96]	441	(mytab.mapstorage).edgemap_default[it->first];
[63]	442	}
[64]	443	// increment the id map's default value
[134]	444	(mytab.mapstorage).edgemap_default["label"] += 1.0;
[27]	445
[63]	446	//calculating coordinates of new edge
	447	Gnome::Canvas::Points coos;
	448	double x1, x2, y1, y2;
[27]	449
[63]	450	active_item->get_bounds(x1, y1, x2, y2);
	451	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
[27]	452
[63]	453	target_item->get_bounds(x1, y1, x2, y2);
	454	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
[27]	455
[113]	456	// set the coordinates of the arrow on the new edge
	457	MapStorage& ms = mytab.mapstorage;
	458	ms.arrow_pos.set(active_edge,
	459	(ms.coords[ms.graph.source(active_edge)] +
	460	ms.coords[ms.graph.target(active_edge)])/ 2.0);
	461
[63]	462	//drawing new edge
[98]	463	edgesmap[active_edge]=new BrokenEdge(displayed_graph, active_edge,
[63]	464	*this);
	465	*(edgesmap[active_edge]) <<
	466	Gnome::Canvas::Properties::fill_color("green");
	467	edgesmap[active_edge]->property_width_pixels().set_value(10);
[27]	468
[63]	469	edgesmap[active_edge]->lower_to_bottom();
[28]	470
[63]	471	//initializing edge-text as well, to empty string
[98]	472	XY text_pos=mytab.mapstorage.arrow_pos[active_edge];
	473	text_pos+=(XY(10,10));
[63]	474
	475	edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph,
	476	text_pos.x, text_pos.y, "");
	477	edgetextmap[active_edge]->property_fill_color().set_value(
	478	"darkgreen");
	479	edgetextmap[active_edge]->raise_to_top();
	480
	481	//updating its properties
[94]	482	// mapwin.updateEdge(active_edge);
	483	propertyUpdate(active_edge);
[63]	484	}
	485	else
	486	{
	487	target_node=INVALID;
	488	std::cerr << "Loop edge is not yet implemented!" << std::endl;
	489	}
	490	}
	491	//clicked item was not a node. it could be an e.g. edge. we do not
	492	//deal with it furthermore.
	493	else
	494	{
	495	target_item=NULL;
	496	}
	497	}
	498	}
[27]	499	break;
	500	case GDK_BUTTON_RELEASE:
	501	isbutton=0;
	502	//we clear settings in two cases
	503	//1: the edge is ready (target_item has valid value)
	504	//2: the edge creation is cancelled with right button
	505	if((target_item)\|\|(e->button.button==3))
[63]	506	{
	507	if(active_item)
	508	{
	509	*active_item << Gnome::Canvas::Properties::fill_color("blue");
	510	active_item=NULL;
	511	}
	512	if(target_item)
	513	{
	514	*target_item << Gnome::Canvas::Properties::fill_color("blue");
	515	target_item=NULL;
	516	}
	517	active_node=INVALID;
	518	active_edge=INVALID;
	519	}
[27]	520	break;
	521	default:
	522	break;
[63]	523	}
[27]	524	return false;
	525	}
	526
[30]	527	bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
[27]	528	{
	529	switch(e->type)
	530	{
	531	case GDK_BUTTON_PRESS:
[43]	532	//finding the clicked items
[31]	533	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	534	active_item=(get_item_at(clicked_x, clicked_y));
[27]	535	active_node=INVALID;
	536	active_edge=INVALID;
[43]	537	//was it a node?
[96]	538	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	539	{
	540	if(nodesmap[i]==active_item)
	541	{
	542	active_node=i;
	543	}
	544	}
[43]	545	//or was it an edge?
[27]	546	if(active_node==INVALID)
	547	{
[96]	548	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	549	{
	550	if(edgesmap[i]==active_item)
	551	{
	552	active_edge=i;
	553	}
	554	}
	555	}
[43]	556
[129]	557	// return if the clicked object is neither an edge nor a node
	558	if (active_edge == INVALID) return false;
	559
[43]	560	//recolor activated item
[31]	561	if(active_item)
	562	{
	563	*active_item << Gnome::Canvas::Properties::fill_color("red");
	564	}
[27]	565	break;
	566
	567	case GDK_BUTTON_RELEASE:
[31]	568	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	569	if(active_item)
[27]	570	{
[43]	571	//the cursor was not moved since pressing it
[31]	572	if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
[27]	573	{
[43]	574	//a node was found
[31]	575	if(active_node!=INVALID)
	576	{
[96]	577	(mytab.mapstorage).modified = true;
[27]	578
[31]	579	std::set<Graph::Edge> edges_to_delete;
[27]	580
[96]	581	for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
[31]	582	{
	583	edges_to_delete.insert(e);
	584	}
[69]	585
[96]	586	for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
[31]	587	{
	588	edges_to_delete.insert(e);
	589	}
[69]	590
[31]	591	//deleting collected edges
[69]	592	for(std::set<Graph::Edge>::iterator
	593	edge_set_it=edges_to_delete.begin();
	594	edge_set_it!=edges_to_delete.end();
	595	++edge_set_it)
[31]	596	{
	597	deleteItem(*edge_set_it);
	598	}
	599	deleteItem(active_node);
	600	}
	601	//a simple edge was chosen
[129]	602	else if (active_edge != INVALID)
[27]	603	{
[31]	604	deleteItem(active_edge);
[27]	605	}
	606	}
[31]	607	//pointer was moved, deletion is cancelled
[27]	608	else
	609	{
[31]	610	if(active_node!=INVALID)
	611	{
	612	*active_item << Gnome::Canvas::Properties::fill_color("blue");
	613	}
[129]	614	else if (active_edge != INVALID)
[31]	615	{
	616	*active_item << Gnome::Canvas::Properties::fill_color("green");
	617	}
[27]	618	}
	619	}
	620	//reseting datas
	621	active_item=NULL;
	622	active_edge=INVALID;
	623	active_node=INVALID;
	624	break;
	625
	626	case GDK_MOTION_NOTIFY:
	627	break;
	628
	629	default:
	630	break;
	631	}
[31]	632	return false;
[27]	633	}
	634
[32]	635	bool GraphDisplayerCanvas::edgeMapEditEventHandler(GdkEvent* e)
	636	{
[48]	637	if(actual_tool==EDGE_MAP_EDIT)
[66]	638	{
	639	switch(e->type)
[32]	640	{
[66]	641	case GDK_BUTTON_PRESS:
	642	{
	643	//for determine, whether it was an edge
	644	Edge clicked_edge=INVALID;
[43]	645
[66]	646	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	647	active_item=(get_item_at(clicked_x, clicked_y));
[48]	648
[66]	649	//find the activated item between texts
[96]	650	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	651	{
	652	//at the same time only one can be active
	653	if(edgetextmap[i]==active_item)
	654	{
	655	clicked_edge=i;
	656	}
	657	}
[65]	658
[66]	659	//if it was not between texts, search for it between edges
	660	if(clicked_edge==INVALID)
	661	{
[96]	662	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	663	{
	664	//at the same time only one can be active
	665	if((edgesmap[i]==active_item)\|\|(edgetextmap[i]==active_item))
	666	{
	667	clicked_edge=i;
	668	}
	669	}
	670	}
	671
	672	//if it was really an edge...
	673	if(clicked_edge!=INVALID)
	674	{
	675	// the id map is not editable
[134]	676	if (edgemap_to_edit == "label") return 0;
[48]	677
[66]	678	//and there is activated map
	679	if(edgetextmap[clicked_edge]->property_text().get_value()!="")
	680	{
	681	//activate the general variable for it
	682	active_edge=clicked_edge;
[48]	683
[66]	684	//create a dialog
[96]	685	Gtk::Dialog dialog("Edit value", true);
[66]	686	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	687	dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
	688	Gtk::VBox* vbox = dialog.get_vbox();
[92]	689	Gtk::SpinButton spin(0.0, 4);
	690	spin.set_increments(1.0, 10.0);
	691	spin.set_range(-1000000.0, 1000000.0);
[66]	692	spin.set_numeric(true);
	693	vbox->add(spin);
	694	spin.show();
	695	switch (dialog.run())
	696	{
	697	case Gtk::RESPONSE_NONE:
	698	case Gtk::RESPONSE_CANCEL:
	699	break;
	700	case Gtk::RESPONSE_ACCEPT:
	701	double new_value = spin.get_value();
[96]	702	(*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
[66]	703	new_value;
	704	std::ostringstream ostr;
	705	ostr << new_value;
	706	edgetextmap[active_edge]->property_text().set_value(
	707	ostr.str());
	708	//mapwin.updateEdge(active_edge);
[94]	709	// mapwin.updateEdge(Edge(INVALID));
	710	propertyUpdate(Edge(INVALID));
[66]	711	}
	712	}
	713	}
	714	break;
	715	}
	716	default:
	717	break;
[32]	718	}
[66]	719	}
[32]	720	return false;
	721	}
	722
	723	bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
	724	{
[48]	725	if(actual_tool==NODE_MAP_EDIT)
[66]	726	{
	727	switch(e->type)
[35]	728	{
[66]	729	case GDK_BUTTON_PRESS:
	730	{
	731	//for determine, whether it was a node
	732	Node clicked_node=INVALID;
[43]	733
[66]	734	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
	735	active_item=(get_item_at(clicked_x, clicked_y));
[43]	736
[66]	737	//find the activated item between texts
[96]	738	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	739	{
	740	//at the same time only one can be active
	741	if(nodetextmap[i]==active_item)
	742	{
	743	clicked_node=i;
	744	}
	745	}
[48]	746
[66]	747	//if there was not, search for it between nodes
	748	if(clicked_node==INVALID)
	749	{
[96]	750	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[66]	751	{
	752	//at the same time only one can be active
	753	if(nodesmap[i]==active_item)
	754	{
	755	clicked_node=i;
	756	}
	757	}
	758	}
[48]	759
[66]	760	//if it was really a node...
	761	if(clicked_node!=INVALID)
	762	{
	763	// the id map is not editable
[134]	764	if (nodemap_to_edit == "label") return 0;
[48]	765
[66]	766	//and there is activated map
	767	if(nodetextmap[clicked_node]->property_text().get_value()!="")
	768	{
	769	//activate the general variable for it
	770	active_node=clicked_node;
[48]	771
[66]	772	//create a dialog
[96]	773	Gtk::Dialog dialog("Edit value", true);
[66]	774	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	775	dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
	776	Gtk::VBox* vbox = dialog.get_vbox();
[92]	777	Gtk::SpinButton spin(0.0, 4);
	778	spin.set_increments(1.0, 10.0);
	779	spin.set_range(-1000000.0, 1000000.0);
[66]	780	spin.set_numeric(true);
	781	vbox->add(spin);
	782	spin.show();
	783	switch (dialog.run())
	784	{
	785	case Gtk::RESPONSE_NONE:
	786	case Gtk::RESPONSE_CANCEL:
	787	break;
	788	case Gtk::RESPONSE_ACCEPT:
	789	double new_value = spin.get_value();
[96]	790	(*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
[66]	791	new_value;
	792	std::ostringstream ostr;
	793	ostr << new_value;
	794	nodetextmap[active_node]->property_text().set_value(
	795	ostr.str());
	796	//mapwin.updateNode(active_node);
[94]	797	// mapwin.updateNode(Node(INVALID));
	798	propertyUpdate(Node(INVALID));
[66]	799	}
	800	}
	801	}
	802	break;
	803	}
	804	default:
	805	break;
[35]	806	}
[66]	807	}
[35]	808	return false;
[32]	809	}
	810
[62]	811	void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
[27]	812	{
[28]	813	delete(nodetextmap[node_to_delete]);
[27]	814	delete(nodesmap[node_to_delete]);
[96]	815	(mytab.mapstorage).graph.erase(node_to_delete);
[27]	816	}
	817
[62]	818	void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
[27]	819	{
[28]	820	delete(edgetextmap[edge_to_delete]);
[27]	821	delete(edgesmap[edge_to_delete]);
[96]	822	(mytab.mapstorage).graph.erase(edge_to_delete);
[27]	823	}
	824
[30]	825	void GraphDisplayerCanvas::textReposition(xy<double> new_place)
[27]	826	{
	827	new_place+=(xy<double>(10,10));
[35]	828	edgetextmap[forming_edge]->property_x().set_value(new_place.x);
	829	edgetextmap[forming_edge]->property_y().set_value(new_place.y);
[27]	830	}
	831
[30]	832	void GraphDisplayerCanvas::toggleEdgeActivity(BrokenEdge* active_bre, bool on)
[27]	833	{
	834	if(on)
	835	{
[35]	836	if(forming_edge!=INVALID)
[27]	837	{
[48]	838	std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
[27]	839	}
	840	else
	841	{
[96]	842	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
[27]	843	{
	844	if(edgesmap[i]==active_bre)
	845	{
[35]	846	forming_edge=i;
[27]	847	}
	848	}
	849	}
	850	}
	851	else
	852	{
[35]	853	if(forming_edge!=INVALID)
[27]	854	{
[35]	855	forming_edge=INVALID;
[27]	856	}
	857	else
	858	{
[48]	859	std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
[27]	860	}
	861	}
	862	}

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

Download in other formats: