COIN-OR::LEMON - Graph Library

Context Navigation

source: glemon-0.x/graph_displayer_canvas-event.cc @ 160:14a76109b561

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

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

Download in other formats: