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

1082 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. void Fl_Canvas::DeleteSelection (void) {

  345.      if (! m_HaveSelection) return;

  346.      // show some warning here

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

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

  349.          Fl_DeviceGUI* o = FindDevice(ID);

  350.          if (o) Fl_DeviceGUI::Kill(o);

  351.      }

  352.      m_HaveSelection = false;

  353.      m_Selection.Clear();

  354.      redraw();

  355. }

  356. 

  357. inline void Fl_Canvas::cb_DeleteDeviceGroup_i() {

  358.        DeleteSelection ();

  359. }

  360. 

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

  362. {

  363. 	if (! (m_Menu))

  364. 	{

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

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

  367. 		m_Menu->textsize(10);

  368. 

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

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

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

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

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

  374. 	}	

  375. 

  376. 	m_Menu->value(0);

  377. 	group->add(m_Menu);

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

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

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

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

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

  383. 		

  384. 	if ((cb_CopyDeviceGroup) && (m_HaveSelection))

  385. 		copy->activate();

  386. 	else	

  387. 		copy->deactivate();

  388. 			

  389. 	if ((cb_CutDeviceGroup) && (m_HaveSelection))

  390. 		cut->activate();

  391. 	else	

  392. 		cut->deactivate();

  393. 

  394. 	if ((cb_PasteDeviceGroup) && (m_CanPaste))

  395. 		paste->activate();

  396. 	else	

  397. 		paste->deactivate();

  398. 

  399. 		

  400. 	if (m_HaveSelection)

  401. 		deleteitems->activate();

  402. 	else	

  403. 		deleteitems->deactivate();

  404. 

  405. 	m_Menu->popup();

  406. 	group->remove(m_Menu);

  407. }

  408. 

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

  410. {

  411. 	MapNewDeviceIds = NewDeviceIds;

  412. 	StreamWiresIn(s, merge, paste);

  413. }

  414. 	

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

  416. {	

  417. 	int total_wires = 0, curpos=0;

  418. 

  419. 	curpos = s.tellp();

  420. 	

  421. 	s<<-1<<endl;

  422. 

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

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

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

  426. 		{

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

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

  429. 	

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

  431. 			{

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

  433. 				s<<0<<" ";

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

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

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

  437. 				s<<0<<" ";

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

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

  440. 		

  441. 				total_wires += 1;

  442. 			}

  443. 		}

  444. 

  445. 	if (total_wires >= 1)

  446. 	{	

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

  448. 		s<<total_wires<<endl;

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

  450. 	}	

  451. }

  452. 

  453. ////////////////////////////////////////////////////////////////////////

  454. 

  455. void Fl_Canvas::DrawWires()

  456. {

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

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

  459. 	{  

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

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

  462. 			 

  463. 		if (!SourceDevice || !DestDevice) 

  464. 		{

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

  466. 			return;

  467. 		}

  468. 

  469.          Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  476.              default:    col = (Fl_Color) WIRE_COL0;

  477.          }

  478.  		fl_color(col);

  479. 

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

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

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

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

  484. 	}

  485. 	

  486. 	DrawIncompleteWire();

  487. }

  488. 

  489. ////////////////////////////////////////////////////////////////////////

  490. 

  491. bool Fl_Canvas::UserMakingConnection()

  492. {

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

  494. }

  495. 

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

  497. 

  498. void Fl_Canvas::DrawIncompleteWire()

  499. {	

  500. 	// draw the wire we are currently connecting

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

  502. 	{

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

  504. 		

  505. 		if (!Device) 

  506. 		{

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

  508. 			return;

  509. 		}

  510. 		

  511. 		

  512.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  519.              default:    col = (Fl_Color) WIRE_COL0;

  520.          }

  521.  		fl_color(col);

  522. 

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

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

  525. 				Fl::event_x(),

  526. 				Fl::event_y());	

  527. 	}

  528. 	

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

  530. 	{

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

  532. 		

  533. 		if (!Device) 

  534. 		{

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

  536. 			return;

  537. 		}

  538. 		

  539. 		

  540.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  547.              default:    col = (Fl_Color) WIRE_COL0;

  548.          }

  549.  		fl_color(col);

  550. 

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

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

  553. 				Fl::event_x(),

  554. 				Fl::event_y());	

  555. 	}

  556. }

  557. 

  558. ////////////////////////////////////////////////////////////////////////

  559. 

  560. void Fl_Canvas::ClearIncompleteWire()

  561. {

  562. 	// Turn off both ports

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

  564. 	{

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

  566. 	}

  567. 	

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

  569. 	{

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

  571. 	}

  572. 	m_IncompleteWire.Clear();

  573. }

  574. 

  575. ////////////////////////////////////////////////////////////////////////

  576. 

  577. int Fl_Canvas::handle(int event)

  578. {

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

  580. 		

  581. 	if (event==FL_PUSH) 

  582. 	{

  583. 		ClearIncompleteWire();

  584. 		redraw();

  585. 		m_DragX=Fl::event_x();

  586. 		m_DragY=Fl::event_y();

  587. 	}

  588. 	

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

  590. 	{

  591. 		if (event==FL_PUSH) 

  592. 		{	

  593. 			if (m_HaveSelection) 

  594. 			{

  595. 				m_Selection.Clear();

  596. 				m_HaveSelection = false;

  597. 			}   

  598. 

  599. 			if (((Fl::event_state() & FL_CTRL) != 0) || ((Fl::event_state() & FL_SHIFT) != 0))

  600. 			{

  601. 				m_Selecting = true;

  602. 				m_StartSelectX=Fl::event_x();

  603. 				m_StartSelectY=Fl::event_y();	

  604. 				m_EndSelectX=Fl::event_x();

  605. 				m_EndSelectY=Fl::event_y();	

  606. 			}			

  607. 

  608. 			ClearIncompleteWire();

  609. 			redraw();

  610. 			m_DragX=Fl::event_x();

  611. 			m_DragY=Fl::event_y();

  612. 			

  613. 		}

  614. 

  615. 		if (event==FL_DRAG)

  616. 		{

  617. 			if (m_Selecting)

  618. 			{

  619. 				m_EndSelectX=Fl::event_x();

  620. 				m_EndSelectY=Fl::event_y();					

  621. 

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

  623. 

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

  625. 					newx=10;

  626. 			

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

  628. 					newy=10;	

  629. 

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

  631. 					newx=-10;	

  632. 					

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

  634. 					newy=-10;	

  635. 

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

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

  638. 

  639. 					m_StartSelectX += newx;

  640. 					m_StartSelectY += newy;					

  641. 					

  642. 				}	

  643. 			}

  644. 			else

  645. 			{

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

  647. 			}	

  648. 

  649. 			m_DragX=Fl::event_x();

  650. 			m_DragY=Fl::event_y();	

  651. 			redraw();

  652. 		}

  653. 

  654. 		if (event==FL_RELEASE) 

  655. 		{	

  656. 			if (m_Selecting) 

  657. 			{

  658. 				m_Selecting = false;

  659. 

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

  661. 					CalculateSelection();

  662. 

  663. 				redraw();

  664. 			}   

  665. 

  666. 		}

  667. 	}

  668. 	

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

  670. 	{

  671. 		if (event==FL_PUSH) 

  672. 		{	

  673. 			m_ToolMenu=true;

  674. 			m_x=Fl::event_x();

  675. 			m_y=Fl::event_y();

  676. 			redraw();

  677. 		}

  678. 		

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

  680. 		

  681. 		if (event==FL_RELEASE) 

  682. 		{

  683. 			m_ToolMenu=false;

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

  685. 			{

  686. 				int args[3];

  687. 				args[0]=m_Selected;

  688. 				args[1]=m_x;

  689. 				args[2]=m_y;

  690. 				cb_AddDevice(this,args);

  691. 			}

  692. 			redraw();

  693. 		}	

  694. 	}

  695. 

  696. 	if ((Fl::event_button()==3) && (event==FL_PUSH))

  697. 	{

  698. 		PopupEditMenu(this);

  699. 	}			

  700. 	

  701. 	return 1;

  702. }

  703. 

  704. ////////////////////////////////////////////////////////////////////////

  705. 

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

  707. {

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

  709. 	{

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

  711. 		{

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

  713. 			{

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

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

  716. 				{	

  717. 					m_IncompleteWire.OutputPort=Port;

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

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

  720. 				}

  721. 				else

  722. 				{

  723. 					ClearIncompleteWire();

  724. 				}

  725. 			}

  726. 			else

  727. 			{

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

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

  730. 				{					

  731. 					m_IncompleteWire.InputPort=Port;

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

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

  734. 				}

  735. 				else

  736. 				{

  737. 					ClearIncompleteWire();

  738. 				}

  739. 			}

  740. 

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

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

  743. 			{

  744. 				m_WireVec.push_back(m_IncompleteWire);	

  745. 	

  746. 				// send the connect callback

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

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

  749. 									  m_IncompleteWire.InputID,m_IncompleteWire.InputTerminal);

  750. 				

  751. 				// Turn on both ports

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

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

  754. 					

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

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

  757. 				

  758. 				m_IncompleteWire.Clear();

  759. 				

  760. 				redraw();

  761. 			}

  762. 		}

  763. 	}

  764. 	else // Turned off the port

  765. 	{	

  766. 		// Find connections using this port

  767. 		bool Found=true;

  768. 		

  769. 		while (Found)

  770. 		{

  771. 			Found=false;

  772. 			

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

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

  775. 			{

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

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

  778. 				{

  779. 					// Turn off both ports

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

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

  782. 					

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

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

  785. 									

  786. 					// send the unconnect callback	

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

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

  789. 

  790. 					// Remove the wire

  791. 					m_WireVec.erase(i);

  792. 					

  793. 					Found=true;

  794. 					break;

  795. 				}

  796. 			}

  797. 		}

  798. 		

  799. 		redraw();

  800. 		

  801. 		// Clear the current m_Selection

  802. 		m_IncompleteWire.Clear();

  803. 	}

  804. }

  805. 

  806. ////////////////////////////////////////////////////////////////////////

  807. 

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

  809. {

  810. 	bool removedall=false;

  811. 	

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

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

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

  815. 	{

  816. 		ClearIncompleteWire();

  817. 	}	

  818. 	

  819. 	while (!removedall)

  820. 	{

  821. 		removedall=true;

  822. 		

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

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

  825. 		{	

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

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

  828. 			{

  829. 				// Turn off both ports

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

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

  832. 

  833. 				// send the unconnect callback

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

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

  836. 				

  837. 				m_WireVec.erase(i);

  838. 				removedall=false;

  839. 				break;

  840. 			}

  841. 		}

  842. 	}

  843. }

  844. 

  845. ////////////////////////////////////////////////////////////////////////

  846. 	

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

  848. {

  849. 	ClearConnections(Device);

  850. 	remove(Device);

  851. 	redraw(); 

  852. }

  853. 

  854. ////////////////////////////////////////////////////////////////////////

  855. 	

  856. void Fl_Canvas::Clear() 

  857. { 

  858. 	m_Graph.Clear();

  859. 

  860. 	int kids=children();

  861. 

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

  863. 	{

  864. 		remove(child(0));		

  865. 	}	

  866. 	

  867. 	m_WireVec.clear(); 

  868. 	redraw(); 

  869. }

  870. 

  871. 

  872. ////////////////////////////////////////////////////////////////////////

  873. 

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

  875. {

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

  877. }

  878. 

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

  880. 

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

  882. {

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

  884. 	{

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

  886. 		{

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

  888. 		}

  889. 	}

  890. 	return NULL;

  891. }

  892. 	

  893. /////////////////////////////////////////////////////////////////////////

  894. 

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

  896. {

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

  898. 

  899. 	// cast away the const :P

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

  901. 	int p=find(o);

  902. 

  903. 	if (p<0) 

  904. 	{

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

  906. 		return;

  907. 	}

  908. 	

  909. 	Fl_Widget *temp=a[0];

  910. 	Fl_Widget *last=a[0];

  911. 	

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

  913. 	{

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

  915. 		{	

  916. 			// move the widgets up

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

  918. 		}

  919. 	}

  920. 	

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

  922. }

  923. 

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

  925. {

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

  927. 	

  928. 	// cast away the const :P

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

  930. 	int p=find(o);

  931. 

  932. 	if (p<0) 

  933. 	{

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

  935. 		return;

  936. 	}

  937. 	

  938. 	Fl_Widget *temp=a[0];

  939. 	Fl_Widget *last=a[0];

  940. 	

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

  942. 	{

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

  944. 		{	

  945. 			// move the widgets down

  946. 			temp=a[n];

  947. 			a[n]=last;

  948. 			last=temp;

  949. 		}

  950. 	}

  951. 	

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

  953. }

  954. 

  955. /////////////////////////////////////////////////////////////////////////

  956. 

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

  958. {

  959. 	int NumWires;

  960. 

  961. 	s>>NumWires;

  962. 		

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

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

  965. 	{

  966. 		int version;

  967. 

  968. 		if (!paste)

  969. 		{

  970. 			s>>version;

  971. 			s>>NumWires;

  972. 		}

  973. 		

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

  975. 		{

  976. 			CanvasWire NewWire;

  977. 			int dummy;

  978. 		

  979. 			s>>NewWire.OutputID;

  980. 			s>>dummy;

  981. 			s>>NewWire.OutputPort;

  982. 			s>>NewWire.OutputTerminal;

  983. 			s>>NewWire.InputID;

  984. 			s>>dummy;

  985. 			s>>NewWire.InputPort;	

  986. 			s>>NewWire.InputTerminal;

  987. 

  988. 			if (paste || merge)		

  989. 			{

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

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

  992. 

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

  994. 				{

  995. 					NewWire.InputID = inputID->second;

  996. 					NewWire.OutputID = outputID->second;

  997. 				}

  998. 			}		

  999. 			// if we can turn on both ports

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

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

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

  1003. 			{

  1004. 				m_WireVec.push_back(NewWire);	

  1005. 					// Notify connection by callback

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

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

  1008. 			}				

  1009. 		}

  1010. 	}	

  1011. 	else

  1012. 	{		

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

  1014. 		{

  1015. 			CanvasWire NewWire;

  1016. 			int dummy;

  1017. 			

  1018. 			s>>NewWire.OutputID;

  1019. 			s>>dummy;

  1020. 			s>>NewWire.OutputPort;

  1021. 			s>>NewWire.InputID;

  1022. 			s>>dummy;

  1023. 			s>>NewWire.InputPort;	

  1024. 		

  1025. 			if (paste || merge)		

  1026. 			{

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

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

  1029. 

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

  1031. 				{

  1032. 					NewWire.InputID = inputID->second;

  1033. 					NewWire.OutputID = outputID->second;

  1034. 				}

  1035. 			}		

  1036. 

  1037. 			// if we can turn on both ports

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

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

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

  1041. 			{

  1042. 				m_WireVec.push_back(NewWire);	

  1043. 

  1044. 				// Notify connection by callback

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

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

  1047. 			}					

  1048. 		}

  1049. 	}	

  1050. }

  1051. 

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

  1053. {

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

  1055. 	return s;

  1056. }

  1057. 

  1058. ////////////////////////////////////////////////////////////////////////

  1059. 

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

  1061. {

  1062. 	int version=0;

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

  1064. 	

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

  1066. 

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

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

  1069. 	{

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

  1071. 		s<<0<<" ";

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

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

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

  1075. 		s<<0<<" ";

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

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

  1078. 	}

  1079. 

  1080. 	return s;

  1081. }