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

1074 lines
29KB
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. #include <math.h>

  26. 

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

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

  29. static const int UPDATE_TICKS = 5;

  30. 

  31. static int Numbers[512];

  32. 

  33. ////////////////////////////////////////////////////////////////////////

  34. 

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

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

  37. m_Menu(NULL),

  38. m_BG(NULL),

  39. m_BGData(NULL),

  40. cb_Connection(NULL),

  41. cb_Unconnect(NULL),

  42. cb_AddDevice(NULL),

  43. m_CanPaste(false),

  44. m_Selecting(false),

  45. m_UpdateTimer(0)

  46. {

  47. 	m_IncompleteWire.OutputID=-1;

  48. 	m_IncompleteWire.OutputPort=-1;

  49. 	m_IncompleteWire.OutputTerminal=false;

  50. 	m_IncompleteWire.InputID=-1;

  51. 	m_IncompleteWire.InputPort=-1;

  52. 	m_IncompleteWire.InputTerminal=false;

  53.         for (int n=0; n<512; n++) Numbers[n]=n;

  54. }

  55. 

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

  57. 

  58. Fl_Canvas::~Fl_Canvas()

  59. {

  60. 	if (m_Menu) delete m_Menu;

  61. }

  62. 

  63. ////////////////////////////////////////////////////////////////////////

  64. 

  65. void Fl_Canvas::draw()

  66. {

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

  68. 

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

  70. 	{

  71. 		if (m_BG)

  72. 		{

  73. 			int X=0,Y=0;

  74. 			while (Y<w())

  75. 			{

  76. 				while (X<h())

  77. 				{

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

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

  80. 					X+=m_BG->w;

  81. #else

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

  83. #endif

  84. 				}

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

  86.  				Y+=m_BG->h;

  87. #else

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

  89. #endif

  90. 				X=0;

  91. 			}

  92. 		}

  93. 		else

  94. 		{

  95. 			draw_box();

  96. 		}

  97. 

  98. 		// draw minimised modules first

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

  100. 		{

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

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

  103. 			{

  104.    	 			draw_child(o);

  105.    				draw_outside_label(o);

  106. 

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

  108. 

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

  110. 				{

  111. 					fl_color(FL_YELLOW);

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

  113. 				}

  114. 			}

  115. 		}

  116. 

  117. 		DrawWires();

  118. 

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

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

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

  122. 		{

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

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

  125. 			{

  126.    	 			draw_child(o);

  127.    				draw_outside_label(o);

  128. 

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

  130. 

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

  132. 				{

  133. 					fl_color(FL_YELLOW);

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

  135. 				}

  136. 			}

  137. 		}

  138. 	}

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

  140. 	{

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

  142.   	}

  143. 	DrawSelection();

  144. }

  145. 

  146. ////////////////////////////////////////////////////////////////////////

  147. 

  148. void Fl_Canvas::Poll()

  149. {

  150. 	// bit of a workaround...

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

  152. 

  153. 	if (m_UpdateTimer>UPDATE_TICKS)

  154. 	{

  155. 		m_UpdateTimer=0;

  156. 		redraw();

  157. 	}

  158. }

  159. 

  160. ////////////////////////////////////////////////////////////////////////

  161. 

  162. void Fl_Canvas::DrawSelection()

  163. {

  164. 	if (m_Selecting)

  165. 	{

  166. 		int X, Y, W, H;

  167. 

  168. 		fl_color(FL_YELLOW);

  169. 

  170. 		X = min(m_StartSelectX, m_EndSelectX);

  171. 		Y = min(m_StartSelectY, m_EndSelectY);

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

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

  174. 

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

  176. 	}

  177. }

  178. 

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

  180. {

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

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

  183. 

  184. 	int src2_x1=X, src2_y1=Y;

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

  186. 

  187. 	int width=0, height=0;

  188. 	

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

  190. 	{

  191. 		src1_x1=X;

  192. 		src1_y1=Y;

  193. 		src1_x2=X+W;

  194. 		src1_y2=Y+H;

  195. 

  196. 		src2_x1=o->x();

  197. 		src2_y1=o->y();

  198. 		src2_x2=o->w();

  199. 		src2_y2=o->h();

  200. 	}

  201. 

  202. 	if (src2_x1 < src1_x2)

  203. 	{

  204. 		if (src1_x2 < src2_x2)

  205. 			width = src1_x2 - src2_x1;

  206. 		else

  207. 			width = src2_x2 - src2_x1;

  208. 

  209. 		if (width == 0)

  210. 			return false;

  211. 		

  212. 		if (src2_y1 < src1_y1)

  213. 		{

  214. 			int tmp;

  215. 

  216. 			tmp = src2_x1;

  217. 			src2_x1=src1_x1;

  218. 			src1_x1=tmp;

  219. 

  220. 			tmp = src2_y1;

  221. 			src2_y1=src1_y1;

  222. 			src1_y1=tmp;

  223. 

  224. 			tmp = src2_x2;

  225. 			src2_x2=src1_x2;

  226. 			src1_x2=tmp;

  227. 			

  228. 			tmp = src2_y2;

  229. 			src2_y2=src1_y2;

  230. 			src1_y2=tmp;

  231. 

  232. 		}

  233. 

  234. 		if (src2_y1 < src1_y2)

  235. 		{

  236. 			if (src1_y2 < src2_y2)

  237. 				height = src1_y2 - src2_y1;

  238. 			else

  239. 				height = src2_y2 - src2_y1;

  240. 

  241. 			if ((height == 0))

  242. 				return false;

  243. 			else

  244. 				return true;

  245. 		}

  246. 	}

  247. 

  248. 	return false;

  249. }

  250. 

  251. void Fl_Canvas::CalculateSelection()

  252. {

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

  254. 	int X, Y, W, H;

  255. 

  256. 	X = min(m_StartSelectX, m_EndSelectX);

  257. 	Y = min(m_StartSelectY, m_EndSelectY);

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

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

  260. 

  261. 	m_HaveSelection = false;

  262. 	m_Selection.Clear();

  263. 

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

  265. 	{

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

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

  268. 		{

  269. 			m_HaveSelection = true;

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

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

  272. 		}

  273. 	}

  274. }

  275. 

  276. void Fl_Canvas::DeleteSelection (void) {

  277.      if (! m_HaveSelection) return;

  278.      // show some warning here

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

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

  281.          Fl_DeviceGUI* o = FindDevice(ID);

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

  283.      }

  284.      m_HaveSelection = false;

  285.      m_Selection.Clear();

  286.      redraw();

  287. }

  288. 

  289. void Fl_Canvas::PopupEditMenu (Fl_Group *group) {

  290.      m_Menu->value(0);

  291.      group->add(m_Menu);

  292.      Fl_Menu_Item *cut=(Fl_Menu_Item*)&(m_Menu->menu()[1]);

  293.      Fl_Menu_Item *copy=(Fl_Menu_Item*)&(m_Menu->menu()[2]);

  294.      Fl_Menu_Item *paste=(Fl_Menu_Item*)&(m_Menu->menu()[3]);

  295.      Fl_Menu_Item *merge=(Fl_Menu_Item*)&(m_Menu->menu()[4]);

  296.      Fl_Menu_Item *deleteitems=(Fl_Menu_Item*)&(m_Menu->menu()[5]);

  297.      if ((cb_CopyDeviceGroup) && (m_HaveSelection)) copy->activate(); else copy->deactivate();

  298.      if ((cb_CutDeviceGroup) && (m_HaveSelection)) cut->activate(); else cut->deactivate();

  299.      if ((cb_PasteDeviceGroup) && (m_CanPaste)) paste->activate(); else paste->deactivate();

  300.      if (m_HaveSelection) deleteitems->activate(); else deleteitems->deactivate();

  301.      m_Menu->popup();

  302.      group->remove(m_Menu);

  303. }

  304. 

  305. void Fl_Canvas::AddPluginName (const string &s, int ID) {

  306.      // There's a bug here, that there's no menu at all if no plugins are found

  307.      // This isn't IMMEDIATELY important, as if you've no plugins - there's nothing to copy/paste/etc anyway.

  308.      if (! (m_Menu)) {

  309.         m_Menu = new Fl_Menu_Button (0, 0, 4, 4, NULL);

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

  311.         m_Menu->textsize (10);

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

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

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

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

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

  317.      }

  318.      m_Menu->add (s.c_str(), 0, (Fl_Callback*)cb_AddDeviceFromMenu, &Numbers[ID]);

  319. }

  320. 

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

  322. {

  323. 	MapNewDeviceIds = NewDeviceIds;

  324. 	StreamWiresIn(s, merge, paste);

  325. }

  326. 

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

  328. {

  329. 	int total_wires = 0, curpos=0;

  330. 

  331. 	curpos = s.tellp();

  332. 

  333. 	s<<-1<<endl;

  334. 

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

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

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

  338. 		{

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

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

  341. 

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

  343. 			{

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

  345. 				s<<0<<" ";

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

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

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

  349. 				s<<0<<" ";

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

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

  352. 

  353. 				total_wires += 1;

  354. 			}

  355. 		}

  356. 

  357. 	if (total_wires >= 1)

  358. 	{

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

  360. 		s<<total_wires<<endl;

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

  362. 	}

  363. }

  364. 

  365. ////////////////////////////////////////////////////////////////////////

  366. 

  367. void Fl_Canvas::DrawWires()

  368. {

  369.         fl_line_style( FL_SOLID, 2 );

  370. 

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

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

  373. 	{

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

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

  376. 

  377. 		if (!SourceDevice || !DestDevice)

  378. 		{

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

  380. 			return;

  381. 		}

  382. 

  383.          Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  390.              default:    col = (Fl_Color) WIRE_COL0;

  391.          }

  392.          fl_color(col);

  393. 

  394. #ifdef NTK_MAJOR_VERSION

  395.          fl_color( fl_color_add_alpha( fl_color(), 127 ) );

  396. #endif

  397. 

  398.                 double ep1_x, ep1_y, ep2_x, ep2_y,

  399.                     ep1_mix_x,

  400.                     ep1_new_x,

  401.                     ep1_mid_x,

  402.                     ep2_mid_x,

  403.                     ep2_new_x,

  404.                     ep1_mid_y,

  405.                     ep2_mid_y;

  406.                 

  407.                 ep1_x = SourceDevice->GetPortX(i->OutputPort+SourceDevice->GetInfo()->NumInputs);

  408.                 

  409.                 ep1_y = SourceDevice->GetPortY(i->OutputPort+SourceDevice->GetInfo()->NumInputs);

  410.                 ep1_mid_y = ep1_y + 7.5;

  411.                 

  412.                 

  413.                 ep2_x = DestDevice->GetPortX(i->InputPort);

  414.                 ep2_y = DestDevice->GetPortY(i->InputPort);

  415.                 ep2_mid_y = 7.5 + ep2_y;

  416.                 

  417.                 ep1_mid_x = fabs(ep1_x-ep2_x)/2;

  418.                 ep1_new_x = ep1_x+ep1_mid_x;

  419.                 

  420.                 ep2_mid_x = fabs(ep1_x-ep2_x)/2;

  421.                 ep2_new_x = ep2_x-ep2_mid_x;

  422.                 

  423.                 fl_begin_line();

  424.                 

  425.                 fl_curve( ep1_x, ep1_y, ep1_new_x, ep1_mid_y, ep2_new_x, ep2_mid_y, ep2_x, ep2_y );

  426.                 

  427.                 fl_end_line();

  428. 

  429. 		/* fl_line(SourceDevice->GetPortX(i->OutputPort+SourceDevice->GetInfo()->NumInputs), */

  430. 		/* 		SourceDevice->GetPortY(i->OutputPort+SourceDevice->GetInfo()->NumInputs), */

  431. 		/* 		DestDevice->GetPortX(i->InputPort), */

  432. 		/* 		DestDevice->GetPortY(i->InputPort)); */

  433. 	}

  434. 

  435. 	DrawIncompleteWire();

  436.         

  437.         fl_line_style( FL_SOLID, 0 );

  438. }

  439. 

  440. ////////////////////////////////////////////////////////////////////////

  441. 

  442. bool Fl_Canvas::UserMakingConnection()

  443. {

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

  445. }

  446. 

  447. ////////////////////////////////////////////////////////////////////////

  448. 

  449. void Fl_Canvas::DrawIncompleteWire()

  450. {

  451. 	// draw the wire we are currently connecting

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

  453. 	{

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

  455. 

  456. 		if (!Device)

  457. 		{

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

  459. 			return;

  460. 		}

  461. 

  462. 

  463.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  470.              default:    col = (Fl_Color) WIRE_COL0;

  471.          }

  472.  		fl_color(col);

  473. 

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

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

  476. 				Fl::event_x(),

  477. 				Fl::event_y());

  478. 	}

  479. 

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

  481. 	{

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

  483. 

  484. 		if (!Device)

  485. 		{

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

  487. 			return;

  488. 		}

  489. 

  490. 

  491.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  498.              default:    col = (Fl_Color) WIRE_COL0;

  499.          }

  500.  		fl_color(col);

  501. 

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

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

  504. 				Fl::event_x(),

  505. 				Fl::event_y());

  506. 	}

  507. }

  508. 

  509. ////////////////////////////////////////////////////////////////////////

  510. 

  511. void Fl_Canvas::ClearIncompleteWire()

  512. {

  513. 	// Turn off both ports

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

  515. 	{

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

  517. 	}

  518. 

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

  520. 	{

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

  522. 	}

  523. 	m_IncompleteWire.Clear();

  524. }

  525. 

  526. ////////////////////////////////////////////////////////////////////////

  527. //  Event handlers for the canvas and the deviceGUIs

  528. 

  529. int Fl_Canvas::handle (int event) {

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

  531.     if (event==FL_PUSH) {

  532.        ClearIncompleteWire();

  533.        redraw();

  534.        m_DragX=Fl::event_x();

  535.        m_DragY=Fl::event_y();

  536.     }

  537.     if ((Fl::event_button() == 1) && ((Fl::event_state() & FL_SHIFT) == 0) && ((Fl::event_state() & FL_CTRL) == 0)) {

  538.        // Left-Click  (or plain click for those who are mouse-button challenged)

  539.        // Select / Multi-select / move devices

  540.        // Handled below - If on a non-selected plugin, deselect and move

  541.        // Handled below - If on a selected plugin, move selection

  542.        // Handled Here - If on canvas - multi select

  543.        if (event==FL_PUSH) {

  544.           if (m_HaveSelection) {

  545.              m_Selection.Clear();

  546.              m_HaveSelection = false;

  547.           }

  548.           m_Selecting = true;

  549.           m_StartSelectX=Fl::event_x();

  550.           m_StartSelectY=Fl::event_y();

  551.           m_EndSelectX=Fl::event_x();

  552.           m_EndSelectY=Fl::event_y();

  553.           ClearIncompleteWire();

  554.           redraw();

  555.           m_DragX=Fl::event_x();

  556.           m_DragY=Fl::event_y();

  557.        }

  558.        if ((event==FL_DRAG) && m_Selecting) {

  559.           m_EndSelectX = Fl::event_x();

  560.           m_EndSelectY = Fl::event_y();

  561.           Fl_Scroll* scroll = (Fl_Scroll *)parent();

  562.           int newx = 0, xp = scroll->xposition();

  563.           int newy = 0, yp = scroll->yposition();

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

  565.              newx = 10;

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

  567.              newy = 10;

  568.           if ((m_EndSelectX > m_StartSelectX) && ((scroll->x() + scroll->w() - m_EndSelectX - 15) <= 15))

  569.              newx = -10;

  570.           if ((m_EndSelectY > m_StartSelectY) && ((scroll->y() + scroll->h() - m_EndSelectY - 15) <= 5))

  571.              newy = -10;

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

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

  574.              m_StartSelectX += newx;

  575.              m_StartSelectY += newy;

  576.           }

  577.           m_DragX=Fl::event_x();

  578.           m_DragY=Fl::event_y();

  579.           redraw();

  580.        }

  581.        if ((event==FL_RELEASE) && m_Selecting) {

  582.           m_Selecting = false;

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

  584.              CalculateSelection();

  585.           redraw();

  586.        }

  587.     }

  588.     if ((Fl::event_button() == 2) || ((Fl::event_button() == 1) && ((Fl::event_state() & FL_SHIFT) != 0))) {

  589.        // Middle-Click  (or shift-click for the mouse button challenged) - old left click

  590.        // Handled Below - If on items allows selecting of individual items

  591.        // Handled Here - If on canvas, drags canvas

  592.        if (event==FL_PUSH) {

  593.           ClearIncompleteWire();

  594.           redraw();

  595.           m_DragX=Fl::event_x();

  596.           m_DragY=Fl::event_y();

  597.        }

  598.        if (event==FL_DRAG) {

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

  600.           m_DragX=Fl::event_x();

  601.           m_DragY=Fl::event_y();

  602.           redraw();

  603.        }

  604.     }

  605.     if ((Fl::event_button() == 3) || ((Fl::event_button() == 1) && ((Fl::event_state() & FL_CTRL) != 0))) {

  606.        // Right-Click (or Ctrl-click for the M.B.C.)

  607.        // Pop-up Edit/Plugins menu

  608.        if (event==FL_PUSH) {

  609.           m_x=Fl::event_x();

  610.           m_y=Fl::event_y();

  611.           PopupEditMenu (this);

  612.        }

  613.     }

  614.     return 1;

  615. }

  616. 

  617. void Fl_Canvas::cb_OnDrag_s (Fl_Widget* widget, int x, int y, void* data) {

  618.      ((Fl_Canvas *)data)->cb_OnDrag_i (widget, x, y);

  619. }

  620. 

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

  622.        if ((widget) && (widget->parent())) {

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

  624.           if (m_HaveSelection) {

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

  626.                 m_HaveSelection = false;

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

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

  629.                  Fl_Widget *o = FindDevice(ID);

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

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

  632.                  }

  633.              }

  634.           }

  635.        }

  636.        return;

  637. }

  638. 

  639. void Fl_Canvas::cb_OnDragClick_s (Fl_Widget* widget, int button, int shift_state, void* data) {

  640.      ((Fl_Canvas *)data)->cb_OnDragClick_i (widget, button, shift_state);

  641. }

  642. 

  643. inline void Fl_Canvas::cb_OnDragClick_i(Fl_Widget* widget, int button,int shift_state) {

  644.        // this bit seems to be unnecessary - andy preston

  645.        // if ((button==3) && ((shift_state & FL_CTRL) != 0)) {

  646.        //   PopupEditMenu(widget->parent());

  647.        // }

  648.        if ((widget) && (button==1)) {

  649.           int ID = ((Fl_DeviceGUI*)(widget->parent()))->GetID();

  650.           std::vector<int>::iterator device_iter = std::find(m_Selection.m_DeviceIds.begin(), m_Selection.m_DeviceIds.end(), ID);

  651.           if (((shift_state & FL_SHIFT) != 0) || ((shift_state & FL_CTRL) != 0)) {

  652.              if (m_HaveSelection) {

  653.                 if (device_iter != m_Selection.m_DeviceIds.end())

  654.                    m_Selection.m_DeviceIds.erase(device_iter);

  655.                 else

  656.                    m_Selection.m_DeviceIds.push_back(ID);

  657.              }

  658.              else {

  659.                 m_Selection.Clear();

  660.                 m_HaveSelection = true;

  661.                 m_Selection.m_DeviceIds.push_back(ID);

  662.              }

  663.           }

  664.           else {

  665.              m_Selection.Clear();

  666.              m_HaveSelection = true;

  667.              m_Selection.m_DeviceIds.push_back(ID);

  668.           }

  669.           redraw();

  670.        }

  671. }

  672. 

  673. ////////////////////////////////////////////////////////////////////////

  674. 

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

  676. {

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

  678. 	{

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

  680. 		{

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

  682. 			{

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

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

  685. 				{

  686. 					m_IncompleteWire.OutputPort=Port;

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

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

  689. 				}

  690. 				else

  691. 				{

  692. 					ClearIncompleteWire();

  693. 				}

  694. 			}

  695. 			else

  696. 			{

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

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

  699. 				{

  700. 					m_IncompleteWire.InputPort=Port;

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

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

  703. 				}

  704. 				else

  705. 				{

  706. 					ClearIncompleteWire();

  707. 				}

  708. 			}

  709. 

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

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

  712. 			{

  713. 				m_WireVec.push_back(m_IncompleteWire);

  714. 

  715. 				// send the connect callback

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

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

  718. 									  m_IncompleteWire.InputID,m_IncompleteWire.InputTerminal);

  719. 

  720. 				// Turn on both ports

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

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

  723. 

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

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

  726. 

  727. 				m_IncompleteWire.Clear();

  728. 

  729. 				redraw();

  730. 			}

  731. 		}

  732. 	}

  733. 	else // Turned off the port

  734. 	{

  735. 		// Find connections using this port

  736. 		bool Found=true;

  737. 

  738. 		while (Found)

  739. 		{

  740. 			Found=false;

  741. 

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

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

  744. 			{

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

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

  747. 				{

  748. 					// Turn off both ports

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

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

  751. 

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

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

  754. 

  755. 					// send the unconnect callback

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

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

  758. 

  759. 					// Remove the wire

  760. 					m_WireVec.erase(i);

  761. 

  762. 					Found=true;

  763. 					break;

  764. 				}

  765. 			}

  766. 		}

  767. 

  768. 		redraw();

  769. 

  770. 		// Clear the current m_Selection

  771. 		m_IncompleteWire.Clear();

  772. 	}

  773. }

  774. 

  775. ////////////////////////////////////////////////////////////////////////

  776. 

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

  778. {

  779. 	bool removedall=false;

  780. 

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

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

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

  784. 	{

  785. 		ClearIncompleteWire();

  786. 	}

  787. 

  788. 	while (!removedall)

  789. 	{

  790. 		removedall=true;

  791. 

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

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

  794. 		{

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

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

  797. 			{

  798. 				// Turn off both ports

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

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

  801. 

  802. 				// send the unconnect callback

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

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

  805. 

  806. 				m_WireVec.erase(i);

  807. 				removedall=false;

  808. 				break;

  809. 			}

  810. 		}

  811. 	}

  812. }

  813. 

  814. ////////////////////////////////////////////////////////////////////////

  815. 

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

  817. {

  818. 	ClearConnections(Device);

  819. 	remove(Device);

  820. 	redraw();

  821. }

  822. 

  823. ////////////////////////////////////////////////////////////////////////

  824. 

  825. void Fl_Canvas::Clear()

  826. {

  827. 	m_Graph.Clear();

  828. 

  829. 	int kids=children();

  830. 

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

  832. 	{

  833. 		remove(child(0));

  834. 	}

  835. 

  836. 	m_WireVec.clear();

  837. 	redraw();

  838. }

  839. 

  840. 

  841. ////////////////////////////////////////////////////////////////////////

  842. 

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

  844. {

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

  846. }

  847. 

  848. ////////////////////////////////////////////////////////////////////////

  849. 

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

  851. {

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

  853. 	{

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

  855. 		{

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

  857. 		}

  858. 	}

  859. 	return NULL;

  860. }

  861. 

  862. /////////////////////////////////////////////////////////////////////////

  863. 

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

  865. {

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

  867. 

  868. 	// cast away the const :P

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

  870. 	int p=find(o);

  871. 

  872. 	if (p<0)

  873. 	{

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

  875. 		return;

  876. 	}

  877. 

  878. 	Fl_Widget *temp=a[0];

  879. 	Fl_Widget *last=a[0];

  880. 

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

  882. 	{

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

  884. 		{

  885. 			// move the widgets up

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

  887. 		}

  888. 	}

  889. 

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

  891. }

  892. 

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

  894. {

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

  896. 

  897. 	// cast away the const :P

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

  899. 	int p=find(o);

  900. 

  901. 	if (p<0)

  902. 	{

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

  904. 		return;

  905. 	}

  906. 

  907. 	Fl_Widget *temp=a[0];

  908. 	Fl_Widget *last=a[0];

  909. 

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

  911. 	{

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

  913. 		{

  914. 			// move the widgets down

  915. 			temp=a[n];

  916. 			a[n]=last;

  917. 			last=temp;

  918. 		}

  919. 	}

  920. 

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

  922. }

  923. 

  924. /////////////////////////////////////////////////////////////////////////

  925. 

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

  927. {

  928. 	int NumWires;

  929. 

  930. 	s>>NumWires;

  931. 

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

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

  934. 	{

  935. 		int version;

  936. 

  937. 		if (!paste)

  938. 		{

  939. 			s>>version;

  940. 			s>>NumWires;

  941. 		}

  942. 

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

  944. 		{

  945. 			CanvasWire NewWire;

  946. 			int dummy;

  947. 

  948. 			s>>NewWire.OutputID;

  949. 			s>>dummy;

  950. 			s>>NewWire.OutputPort;

  951. 			s>>NewWire.OutputTerminal;

  952. 			s>>NewWire.InputID;

  953. 			s>>dummy;

  954. 			s>>NewWire.InputPort;

  955. 			s>>NewWire.InputTerminal;

  956. 

  957. 			if (paste || merge)

  958. 			{

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

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

  961. 

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

  963. 				{

  964. 					NewWire.InputID = inputID->second;

  965. 					NewWire.OutputID = outputID->second;

  966. 				}

  967. 			}

  968. 			// if we can turn on both ports

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

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

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

  972. 			{

  973. 				m_WireVec.push_back(NewWire);

  974. 					// Notify connection by callback

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

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

  977. 			}

  978. 		}

  979. 	}

  980. 	else

  981. 	{

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

  983. 		{

  984. 			CanvasWire NewWire;

  985. 			int dummy;

  986. 

  987. 			s>>NewWire.OutputID;

  988. 			s>>dummy;

  989. 			s>>NewWire.OutputPort;

  990. 			s>>NewWire.InputID;

  991. 			s>>dummy;

  992. 			s>>NewWire.InputPort;

  993. 

  994. 			if (paste || merge)

  995. 			{

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

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

  998. 

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

  1000. 				{

  1001. 					NewWire.InputID = inputID->second;

  1002. 					NewWire.OutputID = outputID->second;

  1003. 				}

  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. 

  1013. 				// Notify connection by callback

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

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

  1016. 			}

  1017. 		}

  1018. 	}

  1019. }

  1020. 

  1021. 

  1022. void Fl_Canvas::cb_DeleteDeviceGroup (Fl_Widget* widget, void* data) {

  1023.      ((Fl_Canvas *)data)->cb_DeleteDeviceGroup_i();

  1024. }

  1025. 

  1026. inline void Fl_Canvas::cb_DeleteDeviceGroup_i() {

  1027.        DeleteSelection ();

  1028. }

  1029. 

  1030. void Fl_Canvas::cb_AddDeviceFromMenu (Fl_Widget* widget, void* data) {

  1031.      ((Fl_Canvas *)widget->parent())->cb_AddDeviceFromMenu_i (widget, data);

  1032. }

  1033. 

  1034. inline void Fl_Canvas::cb_AddDeviceFromMenu_i (Fl_Widget* widget, void* data) {

  1035.        if (cb_AddDevice) {

  1036.           int args[3];

  1037.           args[0]=*(int*)data;

  1038.           args[1]=m_x;

  1039.           args[2]=m_y;

  1040.           cb_AddDevice (this, args);

  1041.        }

  1042. }

  1043. 

  1044. ////////////////////////////////////////////////////////////////////////

  1045. 

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

  1047. {

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

  1049. 	return s;

  1050. }

  1051. 

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

  1053. {

  1054. 	int version=0;

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

  1056. 

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

  1058. 

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

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

  1061. 	{

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

  1063. 		s<<0<<" ";

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

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

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

  1067. 		s<<0<<" ";

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

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

  1070. 	}

  1071. 

  1072. 	return s;

  1073. }