non
/
spiralsynthmodular
mirror of https://github.com/original-male/spiralsynthmodular
1
0
Fork 0
Code Releases 0 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
133 Commits
1 Branch
1.8MB
Tree: b64b57e01c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b64b57e01c'
${ noResults }
spiralsynthmodular/GUI/Widgets/Fl_Canvas.C

676 lines
16KB
Raw Blame History 

  1. /*  Canvas Widget

  2.  *  Copyleft (C) 2002 David Griffiths <dave@pawfal.org>

  3.  *

  4.  *  This program is free software; you can redistribute it and/or modify

  5.  *  it under the terms of the GNU General Public License as published by

  6.  *  the Free Software Foundation; either version 2 of the License, or

  7.  *  (at your option) any later version.

  8.  *

  9.  *  This program is distributed in the hope that it will be useful,

  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.  *  GNU General Public License for more details.

  13.  *

  14.  *  You should have received a copy of the GNU General Public License

  15.  *  along with this program; if not, write to the Free Software

  16.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  17. */ 

  18. 

  19. #include "Fl/fl_draw.H"

  20. #include "Fl_Canvas.h"

  21. #include "Fl_DeviceGUI.h"

  22. #include <iostream>

  23. #include "../../SpiralSynthModularInfo.h"

  24. 

  25. // no of calls to handle when dragged, before the widget is redrawn

  26. // to allow the wire (connection currently being made) to be redrawn

  27. static const int UPDATE_TICKS = 5;

  28. 

  29. ////////////////////////////////////////////////////////////////////////

  30. 

  31. Fl_Canvas::Fl_Canvas(int x, int y, int w, int h, char *name) :

  32. Fl_Group(x,y,w,h,name),

  33. cb_Connection(NULL),

  34. cb_Unconnect(NULL),

  35. cb_AddDevice(NULL),

  36. m_ToolMenu(false),

  37. m_UpdateTimer(0)

  38. {

  39. 	m_IncompleteWire.OutputChild=-1;

  40. 	m_IncompleteWire.OutputPort=-1;

  41. 	m_IncompleteWire.OutputTerminal=false;

  42. 	m_IncompleteWire.InputChild=-1;

  43. 	m_IncompleteWire.InputPort=-1;

  44. 	m_IncompleteWire.InputTerminal=false;

  45. 	

  46. 	m_BG=NULL;

  47. 	m_BGData=NULL;

  48. }

  49. 

  50. ////////////////////////////////////////////////////////////////////////

  51. 

  52. Fl_Canvas::~Fl_Canvas()

  53. {

  54. }

  55. 

  56. ////////////////////////////////////////////////////////////////////////

  57. 

  58. void Fl_Canvas::draw()

  59. {			

  60. 	Fl_Widget*const* a = array();

  61. 	

  62.   	if (damage() & ~FL_DAMAGE_CHILD) // redraw the entire thing:

  63. 	{ 	    

  64. 		if (m_BG)

  65. 		{

  66. 			int X=0,Y=0;

  67. 			while (Y<w())

  68. 			{	

  69. 				while (X<h())

  70. 				{

  71. 					m_BG->draw(parent()->x()+X,parent()->y()+Y);

  72. #if FL_MAJOR_VERSION == 1 && FL_MINOR_VERSION == 0

  73. 					X+=m_BG->w;

  74. #else

  75. 					X+=m_BG->w();

  76. #endif	

  77. 				}		

  78. #if FL_MAJOR_VERSION == 1 && FL_MINOR_VERSION == 0

  79.  				Y+=m_BG->h;

  80. #else

  81. 				Y+=m_BG->h();

  82. #endif

  83. 				X=0;

  84. 			}

  85. 		}

  86. 		else

  87. 		{

  88. 			draw_box();

  89. 		}

  90. 				

  91. 		// draw minimised modules first

  92.    	 	for (int i=children(); i--;) 

  93. 		{

  94.    			Fl_Widget& o = **a++;

  95. 			if (((Fl_DeviceGUI*)&o)->IsMinimised())

  96. 			{

  97.    	 			draw_child(o);

  98.    				draw_outside_label(o);

  99. 			}

  100. 		}

  101. 		

  102. 		DrawWires();

  103. 		

  104. 		// draw maximised modules on top of everything else

  105.    	 	Fl_Widget*const* a = array();

  106. 		for (int i=children(); i--;) 

  107. 		{

  108.    			Fl_Widget& o = **a++;

  109. 			if (!((Fl_DeviceGUI*)&o)->IsMinimised())

  110. 			{

  111.    	 			draw_child(o);

  112.    				draw_outside_label(o);

  113. 			}

  114. 		}

  115. 	}

  116. 	else // only redraw the children that need it:

  117. 	{	

  118. 		for (int i=children(); i--;) update_child(**a++);

  119.   	}

  120. 	

  121. 	if (m_ToolMenu)

  122. 	{

  123. 		int Pos=0,X=0,Y=0,textw,texth;

  124. 		int DegreesPerItem=30;

  125. 		float conv=3.151/180.0f;

  126. 		bool selected=false;

  127. 		m_Selected=-1;

  128. 		

  129. 		fl_font(fl_font(),10);

  130. 		for (vector< pair<string,int> >::iterator i=m_PluginNameList.begin();

  131. 			 i!=m_PluginNameList.end(); ++i)

  132. 		{								

  133. 			textw=0;

  134. 			fl_font(fl_font(),10);

  135. 			fl_measure(i->first.c_str(), textw, texth);

  136. 			

  137. 			X=m_x-(textw/2);

  138. 			Y=m_y-(m_PluginNameList.size()*5)+Pos*10;

  139. 						

  140. 			if (Fl::event_y()>Y-10 && Fl::event_y()<Y && 

  141. 				Fl::event_x()>X && Fl::event_x()<X+textw) 

  142. 			{

  143. 				fl_font(fl_font(),15);

  144. 				fl_measure(i->first.c_str(), textw, texth);

  145. 				X=m_x-(textw/2);

  146. 				m_Selected=i->second;

  147. 				selected=true;

  148. 			}

  149. 			else selected=false;

  150. 						

  151. 			fl_color(FL_GRAY);

  152. 						

  153. 			fl_color(FL_WHITE);

  154. 			fl_draw(i->first.c_str(),X-1,Y+1);

  155. 

  156. 			if (selected) fl_color(FL_BLUE);	

  157. 			else fl_color(FL_BLACK);			

  158. 

  159. 			fl_draw(i->first.c_str(),X,Y);			

  160. 			

  161. 			Pos+=1;	

  162. 		}

  163. 	}

  164. }

  165. 

  166. ////////////////////////////////////////////////////////////////////////

  167. 

  168. void Fl_Canvas::Poll()

  169. {

  170. 	// bit of a workaround...	

  171. 	if (UserMakingConnection()) m_UpdateTimer++;

  172. 		

  173. 	if (m_UpdateTimer>UPDATE_TICKS) 

  174. 	{

  175. 		m_UpdateTimer=0;

  176. 		redraw();

  177. 	}

  178. }

  179. 

  180. ////////////////////////////////////////////////////////////////////////

  181. 

  182. void Fl_Canvas::DrawWires()

  183. {

  184. 	for(vector<CanvasWire>::iterator i=m_WireVec.begin();

  185. 		i!=m_WireVec.end(); i++)

  186. 	{

  187. 		if (i->OutputChild>children() || i->InputChild>children())

  188. 		{

  189. 			cerr<<"wire output child = "<<i->OutputChild<<endl;

  190. 			cerr<<"wire input child = "<<i->InputChild<<endl;

  191. 			SpiralInfo::Alert("Wire drawing mismatch!");

  192. 			return;

  193. 		}

  194. 			   

  195. 		Fl_DeviceGUI* SourceDevice = (Fl_DeviceGUI*)(child(i->OutputChild));

  196. 		Fl_DeviceGUI* DestDevice   = (Fl_DeviceGUI*)(child(i->InputChild));

  197. 			 

  198. 		if (!SourceDevice || !DestDevice) 

  199. 		{

  200. 			SpiralInfo::Alert("Cant find source or dest device while drawing wires");

  201. 			return;

  202. 		}

  203. 

  204.          Fl_Color col = (Fl_Color) WIRE_COL0;

  205.          switch (SourceDevice->GetPortType(i->OutputPort+SourceDevice->GetInfo()->NumInputs)) {

  206.              case 0:     col = (Fl_Color) WIRE_COL0; break;

  207.              case 1:     col = (Fl_Color) WIRE_COL1; break;

  208.              case 2:     col = (Fl_Color) WIRE_COL2; break;

  209.              case 3:     col = (Fl_Color) WIRE_COL3; break;

  210.              case 4:     col = (Fl_Color) WIRE_COL4; break;

  211.              default:    col = (Fl_Color) WIRE_COL0;

  212.          }

  213.  		fl_color(col);

  214. 

  215. 		fl_line(SourceDevice->GetPortX(i->OutputPort+SourceDevice->GetInfo()->NumInputs),

  216. 				SourceDevice->GetPortY(i->OutputPort+SourceDevice->GetInfo()->NumInputs),

  217. 				DestDevice->GetPortX(i->InputPort),

  218. 				DestDevice->GetPortY(i->InputPort));	

  219. 	}

  220. 	

  221. 	DrawIncompleteWire();

  222. }

  223. 

  224. ////////////////////////////////////////////////////////////////////////

  225. 

  226. bool Fl_Canvas::UserMakingConnection()

  227. {

  228. 	return 	(m_IncompleteWire.InputChild!=-1 || m_IncompleteWire.OutputChild!=-1);

  229. }

  230. 

  231. ////////////////////////////////////////////////////////////////////////

  232. 

  233. void Fl_Canvas::DrawIncompleteWire()

  234. {	

  235. 	// draw the wire we are currently connecting

  236. 	if(m_IncompleteWire.InputChild!=-1)

  237. 	{

  238. 		Fl_DeviceGUI* Device = (Fl_DeviceGUI*)(child(m_IncompleteWire.InputChild));

  239. 		

  240. 		if (!Device) 

  241. 		{

  242. 			SpiralInfo::Alert("Cant find source or dest device while drawing wires");

  243. 			return;

  244. 		}

  245. 		

  246. 		

  247.         Fl_Color col = (Fl_Color) WIRE_COL0;

  248.          switch (Device->GetPortType(m_IncompleteWire.InputPort)) {

  249.              case 0:     col = (Fl_Color) WIRE_COL0; break;

  250.              case 1:     col = (Fl_Color) WIRE_COL1; break;

  251.              case 2:     col = (Fl_Color) WIRE_COL2; break;

  252.              case 3:     col = (Fl_Color) WIRE_COL3; break;

  253.              case 4:     col = (Fl_Color) WIRE_COL4; break;

  254.              default:    col = (Fl_Color) WIRE_COL0;

  255.          }

  256.  		fl_color(col);

  257. 

  258. 		fl_line(Device->GetPortX(m_IncompleteWire.InputPort),

  259. 				Device->GetPortY(m_IncompleteWire.InputPort),

  260. 				Fl::event_x(),

  261. 				Fl::event_y());	

  262. 	}

  263. 	

  264. 	if(m_IncompleteWire.OutputChild!=-1)

  265. 	{

  266. 		Fl_DeviceGUI* Device = (Fl_DeviceGUI*)(child(m_IncompleteWire.OutputChild));

  267. 		

  268. 		if (!Device) 

  269. 		{

  270. 			SpiralInfo::Alert("Cant find source or dest device while drawing wires");

  271. 			return;

  272. 		}

  273. 		

  274. 		

  275.         Fl_Color col = (Fl_Color) WIRE_COL0;

  276.          switch (Device->GetPortType(m_IncompleteWire.OutputPort+Device->GetInfo()->NumInputs)) {

  277.              case 0:     col = (Fl_Color) WIRE_COL0; break;

  278.              case 1:     col = (Fl_Color) WIRE_COL1; break;

  279.              case 2:     col = (Fl_Color) WIRE_COL2; break;

  280.              case 3:     col = (Fl_Color) WIRE_COL3; break;

  281.              case 4:     col = (Fl_Color) WIRE_COL4; break;

  282.              default:    col = (Fl_Color) WIRE_COL0;

  283.          }

  284.  		fl_color(col);

  285. 

  286. 		fl_line(Device->GetPortX(m_IncompleteWire.OutputPort+Device->GetInfo()->NumInputs),

  287. 				Device->GetPortY(m_IncompleteWire.OutputPort+Device->GetInfo()->NumInputs),

  288. 				Fl::event_x(),

  289. 				Fl::event_y());	

  290. 	}

  291. }

  292. 

  293. ////////////////////////////////////////////////////////////////////////

  294. 

  295. void Fl_Canvas::ClearIncompleteWire()

  296. {

  297. 	// Turn off both ports

  298. 	if (m_IncompleteWire.OutputChild!=-1)

  299. 	{

  300. 		((Fl_DeviceGUI*)(child(m_IncompleteWire.OutputChild)))->RemoveConnection(m_IncompleteWire.OutputPort+

  301. 			((Fl_DeviceGUI*)(child(m_IncompleteWire.OutputChild)))->GetInfo()->NumInputs);

  302. 	}

  303. 	

  304. 	if (m_IncompleteWire.InputChild!=-1)

  305. 	{

  306. 		((Fl_DeviceGUI*)(child(m_IncompleteWire.InputChild)))->RemoveConnection(m_IncompleteWire.InputPort);

  307. 	}

  308. 	m_IncompleteWire.Clear();

  309. }

  310. 

  311. ////////////////////////////////////////////////////////////////////////

  312. 

  313. int Fl_Canvas::handle(int event)

  314. {

  315. 	if (Fl_Group::handle(event)) return 1;

  316. 	

  317. 	if (event==FL_PUSH) 

  318. 	{

  319. 		ClearIncompleteWire();

  320. 		redraw();

  321. 	}

  322. 	

  323. 	if (Fl::event_button()==3)

  324. 	{

  325. 		if (event==FL_PUSH) 

  326. 		{	

  327. 			m_ToolMenu=true;

  328. 			m_x=Fl::event_x();

  329. 			m_y=Fl::event_y();

  330. 			redraw();

  331. 		}

  332. 		

  333. 		if (event==FL_DRAG)	redraw();

  334. 		

  335. 		if (event==FL_RELEASE && Fl::event_button()==3) 

  336. 		{

  337. 			m_ToolMenu=false;

  338. 			if (m_Selected!=-1 && cb_AddDevice) 

  339. 			{

  340. 				int args[3];

  341. 				args[0]=m_Selected;

  342. 				args[1]=m_x;

  343. 				args[2]=m_y;

  344. 				cb_AddDevice(this,args);

  345. 			}

  346. 			redraw();

  347. 		}	

  348. 	}

  349. 

  350. 	return 1;

  351. }

  352. 	

  353. ////////////////////////////////////////////////////////////////////////

  354. 

  355. void Fl_Canvas::PortClicked(Fl_DeviceGUI* Device, int Type, int Port, bool Value)

  356. {

  357. 	// find out which child this comes from.

  358. 	int ChildNum=-1;	

  359. 	for(int n=0; n<children(); n++)

  360. 	{

  361. 		if(child(n)==Device)

  362. 		{

  363. 			ChildNum=n;

  364. 		}

  365. 	}

  366. 	

  367. 	if (ChildNum==-1) 

  368. 	{

  369. 		SpiralInfo::Alert("Port clicked callback can't find source child.");

  370. 		return;

  371. 	}

  372. 	

  373. 	if(Value) // Turned on the port

  374. 	{

  375. 		if(m_IncompleteWire.InputChild==-1 || m_IncompleteWire.OutputChild==-1)

  376. 		{

  377. 			if (Type==Fl_DeviceGUI::OUTPUT)

  378. 			{

  379. 				// make sure we don't make a output->output connection

  380. 				if (m_IncompleteWire.OutputChild==-1)

  381. 				{	

  382. 					m_IncompleteWire.OutputChild=ChildNum;

  383. 					m_IncompleteWire.OutputPort=Port;

  384. 					m_IncompleteWire.OutputID=Device->GetID();

  385. 					m_IncompleteWire.OutputTerminal=Device->IsTerminal();

  386. 				}

  387. 				else

  388. 				{

  389. 					ClearIncompleteWire();

  390. 				}

  391. 			}

  392. 			else

  393. 			{

  394. 				// make sure we don't make a input->input connection

  395. 				if (m_IncompleteWire.InputChild==-1)				

  396. 				{					

  397. 					m_IncompleteWire.InputChild=ChildNum;

  398. 					m_IncompleteWire.InputPort=Port;

  399. 					m_IncompleteWire.InputID=Device->GetID();

  400. 					m_IncompleteWire.InputTerminal=Device->IsTerminal();

  401. 				}

  402. 				else

  403. 				{

  404. 					ClearIncompleteWire();

  405. 				}

  406. 			}

  407. 

  408. 			// if both have now been set...

  409. 			if (m_IncompleteWire.InputChild!=-1 && m_IncompleteWire.OutputChild!=-1)

  410. 			{

  411. 				m_WireVec.push_back(m_IncompleteWire);	

  412. 	

  413. 				// send the connect callback

  414. 				cb_Connection(this,(void*)&m_IncompleteWire);

  415. 				m_Graph.AddConnection(m_IncompleteWire.OutputID,m_IncompleteWire.OutputTerminal,

  416. 									  m_IncompleteWire.InputID,m_IncompleteWire.InputTerminal);

  417. 				

  418. 				// Turn on both ports

  419. 				Fl_DeviceGUI* ODGUI = (Fl_DeviceGUI*)(child(m_IncompleteWire.OutputChild));

  420. 				ODGUI->AddConnection(m_IncompleteWire.OutputPort+ODGUI->GetInfo()->NumInputs);

  421. 					

  422. 				Fl_DeviceGUI* IDGUI = (Fl_DeviceGUI*)(child(m_IncompleteWire.InputChild));

  423. 				IDGUI->AddConnection(m_IncompleteWire.InputPort);

  424. 				

  425. 				

  426. 				m_IncompleteWire.Clear();

  427. 				

  428. 				redraw();

  429. 			}

  430. 		}

  431. 	}

  432. 	else // Turned off the port

  433. 	{	

  434. 		// Find connections using this port

  435. 		bool Found=true;

  436. 		

  437. 		while (Found)

  438. 		{

  439. 			Found=false;

  440. 			

  441. 			for(vector<CanvasWire>::iterator i=m_WireVec.begin();

  442. 				i!=m_WireVec.end(); i++)

  443. 			{

  444. 				if ((Type==Fl_DeviceGUI::OUTPUT && i->OutputChild==ChildNum && i->OutputPort==Port) ||

  445. 					(Type==Fl_DeviceGUI::INPUT && i->InputChild==ChildNum && i->InputPort==Port))

  446. 				{

  447. 					// Turn off both ports

  448. 					Fl_DeviceGUI* ODGUI = (Fl_DeviceGUI*)(child(i->OutputChild));

  449. 					ODGUI->RemoveConnection(i->OutputPort+ODGUI->GetInfo()->NumInputs);

  450. 					

  451. 					Fl_DeviceGUI* IDGUI = (Fl_DeviceGUI*)(child(i->InputChild));

  452. 					IDGUI->RemoveConnection(i->InputPort);

  453. 									

  454. 					// send the unconnect callback	

  455. 					cb_Unconnect(this,(void*)&(*i));

  456. 					m_Graph.RemoveConnection(i->OutputID,i->InputID);		

  457. 

  458. 					// Remove the wire

  459. 					m_WireVec.erase(i);

  460. 					

  461. 					Found=true;

  462. 					break;

  463. 				}

  464. 			}

  465. 		}

  466. 		

  467. 		redraw();

  468. 		

  469. 		// Clear the current selection

  470. 		m_IncompleteWire.Clear();

  471. 	}

  472. }

  473. 

  474. ////////////////////////////////////////////////////////////////////////

  475. 

  476. void Fl_Canvas::ClearConnections(Fl_DeviceGUI* Device)

  477. {

  478. 	// find out which child this comes from.

  479. 	int ChildNum=-1;	

  480. 	for(int n=0; n<children(); n++)

  481. 	{

  482. 		if(child(n)==Device)

  483. 		{

  484. 			ChildNum=n;

  485. 		}

  486. 	}

  487. 	

  488. 	if (ChildNum==-1) 

  489. 	{

  490. 		SpiralInfo::Alert("Clear connections callback can't find source child.");

  491. 		return;

  492. 	}

  493. 	

  494. 	bool removedall=false;

  495. 		

  496. 	while (!removedall)

  497. 	{

  498. 		removedall=true;

  499. 		

  500. 		for (vector<CanvasWire>::iterator i=m_WireVec.begin();

  501. 			 i!=m_WireVec.end(); i++)

  502. 		{	

  503. 			if (i->OutputChild==ChildNum ||

  504. 			    i->InputChild==ChildNum)

  505. 			{

  506. 				// Turn off both ports

  507. 				((Fl_DeviceGUI*)(child(i->OutputChild)))->RemoveConnection(i->OutputPort+

  508. 					((Fl_DeviceGUI*)(child(i->OutputChild)))->GetInfo()->NumInputs);

  509. 				((Fl_DeviceGUI*)(child(i->InputChild)))->RemoveConnection(i->InputPort);

  510. 

  511. 				// send the unconnect callback

  512. 				cb_Unconnect(this,(void*)&(*i));

  513. 				m_Graph.RemoveConnection(i->OutputID,i->InputID);

  514. 				

  515. 				m_WireVec.erase(i);

  516. 				removedall=false;

  517. 				break;

  518. 			}

  519. 		}

  520. 	}

  521. }

  522. 

  523. ////////////////////////////////////////////////////////////////////////

  524. 	

  525. void Fl_Canvas::RemoveDevice(Fl_DeviceGUI* Device)

  526. {

  527. 	// find out which child this comes from.

  528. 	int ChildNum=-1;	

  529. 	for(int n=0; n<children(); n++)

  530. 	{

  531. 		if(child(n)==Device)

  532. 		{

  533. 			ChildNum=n;

  534. 		}

  535. 	}

  536. 	

  537. 	if (ChildNum==-1) 

  538. 	{

  539. 		SpiralInfo::Alert("Remove device callback can't find source child.");

  540. 		return;

  541. 	}

  542. 

  543. 	ClearConnections(Device);

  544. 

  545. 	for (vector<CanvasWire>::iterator i=m_WireVec.begin();

  546. 		 i!=m_WireVec.end(); i++)

  547. 	{	

  548. 		if (i->OutputChild>ChildNum) i->OutputChild--;		

  549. 		if (i->InputChild>ChildNum)	 i->InputChild--;

  550. 	}

  551. 	

  552. 	remove(child(ChildNum));

  553. 	redraw(); 

  554. }

  555. 

  556. ////////////////////////////////////////////////////////////////////////

  557. 	

  558. void Fl_Canvas::Clear() 

  559. { 

  560. 	m_Graph.Clear();

  561. 

  562. 	int kids=children();

  563. 

  564. 	for(int n=0; n<kids; n++)

  565. 	{

  566. 		remove(child(0));		

  567. 	}	

  568. 	

  569. 	m_WireVec.clear(); 

  570. 	redraw(); 

  571. }

  572. 

  573. 

  574. ////////////////////////////////////////////////////////////////////////

  575. 

  576. void Fl_Canvas::Rename(Fl_DeviceGUI* Device)

  577. {

  578. 	if (cb_Rename) cb_Rename(this,Device);

  579. }

  580. 

  581. ////////////////////////////////////////////////////////////////////////

  582. 	

  583. 	

  584. istream &operator>>(istream &s, Fl_Canvas &o)

  585. {

  586. 	int NumWires;

  587. 	s>>NumWires;

  588. 	

  589. 	// my bad, didn't version this stream - remove one day...

  590. 	if (NumWires==-1)

  591. 	{

  592. 		int version;

  593. 		s>>version;

  594. 		s>>NumWires;

  595. 		

  596. 		for(int n=0; n<NumWires; n++)

  597. 		{

  598. 			CanvasWire NewWire;

  599. 			

  600. 			s>>NewWire.OutputID;

  601. 			s>>NewWire.OutputChild;

  602. 			s>>NewWire.OutputPort;

  603. 			s>>NewWire.OutputTerminal;

  604. 			s>>NewWire.InputID;

  605. 			s>>NewWire.InputChild;

  606. 			s>>NewWire.InputPort;	

  607. 			s>>NewWire.InputTerminal;

  608. 			

  609. 			// if we can turn on both ports

  610. 			if (((Fl_DeviceGUI*)(o.child(NewWire.OutputChild)))->AddConnection(NewWire.OutputPort+

  611. 					((Fl_DeviceGUI*)(o.child(NewWire.OutputChild)))->GetInfo()->NumInputs) &&

  612. 				((Fl_DeviceGUI*)(o.child(NewWire.InputChild)))->AddConnection(NewWire.InputPort))

  613. 			{

  614. 				o.m_WireVec.push_back(NewWire);	

  615. 

  616. 				// Notify connection by callback

  617. 				o.cb_Connection(&o,(void*)&NewWire);

  618. 				o.m_Graph.AddConnection(NewWire.OutputID,NewWire.OutputTerminal,NewWire.InputID,NewWire.InputTerminal);

  619. 			}				

  620. 		}

  621. 		

  622. 	}

  623. 	else

  624. 	{		

  625. 		for(int n=0; n<NumWires; n++)

  626. 		{

  627. 			CanvasWire NewWire;

  628. 			

  629. 			s>>NewWire.OutputID;

  630. 			s>>NewWire.OutputChild;

  631. 			s>>NewWire.OutputPort;

  632. 			s>>NewWire.InputID;

  633. 			s>>NewWire.InputChild;

  634. 			s>>NewWire.InputPort;	

  635. 	

  636. 			// if we can turn on both ports

  637. 			if (((Fl_DeviceGUI*)(o.child(NewWire.OutputChild)))->AddConnection(NewWire.OutputPort+

  638. 					((Fl_DeviceGUI*)(o.child(NewWire.OutputChild)))->GetInfo()->NumInputs) &&

  639. 				((Fl_DeviceGUI*)(o.child(NewWire.InputChild)))->AddConnection(NewWire.InputPort))

  640. 			{

  641. 				o.m_WireVec.push_back(NewWire);	

  642. 

  643. 				// Notify connection by callback

  644. 				o.cb_Connection(&o,(void*)&NewWire);

  645. 				o.m_Graph.AddConnection(NewWire.OutputID,false,NewWire.InputID,false);

  646. 			}					

  647. 		}

  648. 	}	

  649. 	return s;

  650. }

  651. 

  652. ////////////////////////////////////////////////////////////////////////

  653. 

  654. ostream &operator<<(ostream &s, Fl_Canvas &o)

  655. {

  656. 	int version=0;

  657. 	s<<-1<<" "<<version<<" ";

  658. 	

  659. 	s<<o.m_WireVec.size()<<endl;

  660. 

  661. 	for(vector<CanvasWire>::iterator i=o.m_WireVec.begin();

  662. 		i!=o.m_WireVec.end(); i++)

  663. 	{

  664. 		s<<i->OutputID<<" ";

  665. 		s<<i->OutputChild<<" ";

  666. 		s<<i->OutputPort<<" ";

  667. 		s<<i->OutputTerminal<<" ";

  668. 		s<<i->InputID<<" ";

  669. 		s<<i->InputChild<<" ";

  670. 		s<<i->InputPort<<" ";	

  671. 		s<<i->InputTerminal<<endl;

  672. 	}

  673. 

  674. 	return s;

  675. }