COIN-OR::LEMON - Graph Library

Context Navigation

source: glemon-0.x/graph_displayer_canvas-event.cc @ 69:6bb290b67e19

gui

Last change on this file since 69:6bb290b67e19 was 69:6bb290b67e19, checked in by Alpar Juttner, 19 years ago
No comment.
Property exe set to ``*
File size: 22.5 KB

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

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

Download in other formats: