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

1034 lines
28KB
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. static int Numbers[512];

  31. 

  32. ////////////////////////////////////////////////////////////////////////

  33. 

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

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

  36. m_Menu(NULL),

  37. m_BG(NULL),

  38. m_BGData(NULL),

  39. cb_Connection(NULL),

  40. cb_Unconnect(NULL),

  41. cb_AddDevice(NULL),

  42. m_CanPaste(false),

  43. m_Selecting(false),

  44. m_UpdateTimer(0)

  45. {

  46. 	m_IncompleteWire.OutputID=-1;

  47. 	m_IncompleteWire.OutputPort=-1;

  48. 	m_IncompleteWire.OutputTerminal=false;

  49. 	m_IncompleteWire.InputID=-1;

  50. 	m_IncompleteWire.InputPort=-1;

  51. 	m_IncompleteWire.InputTerminal=false;

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

  53. }

  54. 

  55. ////////////////////////////////////////////////////////////////////////

  56. 

  57. Fl_Canvas::~Fl_Canvas()

  58. {

  59. 	if (m_Menu) delete m_Menu;

  60. }

  61. 

  62. ////////////////////////////////////////////////////////////////////////

  63. 

  64. void Fl_Canvas::draw()

  65. {

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

  67. 

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

  69. 	{

  70. 		if (m_BG)

  71. 		{

  72. 			int X=0,Y=0;

  73. 			while (Y<w())

  74. 			{

  75. 				while (X<h())

  76. 				{

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

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

  79. 					X+=m_BG->w;

  80. #else

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

  82. #endif

  83. 				}

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

  85.  				Y+=m_BG->h;

  86. #else

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

  88. #endif

  89. 				X=0;

  90. 			}

  91. 		}

  92. 		else

  93. 		{

  94. 			draw_box();

  95. 		}

  96. 

  97. 		// draw minimised modules first

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

  99. 		{

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

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

  102. 			{

  103.    	 			draw_child(o);

  104.    				draw_outside_label(o);

  105. 

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

  107. 

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

  109. 				{

  110. 					fl_color(FL_YELLOW);

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

  112. 				}

  113. 			}

  114. 		}

  115. 

  116. 		DrawWires();

  117. 

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

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

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

  121. 		{

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

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

  124. 			{

  125.    	 			draw_child(o);

  126.    				draw_outside_label(o);

  127. 

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

  129. 

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

  131. 				{

  132. 					fl_color(FL_YELLOW);

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

  134. 				}

  135. 			}

  136. 		}

  137. 	}

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

  139. 	{

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

  141.   	}

  142. 	DrawSelection();

  143. }

  144. 

  145. ////////////////////////////////////////////////////////////////////////

  146. 

  147. void Fl_Canvas::Poll()

  148. {

  149. 	// bit of a workaround...

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

  151. 

  152. 	if (m_UpdateTimer>UPDATE_TICKS)

  153. 	{

  154. 		m_UpdateTimer=0;

  155. 		redraw();

  156. 	}

  157. }

  158. 

  159. ////////////////////////////////////////////////////////////////////////

  160. 

  161. void Fl_Canvas::DrawSelection()

  162. {

  163. 	if (m_Selecting)

  164. 	{

  165. 		int X, Y, W, H;

  166. 

  167. 		fl_color(FL_YELLOW);

  168. 

  169. 		X = min(m_StartSelectX, m_EndSelectX);

  170. 		Y = min(m_StartSelectY, m_EndSelectY);

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

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

  173. 

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

  175. 	}

  176. }

  177. 

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

  179. {

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

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

  182. 

  183. 	int src2_x1=X, src2_y1=Y;

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

  185. 

  186. 	int width=0, height=0;

  187. 	

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

  189. 	{

  190. 		src1_x1=X;

  191. 		src1_y1=Y;

  192. 		src1_x2=X+W;

  193. 		src1_y2=Y+H;

  194. 

  195. 		src2_x1=o->x();

  196. 		src2_y1=o->y();

  197. 		src2_x2=o->w();

  198. 		src2_y2=o->h();

  199. 	}

  200. 

  201. 	if (src2_x1 < src1_x2)

  202. 	{

  203. 		if (src1_x2 < src2_x2)

  204. 			width = src1_x2 - src2_x1;

  205. 		else

  206. 			width = src2_x2 - src2_x1;

  207. 

  208. 		if (width == 0)

  209. 			return false;

  210. 		

  211. 		if (src2_y1 < src1_y1)

  212. 		{

  213. 			int tmp;

  214. 

  215. 			tmp = src2_x1;

  216. 			src2_x1=src1_x1;

  217. 			src1_x1=tmp;

  218. 

  219. 			tmp = src2_y1;

  220. 			src2_y1=src1_y1;

  221. 			src1_y1=tmp;

  222. 

  223. 			tmp = src2_x2;

  224. 			src2_x2=src1_x2;

  225. 			src1_x2=tmp;

  226. 			

  227. 			tmp = src2_y2;

  228. 			src2_y2=src1_y2;

  229. 			src1_y2=tmp;

  230. 

  231. 		}

  232. 

  233. 		if (src2_y1 < src1_y2)

  234. 		{

  235. 			if (src1_y2 < src2_y2)

  236. 				height = src1_y2 - src2_y1;

  237. 			else

  238. 				height = src2_y2 - src2_y1;

  239. 

  240. 			if ((height == 0))

  241. 				return false;

  242. 			else

  243. 				return true;

  244. 		}

  245. 	}

  246. 

  247. 	return false;

  248. }

  249. 

  250. void Fl_Canvas::CalculateSelection()

  251. {

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

  253. 	int X, Y, W, H;

  254. 

  255. 	X = min(m_StartSelectX, m_EndSelectX);

  256. 	Y = min(m_StartSelectY, m_EndSelectY);

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

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

  259. 

  260. 	m_HaveSelection = false;

  261. 	m_Selection.Clear();

  262. 

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

  264. 	{

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

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

  267. 		{

  268. 			m_HaveSelection = true;

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

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

  271. 		}

  272. 	}

  273. }

  274. 

  275. void Fl_Canvas::DeleteSelection (void) {

  276.      if (! m_HaveSelection) return;

  277.      // show some warning here

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

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

  280.          Fl_DeviceGUI* o = FindDevice(ID);

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

  282.      }

  283.      m_HaveSelection = false;

  284.      m_Selection.Clear();

  285.      redraw();

  286. }

  287. 

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

  289.      m_Menu->value(0);

  290.      group->add(m_Menu);

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

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

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

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

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

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

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

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

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

  300.      m_Menu->popup();

  301.      group->remove(m_Menu);

  302. }

  303. 

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

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

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

  307.      if (! (m_Menu)) {

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

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

  310.         m_Menu->textsize (10);

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

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

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

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

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

  316.      }

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

  318. }

  319. 

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

  321. {

  322. 	MapNewDeviceIds = NewDeviceIds;

  323. 	StreamWiresIn(s, merge, paste);

  324. }

  325. 

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

  327. {

  328. 	int total_wires = 0, curpos=0;

  329. 

  330. 	curpos = s.tellp();

  331. 

  332. 	s<<-1<<endl;

  333. 

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

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

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

  337. 		{

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

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

  340. 

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

  342. 			{

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

  344. 				s<<0<<" ";

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

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

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

  348. 				s<<0<<" ";

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

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

  351. 

  352. 				total_wires += 1;

  353. 			}

  354. 		}

  355. 

  356. 	if (total_wires >= 1)

  357. 	{

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

  359. 		s<<total_wires<<endl;

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

  361. 	}

  362. }

  363. 

  364. ////////////////////////////////////////////////////////////////////////

  365. 

  366. void Fl_Canvas::DrawWires()

  367. {

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

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

  370. 	{

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

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

  373. 

  374. 		if (!SourceDevice || !DestDevice)

  375. 		{

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

  377. 			return;

  378. 		}

  379. 

  380.          Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  387.              default:    col = (Fl_Color) WIRE_COL0;

  388.          }

  389.  		fl_color(col);

  390. 

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

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

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

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

  395. 	}

  396. 

  397. 	DrawIncompleteWire();

  398. }

  399. 

  400. ////////////////////////////////////////////////////////////////////////

  401. 

  402. bool Fl_Canvas::UserMakingConnection()

  403. {

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

  405. }

  406. 

  407. ////////////////////////////////////////////////////////////////////////

  408. 

  409. void Fl_Canvas::DrawIncompleteWire()

  410. {

  411. 	// draw the wire we are currently connecting

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

  413. 	{

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

  415. 

  416. 		if (!Device)

  417. 		{

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

  419. 			return;

  420. 		}

  421. 

  422. 

  423.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  430.              default:    col = (Fl_Color) WIRE_COL0;

  431.          }

  432.  		fl_color(col);

  433. 

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

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

  436. 				Fl::event_x(),

  437. 				Fl::event_y());

  438. 	}

  439. 

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

  441. 	{

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

  443. 

  444. 		if (!Device)

  445. 		{

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

  447. 			return;

  448. 		}

  449. 

  450. 

  451.         Fl_Color col = (Fl_Color) WIRE_COL0;

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

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

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

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

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

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

  458.              default:    col = (Fl_Color) WIRE_COL0;

  459.          }

  460.  		fl_color(col);

  461. 

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

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

  464. 				Fl::event_x(),

  465. 				Fl::event_y());

  466. 	}

  467. }

  468. 

  469. ////////////////////////////////////////////////////////////////////////

  470. 

  471. void Fl_Canvas::ClearIncompleteWire()

  472. {

  473. 	// Turn off both ports

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

  475. 	{

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

  477. 	}

  478. 

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

  480. 	{

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

  482. 	}

  483. 	m_IncompleteWire.Clear();

  484. }

  485. 

  486. ////////////////////////////////////////////////////////////////////////

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

  488. 

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

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

  491.     if (event==FL_PUSH) {

  492.        ClearIncompleteWire();

  493.        redraw();

  494.        m_DragX=Fl::event_x();

  495.        m_DragY=Fl::event_y();

  496.     }

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

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

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

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

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

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

  503.        if (event==FL_PUSH) {

  504.           if (m_HaveSelection) {

  505.              m_Selection.Clear();

  506.              m_HaveSelection = false;

  507.           }

  508.           m_Selecting = true;

  509.           m_StartSelectX=Fl::event_x();

  510.           m_StartSelectY=Fl::event_y();

  511.           m_EndSelectX=Fl::event_x();

  512.           m_EndSelectY=Fl::event_y();

  513.           ClearIncompleteWire();

  514.           redraw();

  515.           m_DragX=Fl::event_x();

  516.           m_DragY=Fl::event_y();

  517.        }

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

  519.           m_EndSelectX = Fl::event_x();

  520.           m_EndSelectY = Fl::event_y();

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

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

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

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

  525.              newx = 10;

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

  527.              newy = 10;

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

  529.              newx = -10;

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

  531.              newy = -10;

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

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

  534.              m_StartSelectX += newx;

  535.              m_StartSelectY += newy;

  536.           }

  537.           m_DragX=Fl::event_x();

  538.           m_DragY=Fl::event_y();

  539.           redraw();

  540.        }

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

  542.           m_Selecting = false;

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

  544.              CalculateSelection();

  545.           redraw();

  546.        }

  547.     }

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

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

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

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

  552.        if (event==FL_PUSH) {

  553.           ClearIncompleteWire();

  554.           redraw();

  555.           m_DragX=Fl::event_x();

  556.           m_DragY=Fl::event_y();

  557.        }

  558.        if (event==FL_DRAG) {

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

  560.           m_DragX=Fl::event_x();

  561.           m_DragY=Fl::event_y();

  562.           redraw();

  563.        }

  564.     }

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

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

  567.        // Pop-up Edit/Plugins menu

  568.        if (event==FL_PUSH) {

  569.           m_x=Fl::event_x();

  570.           m_y=Fl::event_y();

  571.           PopupEditMenu (this);

  572.        }

  573.     }

  574.     return 1;

  575. }

  576. 

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

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

  579. }

  580. 

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

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

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

  584.           if (m_HaveSelection) {

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

  586.                 m_HaveSelection = false;

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

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

  589.                  Fl_Widget *o = FindDevice(ID);

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

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

  592.                  }

  593.              }

  594.           }

  595.        }

  596.        return;

  597. }

  598. 

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

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

  601. }

  602. 

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

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

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

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

  607.        // }

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

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

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

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

  612.              if (m_HaveSelection) {

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

  614.                    m_Selection.m_DeviceIds.erase(device_iter);

  615.                 else

  616.                    m_Selection.m_DeviceIds.push_back(ID);

  617.              }

  618.              else {

  619.                 m_Selection.Clear();

  620.                 m_HaveSelection = true;

  621.                 m_Selection.m_DeviceIds.push_back(ID);

  622.              }

  623.           }

  624.           else {

  625.              m_Selection.Clear();

  626.              m_HaveSelection = true;

  627.              m_Selection.m_DeviceIds.push_back(ID);

  628.           }

  629.           redraw();

  630.        }

  631. }

  632. 

  633. ////////////////////////////////////////////////////////////////////////

  634. 

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

  636. {

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

  638. 	{

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

  640. 		{

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

  642. 			{

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

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

  645. 				{

  646. 					m_IncompleteWire.OutputPort=Port;

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

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

  649. 				}

  650. 				else

  651. 				{

  652. 					ClearIncompleteWire();

  653. 				}

  654. 			}

  655. 			else

  656. 			{

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

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

  659. 				{

  660. 					m_IncompleteWire.InputPort=Port;

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

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

  663. 				}

  664. 				else

  665. 				{

  666. 					ClearIncompleteWire();

  667. 				}

  668. 			}

  669. 

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

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

  672. 			{

  673. 				m_WireVec.push_back(m_IncompleteWire);

  674. 

  675. 				// send the connect callback

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

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

  678. 									  m_IncompleteWire.InputID,m_IncompleteWire.InputTerminal);

  679. 

  680. 				// Turn on both ports

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

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

  683. 

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

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

  686. 

  687. 				m_IncompleteWire.Clear();

  688. 

  689. 				redraw();

  690. 			}

  691. 		}

  692. 	}

  693. 	else // Turned off the port

  694. 	{

  695. 		// Find connections using this port

  696. 		bool Found=true;

  697. 

  698. 		while (Found)

  699. 		{

  700. 			Found=false;

  701. 

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

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

  704. 			{

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

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

  707. 				{

  708. 					// Turn off both ports

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

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

  711. 

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

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

  714. 

  715. 					// send the unconnect callback

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

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

  718. 

  719. 					// Remove the wire

  720. 					m_WireVec.erase(i);

  721. 

  722. 					Found=true;

  723. 					break;

  724. 				}

  725. 			}

  726. 		}

  727. 

  728. 		redraw();

  729. 

  730. 		// Clear the current m_Selection

  731. 		m_IncompleteWire.Clear();

  732. 	}

  733. }

  734. 

  735. ////////////////////////////////////////////////////////////////////////

  736. 

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

  738. {

  739. 	bool removedall=false;

  740. 

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

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

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

  744. 	{

  745. 		ClearIncompleteWire();

  746. 	}

  747. 

  748. 	while (!removedall)

  749. 	{

  750. 		removedall=true;

  751. 

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

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

  754. 		{

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

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

  757. 			{

  758. 				// Turn off both ports

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

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

  761. 

  762. 				// send the unconnect callback

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

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

  765. 

  766. 				m_WireVec.erase(i);

  767. 				removedall=false;

  768. 				break;

  769. 			}

  770. 		}

  771. 	}

  772. }

  773. 

  774. ////////////////////////////////////////////////////////////////////////

  775. 

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

  777. {

  778. 	ClearConnections(Device);

  779. 	remove(Device);

  780. 	redraw();

  781. }

  782. 

  783. ////////////////////////////////////////////////////////////////////////

  784. 

  785. void Fl_Canvas::Clear()

  786. {

  787. 	m_Graph.Clear();

  788. 

  789. 	int kids=children();

  790. 

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

  792. 	{

  793. 		remove(child(0));

  794. 	}

  795. 

  796. 	m_WireVec.clear();

  797. 	redraw();

  798. }

  799. 

  800. 

  801. ////////////////////////////////////////////////////////////////////////

  802. 

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

  804. {

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

  806. }

  807. 

  808. ////////////////////////////////////////////////////////////////////////

  809. 

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

  811. {

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

  813. 	{

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

  815. 		{

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

  817. 		}

  818. 	}

  819. 	return NULL;

  820. }

  821. 

  822. /////////////////////////////////////////////////////////////////////////

  823. 

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

  825. {

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

  827. 

  828. 	// cast away the const :P

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

  830. 	int p=find(o);

  831. 

  832. 	if (p<0)

  833. 	{

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

  835. 		return;

  836. 	}

  837. 

  838. 	Fl_Widget *temp=a[0];

  839. 	Fl_Widget *last=a[0];

  840. 

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

  842. 	{

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

  844. 		{

  845. 			// move the widgets up

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

  847. 		}

  848. 	}

  849. 

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

  851. }

  852. 

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

  854. {

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

  856. 

  857. 	// cast away the const :P

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

  859. 	int p=find(o);

  860. 

  861. 	if (p<0)

  862. 	{

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

  864. 		return;

  865. 	}

  866. 

  867. 	Fl_Widget *temp=a[0];

  868. 	Fl_Widget *last=a[0];

  869. 

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

  871. 	{

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

  873. 		{

  874. 			// move the widgets down

  875. 			temp=a[n];

  876. 			a[n]=last;

  877. 			last=temp;

  878. 		}

  879. 	}

  880. 

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

  882. }

  883. 

  884. /////////////////////////////////////////////////////////////////////////

  885. 

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

  887. {

  888. 	int NumWires;

  889. 

  890. 	s>>NumWires;

  891. 

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

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

  894. 	{

  895. 		int version;

  896. 

  897. 		if (!paste)

  898. 		{

  899. 			s>>version;

  900. 			s>>NumWires;

  901. 		}

  902. 

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

  904. 		{

  905. 			CanvasWire NewWire;

  906. 			int dummy;

  907. 

  908. 			s>>NewWire.OutputID;

  909. 			s>>dummy;

  910. 			s>>NewWire.OutputPort;

  911. 			s>>NewWire.OutputTerminal;

  912. 			s>>NewWire.InputID;

  913. 			s>>dummy;

  914. 			s>>NewWire.InputPort;

  915. 			s>>NewWire.InputTerminal;

  916. 

  917. 			if (paste || merge)

  918. 			{

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

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

  921. 

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

  923. 				{

  924. 					NewWire.InputID = inputID->second;

  925. 					NewWire.OutputID = outputID->second;

  926. 				}

  927. 			}

  928. 			// if we can turn on both ports

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

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

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

  932. 			{

  933. 				m_WireVec.push_back(NewWire);

  934. 					// Notify connection by callback

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

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

  937. 			}

  938. 		}

  939. 	}

  940. 	else

  941. 	{

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

  943. 		{

  944. 			CanvasWire NewWire;

  945. 			int dummy;

  946. 

  947. 			s>>NewWire.OutputID;

  948. 			s>>dummy;

  949. 			s>>NewWire.OutputPort;

  950. 			s>>NewWire.InputID;

  951. 			s>>dummy;

  952. 			s>>NewWire.InputPort;

  953. 

  954. 			if (paste || merge)

  955. 			{

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

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

  958. 

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

  960. 				{

  961. 					NewWire.InputID = inputID->second;

  962. 					NewWire.OutputID = outputID->second;

  963. 				}

  964. 			}

  965. 

  966. 			// if we can turn on both ports

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

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

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

  970. 			{

  971. 				m_WireVec.push_back(NewWire);

  972. 

  973. 				// Notify connection by callback

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

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

  976. 			}

  977. 		}

  978. 	}

  979. }

  980. 

  981. 

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

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

  984. }

  985. 

  986. inline void Fl_Canvas::cb_DeleteDeviceGroup_i() {

  987.        DeleteSelection ();

  988. }

  989. 

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

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

  992. }

  993. 

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

  995.        if (cb_AddDevice) {

  996.           int args[3];

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

  998.           args[1]=m_x;

  999.           args[2]=m_y;

  1000.           cb_AddDevice (this, args);

  1001.        }

  1002. }

  1003. 

  1004. ////////////////////////////////////////////////////////////////////////

  1005. 

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

  1007. {

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

  1009. 	return s;

  1010. }

  1011. 

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

  1013. {

  1014. 	int version=0;

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

  1016. 

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

  1018. 

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

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

  1021. 	{

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

  1023. 		s<<0<<" ";

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

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

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

  1027. 		s<<0<<" ";

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

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

  1030. 	}

  1031. 

  1032. 	return s;

  1033. }