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.
262 Commits
1 Branch
1.8MB
Tree: 0d1d13c3ed
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0d1d13c3ed'
${ noResults }
spiralsynthmodular/GUI/Widgets/Fl_Canvas.C

1089 lines
25KB
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/Fl_Scroll.H>

  21. #include "Fl_Canvas.h"

  22. #include "Fl_DeviceGUI.h"

  23. #include <iostream>

  24. #include "../../SpiralSound/SpiralInfo.h"

  25. 

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

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

  28. static const int UPDATE_TICKS = 5;

  29. 

  30. ////////////////////////////////////////////////////////////////////////

  31. 

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

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

  34. cb_Connection(NULL),

  35. cb_Unconnect(NULL),

  36. cb_AddDevice(NULL),

  37. m_ToolMenu(false),

  38. m_UpdateTimer(0),

  39. m_Selecting(false)

  40. {

  41. 	m_IncompleteWire.OutputID=-1;

  42. 	m_IncompleteWire.OutputPort=-1;

  43. 	m_IncompleteWire.OutputTerminal=false;

  44. 	m_IncompleteWire.InputID=-1;

  45. 	m_IncompleteWire.InputPort=-1;

  46. 	m_IncompleteWire.InputTerminal=false;

  47. 	

  48. 	m_BG=NULL;

  49. 	m_BGData=NULL;

  50. 	m_Menu=NULL;

  51. 	m_CanPaste=false;

  52. }

  53. 

  54. ////////////////////////////////////////////////////////////////////////

  55. 

  56. Fl_Canvas::~Fl_Canvas()

  57. {

  58. 	if (m_Menu) delete m_Menu;

  59. }

  60. 

  61. ////////////////////////////////////////////////////////////////////////

  62. 

  63. void Fl_Canvas::draw()

  64. {			

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

  66. 

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

  68. 	{ 	    

  69. 		if (m_BG)

  70. 		{

  71. 			int X=0,Y=0;

  72. 			while (Y<w())

  73. 			{	

  74. 				while (X<h())

  75. 				{

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

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

  78. 					X+=m_BG->w;

  79. #else

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

  81. #endif	

  82. 				}		

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

  84.  				Y+=m_BG->h;

  85. #else

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

  87. #endif

  88. 				X=0;

  89. 			}

  90. 		}

  91. 		else

  92. 		{

  93. 			draw_box();

  94. 		}

  95. 				

  96. 		// draw minimised modules first

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

  98. 		{

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

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

  101. 			{

  102.    	 			draw_child(o);

  103.    				draw_outside_label(o);

  104. 

  105. 				std::vector<int>::iterator sel = std::find( m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), ((Fl_DeviceGUI*)&o)->GetID() );

  106. 

  107. 				if (sel != m_Selection.m_DeviceIds.end())

  108. 				{

  109. 					fl_color(FL_YELLOW);

  110. 					fl_rect(o.x(), o.y(), o.w(), o.h());

  111. 				}				

  112. 			}

  113. 		}

  114. 		

  115. 		DrawWires();

  116. 		

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

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

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

  120. 		{

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

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

  123. 			{

  124.    	 			draw_child(o);

  125.    				draw_outside_label(o);

  126. 

  127. 				std::vector<int>::iterator sel = std::find( m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), ((Fl_DeviceGUI*)&o)->GetID() );

  128. 

  129. 				if (sel != m_Selection.m_DeviceIds.end())

  130. 				{

  131. 					fl_color(FL_YELLOW);

  132. 					fl_rect(o.x(), o.y(), o.w(), o.h());

  133. 				}				

  134. 			}

  135. 		}

  136. 	}

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

  138. 	{	

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

  140.   	}

  141. 	

  142. 	if (m_ToolMenu)

  143. 	{

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

  145. 		int DegreesPerItem=30;

  146. 		float conv=3.151/180.0f;

  147. 		bool selected=false;

  148. 		m_Selected=-1;

  149. 		

  150. 		fl_font(fl_font(),10);

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

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

  153. 		{								

  154. 			textw=0;

  155. 			fl_font(fl_font(),10);

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

  157. 			

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

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

  160. 						

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

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

  163. 			{

  164. 				fl_font(fl_font(),15);

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

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

  167. 				m_Selected=i->second;

  168. 				selected=true;

  169. 			}

  170. 			else selected=false;

  171. 						

  172. 			fl_color(FL_GRAY);

  173. 						

  174. 			fl_color(FL_WHITE);

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

  176. 

  177. 			if (selected) fl_color(FL_BLUE);	

  178. 			else fl_color(FL_BLACK);			

  179. 

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

  181. 			

  182. 			Pos+=1;	

  183. 		}

  184. 	}

  185. 	DrawSelection();

  186. }

  187. 

  188. ////////////////////////////////////////////////////////////////////////

  189. 

  190. void Fl_Canvas::Poll()

  191. {

  192. 	// bit of a workaround...	

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

  194. 		

  195. 	if (m_UpdateTimer>UPDATE_TICKS) 

  196. 	{

  197. 		m_UpdateTimer=0;

  198. 		redraw();

  199. 	}

  200. }

  201. 

  202. ////////////////////////////////////////////////////////////////////////

  203. 

  204. void Fl_Canvas::DrawSelection()

  205. {

  206. 	if (m_Selecting)

  207. 	{

  208. 		int X, Y, W, H;

  209. 				

  210. 		fl_color(FL_YELLOW);

  211. 

  212. 		X = min(m_StartSelectX, m_EndSelectX);

  213. 		Y = min(m_StartSelectY, m_EndSelectY);

  214. 		W = max(m_StartSelectX, m_EndSelectX) - X;

  215. 		H = max(m_StartSelectY, m_EndSelectY) - Y;

  216. 

  217. 		fl_rect(X-1, Y-1, W+2, H+2);

  218. 	}

  219. }

  220. 

  221. bool widget_intersects_rectangle (Fl_Widget* o, int X, int Y, int W, int H)

  222. {

  223. 	int src1_x1=o->x(), src1_y1=o->y();

  224. 	int src1_x2=o->x()+o->w(), src1_y2=o->y()+o->h();

  225. 

  226. 	int src2_x1=X, src2_y1=Y;

  227. 	int src2_x2=X+W, src2_y2=Y+H;

  228. 

  229. 	int width=0, height=0;

  230. 	

  231. 	if (X < o->x())

  232. 	{

  233. 		src1_x1=X;

  234. 		src1_y1=Y;

  235. 		src1_x2=X+W;

  236. 		src1_y2=Y+H;

  237. 

  238. 		src2_x1=o->x();

  239. 		src2_y1=o->y();

  240. 		src2_x2=o->w();

  241. 		src2_y2=o->h();

  242. 	}

  243. 

  244. 	if (src2_x1 < src1_x2)

  245. 	{

  246. 		if (src1_x2 < src2_x2)

  247. 			width = src1_x2 - src2_x1;

  248. 		else

  249. 			width = src2_x2 - src2_x1;

  250. 

  251. 		if (width == 0)

  252. 			return false;

  253. 		

  254. 		if (src2_y1 < src1_y1)

  255. 		{

  256. 			int tmp;

  257. 

  258. 			tmp = src2_x1;

  259. 			src2_x1=src1_x1;

  260. 			src1_x1=tmp;

  261. 			

  262. 			tmp = src2_y1;

  263. 			src2_y1=src1_y1;

  264. 			src1_y1=tmp;

  265. 

  266. 			tmp = src2_x2;

  267. 			src2_x2=src1_x2;

  268. 			src1_x2=tmp;

  269. 			

  270. 			tmp = src2_y2;

  271. 			src2_y2=src1_y2;

  272. 			src1_y2=tmp;

  273. 

  274. 		}

  275. 

  276. 		if (src2_y1 < src1_y2)

  277. 		{

  278. 			if (src1_y2 < src2_y2)

  279. 				height = src1_y2 - src2_y1;

  280. 			else

  281. 				height = src2_y2 - src2_y1;

  282. 

  283. 			if ((height == 0))

  284. 				return false;

  285. 			else

  286. 				return true;	

  287. 		}

  288. 	}

  289. 

  290. 	return false;

  291. }

  292. 

  293. void Fl_Canvas::CalculateSelection()

  294. {

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

  296. 	int X, Y, W, H;

  297. 				

  298. 	X = min(m_StartSelectX, m_EndSelectX);

  299. 	Y = min(m_StartSelectY, m_EndSelectY);

  300. 	W = max(m_StartSelectX, m_EndSelectX) - X;

  301. 	H = max(m_StartSelectY, m_EndSelectY) - Y;

  302. 

  303. 	m_HaveSelection = false;

  304. 	m_Selection.Clear();

  305. 	

  306.  	for (int i=0; i<children(); i++) 

  307. 	{

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

  309. 		if (widget_intersects_rectangle(&o, X, Y, W, H))

  310. 		{

  311. 			m_HaveSelection = true;

  312. 			m_Selection.m_DeviceIds.push_back(((Fl_DeviceGUI*)&o)->GetID());

  313. 			((Fl_DeviceGUI*)&o)->SetOnDragCallback(cb_OnDrag_s, this);

  314. 		}

  315. 	}

  316. }

  317. 

  318. inline void Fl_Canvas::cb_OnDrag_i(Fl_Widget* widget, int xoffset,int yoffset)

  319. {

  320. 	if ((widget) && (widget->parent()))

  321. 	{

  322. 		int moved_device_id = ((Fl_DeviceGUI*)(widget->parent()))->GetID();

  323. 

  324. 		if (m_HaveSelection)

  325. 		{

  326. 			if (m_Selection.m_DeviceIds.size() <= 0)

  327. 				m_HaveSelection = false;

  328. 

  329. 			for (unsigned int i=0; i<m_Selection.m_DeviceIds.size(); i++) 

  330. 			{

  331. 				int ID = Selection().m_DeviceIds[i];

  332. 				Fl_Widget *o = FindDevice(ID);

  333. 

  334. 				if ((o) && (m_Selection.m_DeviceIds[i] != moved_device_id))

  335. 				{

  336. 					o->position(o->x() + xoffset, o->y() + yoffset);

  337. 				}

  338. 			}

  339. 		}		

  340. 	}

  341. 	return;

  342. }

  343. 

  344. inline void Fl_Canvas::cb_DeleteDeviceGroup_i()

  345. {

  346. 	if (! m_HaveSelection)

  347. 		return;

  348. 

  349. 	//show some warning here	

  350. 

  351. 	for (unsigned int i=0; i<m_Selection.m_DeviceIds.size(); i++) 

  352. 	{

  353. 		int ID = m_Selection.m_DeviceIds[i];

  354. 		Fl_DeviceGUI* o = FindDevice(ID);

  355. 		if (o)

  356. 		{

  357. 			Fl_DeviceGUI::Kill(o);

  358. 		}	

  359. 

  360. 	}	

  361. 

  362. 	m_HaveSelection=false;  

  363. 	m_Selection.Clear(); 

  364. 	redraw();

  365. }

  366. 

  367. 

  368. void Fl_Canvas::PopupEditMenu(Fl_Group *group)

  369. {

  370. 	if (! (m_Menu)) 

  371. 	{

  372. 		m_Menu = new Fl_Menu_Button(Fl::event_x(),Fl::event_x(),4,4,"Edit");

  373. 		m_Menu->type(Fl_Menu_Button::POPUP123);

  374. 		m_Menu->textsize(10);

  375. 

  376. 		m_Menu->add("Cut Currently Selected Devices", 0, (Fl_Callback*)cb_CutDeviceGroup,user_data());

  377. 		m_Menu->add("Copy Currently Selected Devices", 0, (Fl_Callback*)cb_CopyDeviceGroup,user_data());

  378. 		m_Menu->add("Paste Previously Copied Devices", 0, (Fl_Callback*)cb_PasteDeviceGroup,user_data(), FL_MENU_DIVIDER);

  379. 		m_Menu->add("Merge Existing Patch", 0, (Fl_Callback*)cb_MergePatch,user_data(), FL_MENU_DIVIDER);

  380. 		m_Menu->add("Delete Currently Selected Devices", 0, (Fl_Callback*)cb_DeleteDeviceGroup, this);

  381. 	}	

  382. 

  383. 	m_Menu->value(0);

  384. 	group->add(m_Menu);

  385. 	Fl_Menu_Item *cut=(Fl_Menu_Item*)&(m_Menu->menu()[0]);

  386. 	Fl_Menu_Item *copy=(Fl_Menu_Item*)&(m_Menu->menu()[1]);

  387. 	Fl_Menu_Item *paste=(Fl_Menu_Item*)&(m_Menu->menu()[2]);

  388. 	Fl_Menu_Item *merge=(Fl_Menu_Item*)&(m_Menu->menu()[3]);

  389. 	Fl_Menu_Item *deleteitems=(Fl_Menu_Item*)&(m_Menu->menu()[4]);

  390. 		

  391. 	if ((cb_CopyDeviceGroup) && (m_HaveSelection))

  392. 		copy->activate();

  393. 	else	

  394. 		copy->deactivate();

  395. 			

  396. 	if ((cb_CutDeviceGroup) && (m_HaveSelection))

  397. 		cut->activate();

  398. 	else	

  399. 		cut->deactivate();

  400. 

  401. 	if ((cb_PasteDeviceGroup) && (m_CanPaste))

  402. 		paste->activate();

  403. 	else	

  404. 		paste->deactivate();

  405. 

  406. 		

  407. 	if (m_HaveSelection)

  408. 		deleteitems->activate();

  409. 	else	

  410. 		deleteitems->deactivate();

  411. 

  412. 	m_Menu->popup();

  413. 	group->remove(m_Menu);

  414. }

  415. 

  416. void Fl_Canvas::StreamSelectionWiresIn(istream &s, std::map<int,int> NewDeviceIds, bool merge, bool paste)

  417. {

  418. 	MapNewDeviceIds = NewDeviceIds;

  419. 	StreamWiresIn(s, merge, paste);

  420. }

  421. 	

  422. void Fl_Canvas::StreamSelectionWiresOut(ostream &s)

  423. {	

  424. 	int total_wires = 0, curpos=0;

  425. 

  426. 	curpos = s.tellp();

  427. 	

  428. 	s<<-1<<endl;

  429. 

  430. 	if (m_WireVec.size()>0)

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

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

  433. 		{

  434. 			std::vector<int>::iterator output = std::find( m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), i->OutputID );

  435. 			std::vector<int>::iterator input = std::find( m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), i->InputID );

  436. 	

  437. 			if ((input != m_Selection.m_DeviceIds.end()) && (output != m_Selection.m_DeviceIds.end()))

  438. 			{

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

  440. 				s<<0<<" ";

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

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

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

  444. 				s<<0<<" ";

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

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

  447. 		

  448. 				total_wires += 1;

  449. 			}

  450. 		}

  451. 

  452. 	if (total_wires >= 1)

  453. 	{	

  454. 		s.seekp(curpos, ios::beg);

  455. 		s<<total_wires<<endl;

  456. 		s.seekp(0, ios::end);

  457. 	}	

  458. }

  459. 

  460. ////////////////////////////////////////////////////////////////////////

  461. 

  462. void Fl_Canvas::DrawWires()

  463. {

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

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

  466. 	{  

  467. 		Fl_DeviceGUI* SourceDevice = FindDevice(i->OutputID);

  468. 		Fl_DeviceGUI* DestDevice   = FindDevice(i->InputID);

  469. 			 

  470. 		if (!SourceDevice || !DestDevice) 

  471. 		{

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

  473. 			return;

  474. 		}

  475. 

  476.          Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  483.              default:    col = (Fl_Color) WIRE_COL0;

  484.          }

  485.  		fl_color(col);

  486. 

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

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

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

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

  491. 	}

  492. 	

  493. 	DrawIncompleteWire();

  494. }

  495. 

  496. ////////////////////////////////////////////////////////////////////////

  497. 

  498. bool Fl_Canvas::UserMakingConnection()

  499. {

  500. 	return 	(m_IncompleteWire.InputID!=-1 || m_IncompleteWire.OutputID!=-1);

  501. }

  502. 

  503. ////////////////////////////////////////////////////////////////////////

  504. 

  505. void Fl_Canvas::DrawIncompleteWire()

  506. {	

  507. 	// draw the wire we are currently connecting

  508. 	if(m_IncompleteWire.InputID!=-1)

  509. 	{

  510. 		Fl_DeviceGUI* Device = FindDevice(m_IncompleteWire.InputID);

  511. 		

  512. 		if (!Device) 

  513. 		{

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

  515. 			return;

  516. 		}

  517. 		

  518. 		

  519.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  526.              default:    col = (Fl_Color) WIRE_COL0;

  527.          }

  528.  		fl_color(col);

  529. 

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

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

  532. 				Fl::event_x(),

  533. 				Fl::event_y());	

  534. 	}

  535. 	

  536. 	if(m_IncompleteWire.OutputID!=-1)

  537. 	{

  538. 		Fl_DeviceGUI* Device = FindDevice(m_IncompleteWire.OutputID);

  539. 		

  540. 		if (!Device) 

  541. 		{

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

  543. 			return;

  544. 		}

  545. 		

  546. 		

  547.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  554.              default:    col = (Fl_Color) WIRE_COL0;

  555.          }

  556.  		fl_color(col);

  557. 

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

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

  560. 				Fl::event_x(),

  561. 				Fl::event_y());	

  562. 	}

  563. }

  564. 

  565. ////////////////////////////////////////////////////////////////////////

  566. 

  567. void Fl_Canvas::ClearIncompleteWire()

  568. {

  569. 	// Turn off both ports

  570. 	if (m_IncompleteWire.OutputID!=-1)

  571. 	{

  572. 		FindDevice(m_IncompleteWire.OutputID)->RemoveConnection(m_IncompleteWire.OutputPort+FindDevice(m_IncompleteWire.OutputID)->GetInfo()->NumInputs);

  573. 	}

  574. 	

  575. 	if (m_IncompleteWire.InputID!=-1)

  576. 	{

  577. 		FindDevice(m_IncompleteWire.InputID)->RemoveConnection(m_IncompleteWire.InputPort);

  578. 	}

  579. 	m_IncompleteWire.Clear();

  580. }

  581. 

  582. ////////////////////////////////////////////////////////////////////////

  583. 

  584. int Fl_Canvas::handle(int event)

  585. {

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

  587. 		

  588. 	if (event==FL_PUSH) 

  589. 	{

  590. 		ClearIncompleteWire();

  591. 		redraw();

  592. 		m_DragX=Fl::event_x();

  593. 		m_DragY=Fl::event_y();

  594. 	}

  595. 	

  596. 	if (Fl::event_button()==1)

  597. 	{

  598. 		if (event==FL_PUSH) 

  599. 		{	

  600. 			if (m_HaveSelection) 

  601. 			{

  602. 				m_Selection.Clear();

  603. 				m_HaveSelection = false;

  604. 			}   

  605. 

  606. 			if ((Fl::event_state() & FL_CTRL) != 0)

  607. 			{

  608. 				m_Selecting = true;

  609. 				m_StartSelectX=Fl::event_x();

  610. 				m_StartSelectY=Fl::event_y();	

  611. 				m_EndSelectX=Fl::event_x();

  612. 				m_EndSelectY=Fl::event_y();	

  613. 			}			

  614. 

  615. 			ClearIncompleteWire();

  616. 			redraw();

  617. 			m_DragX=Fl::event_x();

  618. 			m_DragY=Fl::event_y();

  619. 			

  620. 		}

  621. 

  622. 		if (event==FL_DRAG)

  623. 		{

  624. 			if (m_Selecting)

  625. 			{

  626. 				m_EndSelectX=Fl::event_x();

  627. 				m_EndSelectY=Fl::event_y();					

  628. 

  629. 				int newx=0, newy=0, xp=((Fl_Scroll *)parent())->xposition(), yp=((Fl_Scroll *)parent())->yposition();

  630. 

  631. 				if ((m_EndSelectX < m_StartSelectX) && ((m_EndSelectX - x() - xp) <= 15))

  632. 					newx=10;

  633. 			

  634. 				if ((m_EndSelectY < m_StartSelectY) && ((m_EndSelectY - y() - yp) <= 15))

  635. 					newy=10;	

  636. 

  637. 				if ((m_EndSelectX > m_StartSelectX) && ((((Fl_Scroll *)parent())->x() + ((Fl_Scroll *)parent())->w() - m_EndSelectX - 15) <= 15))

  638. 					newx=-10;	

  639. 					

  640. 				if ((m_EndSelectY > m_StartSelectY) && ((((Fl_Scroll *)parent())->y() + ((Fl_Scroll *)parent())->h() - m_EndSelectY - 15) <= 5))

  641. 					newy=-10;	

  642. 

  643. 				if ((newx!=0) || (newy!=0)) {

  644. 					position(x()+newx,y()+newy);	

  645. 

  646. 					m_StartSelectX += newx;

  647. 					m_StartSelectY += newy;					

  648. 					

  649. 				}	

  650. 			}

  651. 			else

  652. 			{

  653. 				position(x()+(Fl::event_x()-m_DragX),y()+(Fl::event_y()-m_DragY));	

  654. 			}	

  655. 

  656. 			m_DragX=Fl::event_x();

  657. 			m_DragY=Fl::event_y();	

  658. 			redraw();

  659. 		}

  660. 

  661. 		if (event==FL_RELEASE) 

  662. 		{	

  663. 			if (m_Selecting) 

  664. 			{

  665. 				m_Selecting = false;

  666. 

  667. 				if ((m_EndSelectX != m_StartSelectX) && (m_EndSelectY != m_StartSelectY))

  668. 					CalculateSelection();

  669. 

  670. 				redraw();

  671. 			}   

  672. 

  673. 		}

  674. 	}

  675. 	

  676. 	if (Fl::event_button()==2)

  677. 	{

  678. 		if (event==FL_PUSH) 

  679. 		{	

  680. 			m_ToolMenu=true;

  681. 			m_x=Fl::event_x();

  682. 			m_y=Fl::event_y();

  683. 			redraw();

  684. 		}

  685. 		

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

  687. 		

  688. 		if (event==FL_RELEASE) 

  689. 		{

  690. 			m_ToolMenu=false;

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

  692. 			{

  693. 				int args[3];

  694. 				args[0]=m_Selected;

  695. 				args[1]=m_x;

  696. 				args[2]=m_y;

  697. 				cb_AddDevice(this,args);

  698. 			}

  699. 			redraw();

  700. 		}	

  701. 	}

  702. 

  703. 	if ((Fl::event_button()==3) && (event==FL_PUSH)  && ((Fl::event_state() & FL_CTRL) != 0))

  704. 	{

  705. 		PopupEditMenu(this);

  706. 	}			

  707. 	

  708. 	return 1;

  709. }

  710. 

  711. ////////////////////////////////////////////////////////////////////////

  712. 

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

  714. {

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

  716. 	{

  717. 		if(m_IncompleteWire.InputID==-1 || m_IncompleteWire.OutputID==-1)

  718. 		{

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

  720. 			{

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

  722. 				if (m_IncompleteWire.OutputID==-1)

  723. 				{	

  724. 					m_IncompleteWire.OutputPort=Port;

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

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

  727. 				}

  728. 				else

  729. 				{

  730. 					ClearIncompleteWire();

  731. 				}

  732. 			}

  733. 			else

  734. 			{

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

  736. 				if (m_IncompleteWire.InputID==-1)				

  737. 				{					

  738. 					m_IncompleteWire.InputPort=Port;

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

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

  741. 				}

  742. 				else

  743. 				{

  744. 					ClearIncompleteWire();

  745. 				}

  746. 			}

  747. 

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

  749. 			if (m_IncompleteWire.InputID!=-1 && m_IncompleteWire.OutputID!=-1)

  750. 			{

  751. 				m_WireVec.push_back(m_IncompleteWire);	

  752. 	

  753. 				// send the connect callback

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

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

  756. 									  m_IncompleteWire.InputID,m_IncompleteWire.InputTerminal);

  757. 				

  758. 				// Turn on both ports

  759. 				Fl_DeviceGUI* ODGUI = FindDevice(m_IncompleteWire.OutputID);

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

  761. 					

  762. 				Fl_DeviceGUI* IDGUI = FindDevice(m_IncompleteWire.InputID);

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

  764. 				

  765. 				m_IncompleteWire.Clear();

  766. 				

  767. 				redraw();

  768. 			}

  769. 		}

  770. 	}

  771. 	else // Turned off the port

  772. 	{	

  773. 		// Find connections using this port

  774. 		bool Found=true;

  775. 		

  776. 		while (Found)

  777. 		{

  778. 			Found=false;

  779. 			

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

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

  782. 			{

  783. 				if ((Type==Fl_DeviceGUI::OUTPUT && i->OutputID==Device->GetID() && i->OutputPort==Port) ||

  784. 					(Type==Fl_DeviceGUI::INPUT && i->InputID==Device->GetID() && i->InputPort==Port))

  785. 				{

  786. 					// Turn off both ports

  787. 					Fl_DeviceGUI* ODGUI = FindDevice(i->OutputID);

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

  789. 					

  790. 					Fl_DeviceGUI* IDGUI = FindDevice(i->InputID);

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

  792. 									

  793. 					// send the unconnect callback	

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

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

  796. 

  797. 					// Remove the wire

  798. 					m_WireVec.erase(i);

  799. 					

  800. 					Found=true;

  801. 					break;

  802. 				}

  803. 			}

  804. 		}

  805. 		

  806. 		redraw();

  807. 		

  808. 		// Clear the current m_Selection

  809. 		m_IncompleteWire.Clear();

  810. 	}

  811. }

  812. 

  813. ////////////////////////////////////////////////////////////////////////

  814. 

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

  816. {

  817. 	bool removedall=false;

  818. 	

  819. 	//make sure we don't leave a dangling incomplete wire this will cause errors/seg-faults

  820. 	if (UserMakingConnection() && Device && ((Device->GetID() == m_IncompleteWire.OutputID) || 

  821. 		(Device->GetID() == m_IncompleteWire.InputID)))

  822. 	{

  823. 		ClearIncompleteWire();

  824. 	}	

  825. 	

  826. 	while (!removedall)

  827. 	{

  828. 		removedall=true;

  829. 		

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

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

  832. 		{	

  833. 			if (i->OutputID==Device->GetID() ||

  834. 			    i->InputID==Device->GetID())

  835. 			{

  836. 				// Turn off both ports

  837. 				FindDevice(i->OutputID)->RemoveConnection(i->OutputPort+FindDevice(i->OutputID)->GetInfo()->NumInputs);

  838. 				FindDevice(i->InputID)->RemoveConnection(i->InputPort);

  839. 

  840. 				// send the unconnect callback

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

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

  843. 				

  844. 				m_WireVec.erase(i);

  845. 				removedall=false;

  846. 				break;

  847. 			}

  848. 		}

  849. 	}

  850. }

  851. 

  852. ////////////////////////////////////////////////////////////////////////

  853. 	

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

  855. {

  856. 	ClearConnections(Device);

  857. 	remove(Device);

  858. 	redraw(); 

  859. }

  860. 

  861. ////////////////////////////////////////////////////////////////////////

  862. 	

  863. void Fl_Canvas::Clear() 

  864. { 

  865. 	m_Graph.Clear();

  866. 

  867. 	int kids=children();

  868. 

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

  870. 	{

  871. 		remove(child(0));		

  872. 	}	

  873. 	

  874. 	m_WireVec.clear(); 

  875. 	redraw(); 

  876. }

  877. 

  878. 

  879. ////////////////////////////////////////////////////////////////////////

  880. 

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

  882. {

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

  884. }

  885. 

  886. ////////////////////////////////////////////////////////////////////////

  887. 

  888. Fl_DeviceGUI *Fl_Canvas::FindDevice(int ID)

  889. {

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

  891. 	{

  892. 		if(((Fl_DeviceGUI*)child(n))->GetID()==ID)

  893. 		{

  894. 			return (Fl_DeviceGUI*)child(n);

  895. 		}

  896. 	}

  897. 	return NULL;

  898. }

  899. 	

  900. /////////////////////////////////////////////////////////////////////////

  901. 

  902. void Fl_Canvas::ToTop(Fl_DeviceGUI *o)

  903. {

  904. 	if (children()<2) return; //no need to do anything

  905. 

  906. 	// cast away the const :P

  907. 	Fl_Widget** a=(Fl_Widget**)array();

  908. 	int p=find(o);

  909. 

  910. 	if (p<0) 

  911. 	{

  912. 		cerr<<"ToTop couldn't find widget!"<<endl;

  913. 		return;

  914. 	}

  915. 	

  916. 	Fl_Widget *temp=a[0];

  917. 	Fl_Widget *last=a[0];

  918. 	

  919. 	for(int n=1; n<children(); n++)

  920. 	{

  921. 		if (n>p) // after the widget in the list

  922. 		{	

  923. 			// move the widgets up

  924. 			a[n-1]=a[n];

  925. 		}

  926. 	}

  927. 	

  928. 	a[children()-1]=o; // put the raised one at the top of the list

  929. }

  930. 

  931. void Fl_Canvas::ToBot(Fl_DeviceGUI *o)

  932. {

  933. 	if (children()<2) return; //no need to do anything

  934. 	

  935. 	// cast away the const :P

  936. 	Fl_Widget** a=(Fl_Widget**)array();

  937. 	int p=find(o);

  938. 

  939. 	if (p<0) 

  940. 	{

  941. 		cerr<<"ToBot couldn't find widget!"<<endl;

  942. 		return;

  943. 	}

  944. 	

  945. 	Fl_Widget *temp=a[0];

  946. 	Fl_Widget *last=a[0];

  947. 	

  948. 	for(int n=1; n<children(); n++)

  949. 	{

  950. 		if (n<=p) // before the widget in the list

  951. 		{	

  952. 			// move the widgets down

  953. 			temp=a[n];

  954. 			a[n]=last;

  955. 			last=temp;

  956. 		}

  957. 	}

  958. 	

  959. 	a[0]=o; // put the lowered one at the top of the list	

  960. }

  961. 

  962. /////////////////////////////////////////////////////////////////////////

  963. 

  964. void Fl_Canvas::StreamWiresIn(istream &s, bool merge, bool paste)

  965. {

  966. 	int NumWires;

  967. 

  968. 	s>>NumWires;

  969. 		

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

  971. 	if (paste || NumWires==-1)

  972. 	{

  973. 		int version;

  974. 

  975. 		if (!paste)

  976. 		{

  977. 			s>>version;

  978. 			s>>NumWires;

  979. 		}

  980. 		

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

  982. 		{

  983. 			CanvasWire NewWire;

  984. 			int dummy;

  985. 		

  986. 			s>>NewWire.OutputID;

  987. 			s>>dummy;

  988. 			s>>NewWire.OutputPort;

  989. 			s>>NewWire.OutputTerminal;

  990. 			s>>NewWire.InputID;

  991. 			s>>dummy;

  992. 			s>>NewWire.InputPort;	

  993. 			s>>NewWire.InputTerminal;

  994. 

  995. 			if (paste || merge)		

  996. 			{

  997. 				std::map<int, int>::iterator inputID = MapNewDeviceIds.find( NewWire.InputID);

  998. 				std::map<int, int>::iterator outputID = MapNewDeviceIds.find(NewWire.OutputID);

  999. 

  1000. 				if ((inputID != MapNewDeviceIds.end()) && (outputID != MapNewDeviceIds.end()))

  1001. 				{

  1002. 					NewWire.InputID = inputID->second;

  1003. 					NewWire.OutputID = outputID->second;

  1004. 				}

  1005. 			}		

  1006. 			// if we can turn on both ports

  1007. 			if (FindDevice(NewWire.OutputID)->AddConnection(NewWire.OutputPort+

  1008. 					FindDevice(NewWire.OutputID)->GetInfo()->NumInputs) &&

  1009. 				FindDevice(NewWire.InputID)->AddConnection(NewWire.InputPort))

  1010. 			{

  1011. 				m_WireVec.push_back(NewWire);	

  1012. 					// Notify connection by callback

  1013. 				cb_Connection(this,(void*)&NewWire);

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

  1015. 			}				

  1016. 		}

  1017. 	}	

  1018. 	else

  1019. 	{		

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

  1021. 		{

  1022. 			CanvasWire NewWire;

  1023. 			int dummy;

  1024. 			

  1025. 			s>>NewWire.OutputID;

  1026. 			s>>dummy;

  1027. 			s>>NewWire.OutputPort;

  1028. 			s>>NewWire.InputID;

  1029. 			s>>dummy;

  1030. 			s>>NewWire.InputPort;	

  1031. 		

  1032. 			if (paste || merge)		

  1033. 			{

  1034. 				std::map<int, int>::iterator inputID = MapNewDeviceIds.find( NewWire.InputID);

  1035. 				std::map<int, int>::iterator outputID = MapNewDeviceIds.find(NewWire.OutputID);

  1036. 

  1037. 				if ((inputID != MapNewDeviceIds.end()) && (outputID != MapNewDeviceIds.end()))

  1038. 				{

  1039. 					NewWire.InputID = inputID->second;

  1040. 					NewWire.OutputID = outputID->second;

  1041. 				}

  1042. 			}		

  1043. 

  1044. 			// if we can turn on both ports

  1045. 			if (FindDevice(NewWire.OutputID)->AddConnection(NewWire.OutputPort+

  1046. 					FindDevice(NewWire.OutputID)->GetInfo()->NumInputs) &&

  1047. 				FindDevice(NewWire.InputID)->AddConnection(NewWire.InputPort))

  1048. 			{

  1049. 				m_WireVec.push_back(NewWire);	

  1050. 

  1051. 				// Notify connection by callback

  1052. 				cb_Connection(this,(void*)&NewWire);

  1053. 				m_Graph.AddConnection(NewWire.OutputID,false,NewWire.InputID,false);

  1054. 			}					

  1055. 		}

  1056. 	}	

  1057. }

  1058. 

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

  1060. {

  1061. 	o.StreamWiresIn(s, false, false);

  1062. 	return s;

  1063. }

  1064. 

  1065. ////////////////////////////////////////////////////////////////////////

  1066. 

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

  1068. {

  1069. 	int version=0;

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

  1071. 	

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

  1073. 

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

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

  1076. 	{

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

  1078. 		s<<0<<" ";

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

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

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

  1082. 		s<<0<<" ";

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

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

  1085. 	}

  1086. 

  1087. 	return s;

  1088. }