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

Line
1	#include "graph_displayer_canvas.h"
2	#include <cmath>
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	{
15	if(actual_tool!=newtool)
16	{
17
18	actual_handler.disconnect();
19
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:
31	//has to do the same thing as in the case of NODE_MAP_EDIT
32	case NODE_MAP_EDIT:
33	{
34	break;
35	}
36	default:
37	break;
38	}
39
40	active_item=NULL;
41	target_item=NULL;
42	active_edge=INVALID;
43	active_node=INVALID;
44
45
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;
53
54	case CREATE_NODE:
55	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
56	break;
57
58	case CREATE_EDGE:
59	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
60	break;
61
62	case ERASER:
63	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
64	break;
65
66	case EDGE_MAP_EDIT:
67	grab_focus();
68	actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::edgeMapEditEventHandler), false);
69	break;
70
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	}
78	}
79	}
80
81	int GraphDisplayerCanvas::getActualTool()
82	{
83	return actual_tool;
84	}
85
86	bool GraphDisplayerCanvas::moveEventHandler(GdkEvent* e)
87	{
88	static Gnome::Canvas::Text *coord_text = 0;
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
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));
96	active_node=INVALID;
97	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
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:
115	if (coord_text)
116	{
117	delete coord_text;
118	coord_text = 0;
119	}
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	{
128	(mytab.mapstorage).modified = true;
129
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
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;
141
142	//repositioning node and its text
143	active_item->move(dx, dy);
144	nodetextmap[active_node]->move(dx, dy);
145
146	// the new coordinates of the centre of the node
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);
149
150	clicked_x=new_x;
151	clicked_y=new_y;
152
153	// write back the new coordinates to the coords map
154	(mytab.mapstorage).coords.set(active_node, xy<double>(coord_x, coord_y));
155
156	// reposition the coordinates text
157	std::ostringstream ostr;
158	ostr << "(" <<
159	(mytab.mapstorage).coords[active_node].x << ", " <<
160	(mytab.mapstorage).coords[active_node].y << ")";
161	double radius =
162	(nodesmap[active_node]->property_x2().get_value() -
163	nodesmap[active_node]->property_x1().get_value()) / 2.0;
164	if (coord_text)
165	{
166	coord_text->property_text().set_value(ostr.str());
167	coord_text->property_x().set_value((mytab.mapstorage).coords[active_node].x +
168	radius);
169	coord_text->property_y().set_value((mytab.mapstorage).coords[active_node].y -
170	radius);
171	}
172	else
173	{
174	coord_text = new Gnome::Canvas::Text(
175	displayed_graph,
176	(mytab.mapstorage).coords[active_node].x + radius,
177	(mytab.mapstorage).coords[active_node].y - radius,
178	ostr.str());
179	coord_text->property_fill_color().set_value("black");
180	coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
181	}
182
183	//all the edges connected to the moved point has to be redrawn
184	for(OutEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
185	{
186	Gnome::Canvas::Points coos;
187	double x1, x2, y1, y2;
188
189	nodesmap[(mytab.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
190	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
191
192	nodesmap[(mytab.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
193	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
194
195	if(isbutton==3)
196	{
197	edgesmap[ei]->setPoints(coos);
198	}
199	else
200	{
201	edgesmap[ei]->setPoints(coos,true);
202	}
203
204	//reposition of edgetext
205	xy<double> text_pos=edgesmap[ei]->getArrowPos();
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
211	for(InEdgeIt ei((mytab.mapstorage).graph,active_node);ei!=INVALID;++ei)
212	{
213	Gnome::Canvas::Points coos;
214	double x1, x2, y1, y2;
215
216	nodesmap[(mytab.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
217	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
218
219	nodesmap[(mytab.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
220	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
221
222	if(isbutton==3)
223	{
224	edgesmap[ei]->setPoints(coos);
225	}
226	else
227	{
228	edgesmap[ei]->setPoints(coos,true);
229	}
230
231	xy<double> text_pos=edgesmap[ei]->getArrowPos();
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
240	return false;
241	}
242
243	bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
244	{
245	switch(e->type)
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	}
257
258	case GDK_BUTTON_RELEASE:
259	(mytab.mapstorage).modified = true;
260
261	isbutton=1;
262
263	active_node=(mytab.mapstorage).graph.addNode();
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
269	// update coordinates
270	(mytab.mapstorage).coords.set(active_node, xy<double>(clicked_x, clicked_y));
271
272	// update all other maps
273	for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
274	(mytab.mapstorage).nodemap_storage.begin(); it !=
275	(mytab.mapstorage).nodemap_storage.end(); ++it)
276	{
277	if ((it->first != "coordinates_x") &&
278	(it->first != "coordinates_y"))
279	{
280	(*(it->second))[active_node] =
281	(mytab.mapstorage).nodemap_default[it->first];
282	}
283	}
284	// increment the id map's default value
285	(mytab.mapstorage).nodemap_default["id"] += 1.0;
286
287	nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
288	clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
289	active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
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
296	(nodesmap[active_node])->show();
297
298	nodetextmap[active_node]=new Gnome::Canvas::Text(displayed_graph,
299	clicked_x+node_property_defaults[N_RADIUS]+5,
300	clicked_y+node_property_defaults[N_RADIUS]+5, "");
301	nodetextmap[active_node]->property_fill_color().set_value("darkblue");
302	nodetextmap[active_node]->raise_to_top();
303
304	// mapwin.updateNode(active_node);
305	propertyUpdate(active_node);
306
307	isbutton=0;
308	target_item=NULL;
309	active_item=NULL;
310	active_node=INVALID;
311	break;
312	default:
313	break;
314	}
315	return false;
316	}
317
318	bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
319	{
320	switch(e->type)
321	{
322	case GDK_BUTTON_PRESS:
323	//in edge creation right button has special meaning
324	if(e->button.button!=3)
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
330
331	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
332
333	active_item=(get_item_at(clicked_x, clicked_y));
334	active_node=INVALID;
335	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
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;
364	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
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	{
376	(mytab.mapstorage).modified = true;
377
378	*(nodesmap[target_node]) <<
379	Gnome::Canvas::Properties::fill_color("red");
380
381	//creating new edge
382	active_edge=(mytab.mapstorage).graph.addEdge(active_node,
383	target_node);
384
385	// update maps
386	for (std::map<std::string,
387	Graph::EdgeMap<double>*>::const_iterator it =
388	(mytab.mapstorage).edgemap_storage.begin(); it !=
389	(mytab.mapstorage).edgemap_storage.end(); ++it)
390	{
391	(*(it->second))[active_edge] =
392	(mytab.mapstorage).edgemap_default[it->first];
393	}
394	// increment the id map's default value
395	(mytab.mapstorage).edgemap_default["id"] += 1.0;
396
397	//calculating coordinates of new edge
398	Gnome::Canvas::Points coos;
399	double x1, x2, y1, y2;
400
401	active_item->get_bounds(x1, y1, x2, y2);
402	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
403
404	target_item->get_bounds(x1, y1, x2, y2);
405	coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
406
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);
413
414	edgesmap[active_edge]->lower_to_bottom();
415
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
427	// mapwin.updateEdge(active_edge);
428	propertyUpdate(active_edge);
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	}
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))
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	}
465	break;
466	default:
467	break;
468	}
469	return false;
470	}
471
472	bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
473	{
474	switch(e->type)
475	{
476	case GDK_BUTTON_PRESS:
477	//finding the clicked items
478	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
479	active_item=(get_item_at(clicked_x, clicked_y));
480	active_node=INVALID;
481	active_edge=INVALID;
482	//was it a node?
483	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
484	{
485	if(nodesmap[i]==active_item)
486	{
487	active_node=i;
488	}
489	}
490	//or was it an edge?
491	if(active_node==INVALID)
492	{
493	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
494	{
495	if(edgesmap[i]==active_item)
496	{
497	active_edge=i;
498	}
499	}
500	}
501
502	//recolor activated item
503	if(active_item)
504	{
505	*active_item << Gnome::Canvas::Properties::fill_color("red");
506	}
507	break;
508
509	case GDK_BUTTON_RELEASE:
510	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
511	if(active_item)
512	{
513	//the cursor was not moved since pressing it
514	if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
515	{
516	//a node was found
517	if(active_node!=INVALID)
518	{
519	(mytab.mapstorage).modified = true;
520
521	std::set<Graph::Edge> edges_to_delete;
522
523	for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
524	{
525	edges_to_delete.insert(e);
526	}
527
528	for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
529	{
530	edges_to_delete.insert(e);
531	}
532
533	//deleting collected edges
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)
538	{
539	deleteItem(*edge_set_it);
540	}
541	deleteItem(active_node);
542	}
543	//a simple edge was chosen
544	else
545	{
546	deleteItem(active_edge);
547	}
548	}
549	//pointer was moved, deletion is cancelled
550	else
551	{
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	}
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	}
574	return false;
575	}
576
577	bool GraphDisplayerCanvas::edgeMapEditEventHandler(GdkEvent* e)
578	{
579	if(actual_tool==EDGE_MAP_EDIT)
580	{
581	switch(e->type)
582	{
583	case GDK_BUTTON_PRESS:
584	{
585	//for determine, whether it was an edge
586	Edge clicked_edge=INVALID;
587
588	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
589	active_item=(get_item_at(clicked_x, clicked_y));
590
591	//find the activated item between texts
592	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
593	{
594	//at the same time only one can be active
595	if(edgetextmap[i]==active_item)
596	{
597	clicked_edge=i;
598	}
599	}
600
601	//if it was not between texts, search for it between edges
602	if(clicked_edge==INVALID)
603	{
604	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
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;
619
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;
625
626	//create a dialog
627	Gtk::Dialog dialog("Edit value", true);
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();
631	Gtk::SpinButton spin(0.0, 4);
632	spin.set_increments(1.0, 10.0);
633	spin.set_range(-1000000.0, 1000000.0);
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();
644	(*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
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);
651	// mapwin.updateEdge(Edge(INVALID));
652	propertyUpdate(Edge(INVALID));
653	}
654	}
655	}
656	break;
657	}
658	default:
659	break;
660	}
661	}
662	return false;
663	}
664
665	bool GraphDisplayerCanvas::nodeMapEditEventHandler(GdkEvent* e)
666	{
667	if(actual_tool==NODE_MAP_EDIT)
668	{
669	switch(e->type)
670	{
671	case GDK_BUTTON_PRESS:
672	{
673	//for determine, whether it was a node
674	Node clicked_node=INVALID;
675
676	window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
677	active_item=(get_item_at(clicked_x, clicked_y));
678
679	//find the activated item between texts
680	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
681	{
682	//at the same time only one can be active
683	if(nodetextmap[i]==active_item)
684	{
685	clicked_node=i;
686	}
687	}
688
689	//if there was not, search for it between nodes
690	if(clicked_node==INVALID)
691	{
692	for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
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	}
701
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;
707
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;
713
714	//create a dialog
715	Gtk::Dialog dialog("Edit value", true);
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();
719	Gtk::SpinButton spin(0.0, 4);
720	spin.set_increments(1.0, 10.0);
721	spin.set_range(-1000000.0, 1000000.0);
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();
732	(*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
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);
739	// mapwin.updateNode(Node(INVALID));
740	propertyUpdate(Node(INVALID));
741	}
742	}
743	}
744	break;
745	}
746	default:
747	break;
748	}
749	}
750	return false;
751	}
752
753	void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
754	{
755	delete(nodetextmap[node_to_delete]);
756	delete(nodesmap[node_to_delete]);
757	(mytab.mapstorage).graph.erase(node_to_delete);
758	}
759
760	void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
761	{
762	delete(edgetextmap[edge_to_delete]);
763	delete(edgesmap[edge_to_delete]);
764	(mytab.mapstorage).graph.erase(edge_to_delete);
765	}
766
767	void GraphDisplayerCanvas::textReposition(xy<double> new_place)
768	{
769	new_place+=(xy<double>(10,10));
770	edgetextmap[forming_edge]->property_x().set_value(new_place.x);
771	edgetextmap[forming_edge]->property_y().set_value(new_place.y);
772	}
773
774	void GraphDisplayerCanvas::toggleEdgeActivity(BrokenEdge* active_bre, bool on)
775	{
776	if(on)
777	{
778	if(forming_edge!=INVALID)
779	{
780	std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
781	}
782	else
783	{
784	for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
785	{
786	if(edgesmap[i]==active_bre)
787	{
788	forming_edge=i;
789	}
790	}
791	}
792	}
793	else
794	{
795	if(forming_edge!=INVALID)
796	{
797	forming_edge=INVALID;
798	}
799	else
800	{
801	std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
802	}
803	}
804
805	}
806
807	int GraphDisplayerCanvas::addNewEdgeMap(double default_value, std::string mapname)
808	{
809	//create the new map
810	Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> ((mytab.mapstorage).graph, default_value);
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
814	if((mytab.mapstorage).addEdgeMap(mapname,emptr, default_value))
815	{
816	return 1;
817	}
818
819
820	//add it to the list of the displayable maps
821	mytab.registerNewEdgeMap(mapname);
822
823	//display it
824	changeEdgeText(mapname);
825
826	return 0;
827	}
828
829	int GraphDisplayerCanvas::addNewNodeMap(double default_value, std::string mapname)
830	{
831	//create the new map
832	Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> ((mytab.mapstorage).graph,default_value);
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
836	if((mytab.mapstorage).addNodeMap(mapname,emptr, default_value))
837	{
838	return 1;
839	}
840
841	//add it to the list of the displayable maps
842	mytab.registerNewNodeMap(mapname);
843
844	//display it
845	changeNodeText(mapname);
846
847	return 0;
848	}
849

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

Download in other formats: