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

1154 lines
31KB
Raw Blame History 

  1. /*  SpiralSynthModular

  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 <string>

  20. #include <iostream>

  21. #include <fstream>

  22. #include <sstream>

  23. #include <FL/Fl.H>

  24. #include <FL/Enumerations.H>

  25. #include <FL/fl_file_chooser.h>

  26. #include <FL/Fl_Box.h>

  27. #include <FL/Fl_Tooltip.h>

  28. 

  29. #include "SpiralSynthModular.h"

  30. #include "SpiralSound/PluginManager.h"

  31. #include "SpiralSound/Plugins/SpiralPluginGUI.h"

  32. 

  33. #include "GUI/SSM.xpm"

  34. #include "GUI/load.xpm"

  35. #include "GUI/save.xpm"

  36. #include "GUI/new.xpm"

  37. #include "GUI/options.xpm"

  38. #include "GUI/edit.xpm"

  39. #include "GUI/comment.xpm"

  40. #include "GUI/Widgets/PawfalYesNo.h"

  41. 

  42. //#define DEBUG_PLUGINS

  43. //#define DEBUG_STREAM

  44. 

  45. const static string LABEL = "SpiralSynthModular "+VER_STRING;

  46. static string TITLEBAR;

  47. 

  48. static const int FILE_VERSION = 3;

  49. static int Numbers[512];

  50. 

  51. static const int MAIN_WIDTH     = 700;

  52. static const int MAIN_HEIGHT    = 300;

  53. static const int SLIDER_WIDTH   = 15;

  54. static const int TOOLBOX_HEIGHT = MAIN_HEIGHT-40;

  55. static const int TOOLBOX_WIDTH  = 132+SLIDER_WIDTH;

  56. static const int ICON_DEPTH     = 3;

  57. static const int COMMENT_ID     = -1;

  58. 

  59. using namespace std;

  60. 

  61. map<int,DeviceWin*> SynthModular::m_DeviceWinMap;

  62. bool SynthModular::m_CallbackUpdateMode = false;

  63. bool SynthModular::m_BlockingOutputPluginIsReady = false;

  64. 

  65. //////////////////////////////////////////////////////////

  66. 

  67. DeviceWin::~DeviceWin()

  68. {	

  69. } 

  70. 

  71. //////////////////////////////////////////////////////////

  72. 		

  73. SynthModular::SynthModular():

  74. m_NextID(0),

  75. m_NextPluginButton(1),

  76. m_NextPluginButtonXPos(5),

  77. m_NextPluginButtonYPos(20),

  78. m_PauseAudio(false)

  79. { 	

  80. 	m_Info.BUFSIZE    = SpiralInfo::BUFSIZE;

  81. 	m_Info.FRAGSIZE   = SpiralInfo::FRAGSIZE;

  82. 	m_Info.FRAGCOUNT  = SpiralInfo::FRAGCOUNT;	

  83. 	m_Info.SAMPLERATE = SpiralInfo::SAMPLERATE;

  84. 	m_Info.OUTPUTFILE = SpiralInfo::OUTPUTFILE;

  85. 	m_Info.MIDIFILE   = SpiralInfo::MIDIFILE; 

  86. 	m_Info.POLY       = SpiralInfo::POLY;

  87. 	//m_Info.GUI_COLOUR = SpiralInfo::GUI_COLOUR;

  88. 	

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

  90. 	

  91. 	m_CH.Register("PauseAudio",&m_PauseAudio);

  92. }

  93. 

  94. //////////////////////////////////////////////////////////

  95. 

  96. SynthModular::~SynthModular()

  97. { 

  98. 	ClearUp();

  99. 	PluginManager::Get()->PackUpAndGoHome();

  100. }

  101. 

  102. //////////////////////////////////////////////////////////

  103. 

  104. void SynthModular::ClearUp()

  105. {

  106. 	PauseAudio();

  107. 	

  108. 	for(map<int,DeviceWin*>::iterator i=m_DeviceWinMap.begin();

  109. 		i!=m_DeviceWinMap.end(); i++)

  110. 	{

  111. 		if (i->second->m_DeviceGUI->GetPluginWindow())

  112. 		{

  113. 			i->second->m_DeviceGUI->GetPluginWindow()->hide();

  114. 			m_MainWindow->remove(i->second->m_DeviceGUI->GetPluginWindow());			

  115. 		}

  116. 		// deleted by Canvas::Remove()? seems to cause random crashes

  117. 		//delete i->second->m_DeviceGUI;

  118. 		delete i->second->m_Device;

  119. 	}

  120. 	

  121. 	m_Canvas->Clear();

  122. 	m_DeviceWinMap.clear();

  123. 	m_NextID=0;

  124. 	

  125. 	ResumeAudio();

  126. }

  127. 

  128. //////////////////////////////////////////////////////////

  129. 

  130. void SynthModular::Update()

  131. {	

  132. 	m_CH.UpdateDataNow();

  133. 		

  134. 	if (m_PauseAudio) return;

  135. 		

  136. 	// for all the plugins

  137. 	for(map<int,DeviceWin*>::iterator i=m_DeviceWinMap.begin();

  138. 		i!=m_DeviceWinMap.end(); i++)

  139. 	{

  140. 		if (i->second->m_Device) // if it's not a comment

  141. 		{

  142. 			#ifdef DEBUG_PLUGINS

  143. 			cerr<<"Updating channelhandler of plugin "<<i->second->m_PluginID<<endl;

  144. 			#endif

  145. 			

  146. 			// updates the data from the gui thread, if it's not blocking

  147.  			i->second->m_Device->UpdateChannelHandler();

  148. 			

  149. 			#ifdef DEBUG_PLUGINS			

  150. 			cerr<<"Finished updating"<<endl;

  151. 			#endif

  152. 	    	

  153. 			// run any commands we've received from the GUI's

  154. 			i->second->m_Device->ExecuteCommands();

  155. 		}

  156. 	}

  157. 	

  158. 	// run the plugins (only ones connected to anything)

  159. 	list<int> ExecutionOrder = m_Canvas->GetGraph()->GetSortedList();

  160. 	for (list<int>::reverse_iterator i=ExecutionOrder.rbegin(); 

  161. 		 i!=ExecutionOrder.rend(); i++)

  162. 	{

  163. 		// use the graphsort order to remove internal latency

  164. 		map<int,DeviceWin*>::iterator di=m_DeviceWinMap.find(*i);

  165. 		if (di!=m_DeviceWinMap.end() && di->second->m_Device) 

  166. 		{		

  167. 			#ifdef DEBUG_PLUGINS

  168. 			cerr<<"Executing plugin "<<di->second->m_PluginID<<endl;

  169. 			#endif

  170. 			

  171. 			di->second->m_Device->Execute();

  172. 			

  173. 			#ifdef DEBUG_PLUGINS			

  174. 			cerr<<"Finished executing"<<endl;

  175. 			#endif

  176. 		}

  177. 	}

  178. }

  179. 

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

  181. 

  182. void SynthModular::UpdatePluginGUIs()

  183. {

  184. 	// see if any need deleting		

  185. 	for (map<int,DeviceWin*>::iterator i=m_DeviceWinMap.begin(); 

  186. 		 i!=m_DeviceWinMap.end(); i++)

  187. 	{	

  188. 		if (i->second->m_DeviceGUI->GetPluginWindow())

  189. 		{

  190. 			SpiralPluginGUI *GUI=(SpiralPluginGUI *)i->second->m_DeviceGUI->GetPluginWindow();

  191. 			GUI->Update();

  192. 		}

  193. 		

  194. 		if (i->second->m_DeviceGUI->Killed())

  195. 		{

  196. 			PauseAudio();

  197. 			if (i->second->m_Device) 

  198. 			{

  199. 				delete i->second->m_Device;

  200. 			}

  201. 			

  202. 			if (i->second->m_DeviceGUI->GetPluginWindow())

  203. 			{

  204. 				i->second->m_DeviceGUI->GetPluginWindow()->hide();

  205. 				m_MainWindow->remove(i->second->m_DeviceGUI->GetPluginWindow());

  206. 			}

  207. 			

  208. 			i->second->m_DeviceGUI->Clear();

  209. 			m_Canvas->RemoveDevice(i->second->m_DeviceGUI);			

  210. 			// deleted by Canvas::Remove()? seems to cause random crashes 

  211. 			//delete i->second->m_DeviceGUI;			

  212. 			

  213. 			m_DeviceWinMap.erase(i);

  214. 			ResumeAudio();

  215. 			break;

  216. 		}

  217. 	}

  218. 	

  219. 	m_Canvas->Poll();

  220. }

  221. 

  222. //////////////////////////////////////////////////////////

  223. 

  224. SpiralWindowType *SynthModular::CreateWindow()

  225. {

  226. 	int xoff=0, yoff=10, but=64, gap=MAIN_HEIGHT/4, n=0;

  227. 	

  228. 	m_TopWindow = new SpiralWindowType(MAIN_WIDTH, MAIN_HEIGHT*2, LABEL.c_str());

  229. 	m_TopWindow->resizable(m_TopWindow);

  230. 	

  231. 	m_TopTile = new Fl_Tile(0,0,MAIN_WIDTH, MAIN_HEIGHT*2, "");

  232. 	m_TopWindow->add(m_TopTile);

  233. 

  234. 	m_MainWindow = new Fl_Tile(0,0,MAIN_WIDTH, MAIN_HEIGHT, "");

  235. 	m_MainWindow->color(SpiralSynthModularInfo::GUICOL_Canvas);

  236.  	//m_MainWindow->callback((Fl_Callback*)cb_Close);

  237. 	m_MainWindow->user_data((void*)(this));

  238. 	m_TopTile->add(m_MainWindow);

  239. 	

  240. 	m_MainButtons = new Fl_Group(0, 0, but, MAIN_HEIGHT, "");

  241.     m_MainButtons->type(1);

  242. 	m_MainButtons->color(SpiralSynthModularInfo::GUICOL_Tool);

  243. 	m_MainButtons->box(FL_FLAT_BOX);

  244. 	m_MainButtons->user_data((void*)(this));

  245. 	m_MainWindow->add(m_MainButtons); 

  246. 

  247. 	m_AppScroll = new Fl_Scroll(but, 0, MAIN_WIDTH-but, MAIN_HEIGHT, "");	

  248. 	m_AppScroll->scrollbar.align(FL_ALIGN_RIGHT);

  249. 	m_MainWindow->add(m_AppScroll);

  250. 	//m_MainWindow->resizable(m_AppScroll);

  251. 

  252. 	m_AppGroup = new Fl_Group(-5000, -5000, 10000, 10000, "");

  253.     m_AppGroup->type(1);

  254. 	m_AppGroup->box(FL_FLAT_BOX);

  255.     m_AppGroup->labeltype(FL_ENGRAVED_LABEL);

  256.     m_AppGroup->align(FL_ALIGN_TOP_LEFT|FL_ALIGN_INSIDE);

  257. 	m_AppGroup->color(SpiralSynthModularInfo::GUICOL_Canvas);

  258. 	m_AppScroll->add(m_AppGroup);   	

  259. 

  260. 	m_Load = new Fl_Button(xoff, 5+yoff, but, but, "");

  261. 	m_Load->box(FL_NO_BOX);

  262. 	Fl_Pixmap *tPix = new Fl_Pixmap(load_xpm);

  263. 	m_Load->image(tPix->copy(tPix->w(),tPix->h()));		

  264. 	m_Load->selection_color(SpiralSynthModularInfo::GUICOL_Tool);

  265.     m_Load->tooltip("Load a patch file");		 

  266. 	m_Load->callback((Fl_Callback*)cb_Load);

  267. 	m_MainButtons->add(m_Load);

  268. 	n++;

  269. 	

  270. 	m_Save = new Fl_Button(xoff, n*gap+yoff, but, but, "");

  271. 	m_Save->box(FL_NO_BOX);

  272. 	tPix = new Fl_Pixmap(save_xpm);

  273. 	m_Save->image(tPix->copy(tPix->w(),tPix->h()));	

  274. 	delete tPix;	

  275. 	m_Save->selection_color(SpiralSynthModularInfo::GUICOL_Tool);

  276.  	m_Save->tooltip("Save a patch file");		 

  277. 	m_Save->callback((Fl_Callback*)cb_Save);

  278. 	m_MainButtons->add(m_Save);

  279. 	n++;

  280. 		

  281. 	m_New = new Fl_Button(xoff, n*gap+yoff, but, but, "");

  282. 	m_New->box(FL_NO_BOX);

  283. 	tPix = new Fl_Pixmap(new_xpm);

  284. 	m_New->image(tPix->copy(tPix->w(),tPix->h()));	

  285. 	delete tPix;	

  286. 	m_New->selection_color(SpiralSynthModularInfo::GUICOL_Tool);

  287.   	m_New->tooltip("New patch");		 

  288. 	m_New->callback((Fl_Callback*)cb_New);

  289. 	m_MainButtons->add(m_New);

  290. 	n++;

  291. 				

  292. 	m_Options = new Fl_Button(xoff, n*gap+yoff, but, but, "");

  293. 	m_Options->box(FL_NO_BOX);

  294. 	tPix = new Fl_Pixmap(options_xpm);

  295. 	m_Options->image(tPix->copy(tPix->w(),tPix->h()));

  296. 	delete tPix;		

  297. 	m_Options->selection_color(SpiralSynthModularInfo::GUICOL_Tool);

  298.  	m_Options->tooltip("Options");			 

  299. 	m_Options->callback((Fl_Callback*)cb_Rload);

  300. 	m_MainButtons->add(m_Options);

  301. 	n++;

  302. 	

  303. 	/*m_OpenEditor = new Fl_Button(5+xoff, n*gap+yoff, but, but, "");

  304. 	m_OpenEditor->box(FL_NO_BOX);

  305. 	tPix = new Fl_Pixmap(edit_xpm);

  306. 	m_OpenEditor->image(tPix->copy(tPix->w(),tPix->h()));	

  307. 	delete tPix;	

  308. 	m_OpenEditor->selection_color(SpiralSynthModularInfo::GUICOL_Tool);	

  309. 	m_OpenEditor->tooltip("Open/Close Editor");		 

  310. 	m_OpenEditor->callback((Fl_Callback*)cb_OpenEditor);

  311. 	m_MainButtons->add(m_OpenEditor);

  312. 	n++;*/

  313. 			

  314. 	/////////////////

  315. 

  316. 	m_EditorWindow = new Fl_Tile(0,MAIN_HEIGHT,MAIN_WIDTH, MAIN_HEIGHT, "");

  317. 	m_EditorWindow->color(SpiralSynthModularInfo::GUICOL_Tool);

  318. 	m_TopTile->add(m_EditorWindow);

  319. 	

  320. 	int edy = MAIN_HEIGHT;

  321. 	Fl_Group *Left = new Fl_Group(0,MAIN_HEIGHT,TOOLBOX_WIDTH,MAIN_HEIGHT);

  322. 	m_EditorWindow->add(Left); 

  323. 	m_EditorWindow->resizable(Left);

  324. 	

  325. 	m_ToolBox = new Fl_Scroll(0,0+edy,TOOLBOX_WIDTH, TOOLBOX_HEIGHT, "");

  326.     m_ToolBox->type(Fl_Scroll::VERTICAL_ALWAYS);

  327. 	m_ToolBox->box(FL_FLAT_BOX);

  328.     m_ToolBox->labeltype(FL_ENGRAVED_LABEL);

  329.     m_ToolBox->align(FL_ALIGN_TOP_LEFT|FL_ALIGN_INSIDE);

  330. 	m_ToolBox->scrollbar.align(FL_ALIGN_LEFT);

  331. 	m_ToolBox->color(SpiralSynthModularInfo::GUICOL_Tool);

  332. 	m_ToolBox->user_data((void*)(this));

  333. 	Left->add(m_ToolBox);  

  334. //	m_EditorWindow->resizable(m_ToolBox);

  335. 		

  336. 	m_ToolPack = new Fl_Pack(SLIDER_WIDTH+5,5+edy,TOOLBOX_WIDTH-10, TOOLBOX_HEIGHT-40,"");

  337.     m_ToolPack->type(FL_VERTICAL);

  338. 	m_ToolPack->box(FL_NO_BOX);

  339. 	m_ToolPack->color(SpiralSynthModularInfo::GUICOL_Tool);

  340.     m_ToolPack->user_data((void*)(this));

  341. 	m_ToolBox->add(m_ToolPack);  

  342. 	//m_EditorWindow->resizable(m_ToolBox); 

  343. 	

  344. 	xoff=0; yoff=MAIN_HEIGHT+TOOLBOX_HEIGHT;

  345. 	m_Buttons = new Fl_Group(xoff, yoff, TOOLBOX_WIDTH, MAIN_HEIGHT*2-TOOLBOX_HEIGHT, "");

  346.     m_Buttons->type(1);

  347. 	m_Buttons->color(SpiralSynthModularInfo::GUICOL_Tool);

  348. 	m_Buttons->box(FL_FLAT_BOX);

  349. 	m_Buttons->user_data((void*)(this));

  350. 	Left->add(m_Buttons); 

  351. 

  352. 	m_CanvasScroll = new Fl_Scroll(TOOLBOX_WIDTH, 0+edy, MAIN_WIDTH-TOOLBOX_WIDTH, MAIN_HEIGHT, "");	

  353. 	m_EditorWindow->add(m_CanvasScroll);

  354. 	m_EditorWindow->resizable(m_CanvasScroll);

  355. 	

  356. 	m_Canvas = new Fl_Canvas(-5000, -5000, 10000, 10000, "");

  357.     m_Canvas->type(1);

  358. 	m_Canvas->box(FL_FLAT_BOX);

  359.     m_Canvas->labeltype(FL_ENGRAVED_LABEL);

  360.     m_Canvas->align(FL_ALIGN_TOP_LEFT|FL_ALIGN_INSIDE);

  361. 	m_Canvas->color(SpiralSynthModularInfo::GUICOL_Canvas);

  362. 	m_Canvas->user_data((void*)(this));

  363. 	m_Canvas->SetConnectionCallback((Fl_Callback*)cb_Connection);

  364. 	m_Canvas->SetUnconnectCallback((Fl_Callback*)cb_Unconnect);

  365. 	m_Canvas->SetAddDeviceCallback((Fl_Callback*)cb_NewDeviceFromMenu);

  366. 	m_CanvasScroll->add(m_Canvas);   

  367. 

  368. 	m_NewComment = new Fl_Button(TOOLBOX_WIDTH/2-16, MAIN_HEIGHT*2-25, 40, 40, "");

  369. 	m_NewComment->box(FL_NO_BOX);

  370. 	m_Canvas->align(FL_ALIGN_TOP_LEFT|FL_ALIGN_INSIDE);

  371. 	tPix = new Fl_Pixmap(comment_xpm);

  372. 	m_NewComment->image(tPix->copy(tPix->w(),tPix->h()));	

  373. 	delete tPix;	

  374. 	m_NewComment->color(SpiralSynthModularInfo::GUICOL_Button);

  375. 	m_NewComment->selection_color(SpiralSynthModularInfo::GUICOL_Tool);

  376. 	m_NewComment->type(0);

  377. 	m_NewComment->shortcut(FL_F + 10);		

  378. 	m_NewComment->tooltip("New comment in editor");		 

  379. 	m_NewComment->user_data((void*)(this));

  380. 	m_NewComment->callback((Fl_Callback*)cb_NewComment);

  381. 	m_Buttons->add(m_NewComment);

  382. 

  383. 	m_SettingsWindow = new SettingsWindow;

  384. 	m_SettingsWindow->RegisterApp(this);

  385. 	

  386. 	return m_TopWindow;

  387. }

  388. 

  389. //////////////////////////////////////////////////////////

  390. 

  391. void SynthModular::LoadPlugins(string pluginPath)

  392. {

  393. 

  394. 	int Width  = 40;

  395. 	int Height = 40;

  396. 	

  397. 	int SWidth  = 256;

  398. 	int SHeight = 256;

  399. 		

  400. 	Fl_Pixmap pic(SSM_xpm);

  401. 	

  402. 	Fl_Double_Window* Splash = new Fl_Double_Window((Fl::w()/2)-(SWidth/2),

  403. 									                (Fl::h()/2)-(SHeight/2),

  404. 									                SWidth,SHeight,"SSM");

  405. 	Splash->border(0);

  406. 	

  407. 	Fl_Box* pbut = new Fl_Box(0,8,SWidth,SHeight,"");

  408. 	pbut->box(FL_NO_BOX);

  409. 	pic.label(pbut);

  410. 	Fl_Box *splashtext = new Fl_Box(5,SHeight-20,200,20,"Loading...");

  411. 	splashtext->labelsize(10);

  412. 	splashtext->box(FL_NO_BOX);

  413. 	splashtext->align(FL_ALIGN_INSIDE|FL_ALIGN_LEFT);

  414. 	Splash->add(pbut);

  415. 	Splash->add(splashtext);

  416. 	Splash->show();

  417. 

  418. 	int ID=-1;

  419. 	int Icon=0;

  420. 	Fl_Pack *IconPack;

  421. 

  422. 	IconPack = new Fl_Pack(0,0,TOOLBOX_WIDTH-SLIDER_WIDTH,Height,"");

  423.     IconPack->type(FL_HORIZONTAL);

  424. 	IconPack->color(SpiralSynthModularInfo::GUICOL_Tool);

  425. 	IconPack->user_data((void*)(this));  

  426. 	m_ToolPack->add(IconPack);

  427. 

  428. 	for (vector<string>::iterator i=SpiralSynthModularInfo::PLUGINVEC.begin();

  429. 		 i!=SpiralSynthModularInfo::PLUGINVEC.end(); i++)

  430. 	{

  431. 		string Fullpath;

  432. 		if (pluginPath=="")

  433. 		{

  434. 			Fullpath=SpiralSynthModularInfo::PLUGIN_PATH+*i;

  435. 		}

  436. 		else

  437. 		{

  438. 			Fullpath=pluginPath+*"/"+*i;

  439. 		}

  440. 

  441. 		ID=PluginManager::Get()->LoadPlugin(Fullpath.c_str());

  442. 		if (ID!=PluginError)

  443. 		{	

  444. 			#ifdef DEBUG_PLUGINS

  445. 			cerr<<"Plugin ["<<*i<<"] = "<<ID<<endl;

  446. 			#endif

  447. 			

  448. 			if (Icon>=ICON_DEPTH)

  449. 			{

  450. 				Icon=0;

  451. 				IconPack = new Fl_Pack(0,0,TOOLBOX_WIDTH-SLIDER_WIDTH,Height,"");

  452. 	   	 		IconPack->type(FL_HORIZONTAL);

  453. 				IconPack->color(SpiralSynthModularInfo::GUICOL_Tool);

  454. 				IconPack->user_data((void*)(this));

  455. 				m_ToolPack->add(IconPack); 

  456. 			}

  457. 		

  458. 			Fl_Button *NewButton = new Fl_Button(0,0,Width,Height,"");

  459. 			NewButton->labelsize(10);

  460. 			

  461. 			Fl_Pixmap *tPix = new Fl_Pixmap(PluginManager::Get()->GetPlugin(ID)->GetIcon());

  462. 			NewButton->image(tPix->copy(tPix->w(),tPix->h()));		

  463. 			delete tPix;	

  464. 			

  465. 			IconPack->add(NewButton);

  466. 			NewButton->type(0);	

  467. 			NewButton->box(FL_PLASTIC_UP_BOX);				

  468. 			NewButton->align(FL_ALIGN_INSIDE|FL_ALIGN_TOP);

  469. 			NewButton->color(SpiralSynthModularInfo::GUICOL_Button);

  470. 			NewButton->selection_color(SpiralSynthModularInfo::GUICOL_Tool);

  471. 			

  472. 			string tooltip=*i;

  473.             // find the first / if there is one, and get rid of everything before and including it

  474. 			unsigned int p = tooltip.find ('/');

  475. 			if (p < tooltip.length()) tooltip.erase (0, p);

  476. 			// find last . and get rid of everything after and including it

  477. 			p = tooltip.rfind ('.');

  478. 			unsigned int l = tooltip.length ();

  479. 			if (p < l) tooltip.erase (p, l);

  480. 			m_Canvas->AddPluginName (tooltip, PluginManager::Get()->GetPlugin(ID)->ID);

  481. 			splashtext->label (tooltip.c_str());

  482.                		Splash->redraw();

  483. 			NewButton->tooltip (tooltip.c_str());

  484. 			

  485. 			NewButton->callback((Fl_Callback*)cb_NewDevice,&Numbers[ID]);			

  486. 			NewButton->show();

  487. 			m_DeviceVec.push_back(NewButton);			

  488. 			Icon++;

  489. 		

  490. 			m_ToolBox->redraw();

  491. 		

  492. 			m_NextPluginButton++;

  493. 			Fl::check();

  494. 		}

  495. 	}

  496. 	

  497. 	Splash->hide();

  498. 	delete Splash;

  499. }

  500. 

  501. //////////////////////////////////////////////////////////

  502. 

  503. DeviceGUIInfo SynthModular::BuildDeviceGUIInfo(PluginInfo &PInfo)

  504. {

  505. 	DeviceGUIInfo Info;

  506. 	int Height=50;

  507. 	

  508. 	// tweak the size if we have too many ins/outs

  509. 	if (PInfo.NumInputs>4 || PInfo.NumOutputs>4)

  510. 	{

  511. 		if (PInfo.NumInputs<PInfo.NumOutputs)

  512. 		{

  513. 			Height=PInfo.NumOutputs*10+5;

  514. 		}

  515. 		else

  516. 		{

  517. 			Height=PInfo.NumInputs*10+5;

  518. 		}

  519. 	}

  520. 	

  521. 	// Make the guiinfo struct

  522. 	Info.XPos       = 0;

  523. 	Info.YPos       = 0;

  524. 	Info.Width      = 40;

  525. 	Info.Height     = Height;

  526. 	Info.NumInputs  = PInfo.NumInputs;

  527. 	Info.NumOutputs = PInfo.NumOutputs;

  528. 	Info.Name       = PInfo.Name;

  529. 	Info.PortTips   = PInfo.PortTips;

  530. 	Info.PortTypes  = PInfo.PortTypes;

  531. 	

  532. 	return Info;

  533. }

  534. 

  535. //////////////////////////////////////////////////////////

  536. 

  537. DeviceWin* SynthModular::NewDeviceWin(int n, int x, int y)

  538. {

  539. 	DeviceWin *nlw = new DeviceWin;

  540. 	const HostsideInfo* Plugin=PluginManager::Get()->GetPlugin(n);

  541. 		

  542. 	if (!Plugin) return NULL;

  543. 	

  544. 	nlw->m_Device=Plugin->CreateInstance();

  545. 

  546. 	if (!nlw->m_Device)

  547. 	{

  548. 		return NULL;

  549. 	}

  550. 	nlw->m_Device->SetBlockingCallback(cb_Blocking);

  551. 	nlw->m_Device->SetUpdateCallback(cb_Update);

  552. 	nlw->m_Device->SetParent((void*)this);

  553. 

  554. 	PluginInfo PInfo    = nlw->m_Device->Initialise(&m_Info);		

  555. 	SpiralGUIType *temp = nlw->m_Device->CreateGUI();

  556. 	Fl_Pixmap *Pix      = new Fl_Pixmap(Plugin->GetIcon());

  557. 	nlw->m_PluginID     = n;

  558. 

  559. 	if (temp) 

  560. 	{	

  561. 		temp->hide();

  562. 		temp->position(200,50);

  563. 		m_AppGroup->add(temp);		

  564. 		m_MainWindow->redraw();

  565. 	}

  566. 	DeviceGUIInfo Info=BuildDeviceGUIInfo(PInfo);

  567. 	Info.XPos       = x; //TOOLBOX_WIDTH+(rand()%400);

  568. 	Info.YPos       = y; //rand()%400;

  569. 	

  570. 	nlw->m_DeviceGUI = new Fl_DeviceGUI(Info, temp, Pix);

  571. 	m_Canvas->add(nlw->m_DeviceGUI);

  572. 	m_Canvas->redraw();

  573. 

  574. 	return nlw;	

  575. }

  576. 

  577. //////////////////////////////////////////////////////////

  578. 

  579. void SynthModular::AddDevice(int n, int x=-1, int y=-1)

  580. {

  581. 	//cerr<<"Adding "<<m_NextID<<endl;

  582. 	

  583. 	if (x==-1)

  584. 	{	

  585. 		x = m_CanvasScroll->x()+50; 

  586. 		y = m_CanvasScroll->y()+50; 

  587. 	}

  588. 

  589. 	DeviceWin* temp = NewDeviceWin(n,x,y);

  590. 	if (temp)

  591. 	{

  592. 		int ID=m_NextID++;

  593. 		//cerr<<"adding device "<<ID<<endl;

  594. 		temp->m_DeviceGUI->SetID(ID);

  595. 		temp->m_Device->SetUpdateInfoCallback(ID,cb_UpdatePluginInfo);

  596. 		m_DeviceWinMap[ID]=temp;

  597. 	}

  598. }

  599. 

  600. //////////////////////////////////////////////////////////

  601. 

  602. DeviceWin* SynthModular::NewComment(int n, int x=-1, int y=-1)

  603. {	

  604. 	DeviceWin *nlw = new DeviceWin;

  605. 

  606. 	if (x==-1)

  607. 	{	

  608. 		x = m_CanvasScroll->x()+50; 

  609. 		y = m_CanvasScroll->y()+50; 

  610. 	}

  611. 		

  612. 	nlw->m_Device=NULL;

  613. 	nlw->m_PluginID  = COMMENT_ID;

  614. 	

  615. 	DeviceGUIInfo Info;	

  616. 	

  617. 	Info.XPos       = x; 

  618. 	Info.YPos       = y; 

  619. 	Info.Width      = 50;

  620. 	Info.Height     = 20;

  621. 	Info.NumInputs  = 0;

  622. 	Info.NumOutputs = 0;

  623. 	Info.Name = "";

  624. 	

  625. 	nlw->m_DeviceGUI = new Fl_CommentGUI(Info, NULL, NULL);

  626. 			

  627. 	m_Canvas->add(nlw->m_DeviceGUI);

  628. 	m_Canvas->redraw();

  629. 	

  630. 	return nlw;

  631. }

  632. 

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

  634. 

  635. void SynthModular::AddComment(int n)

  636. {

  637. 	//cerr<<"Adding "<<m_NextID<<endl;

  638. 	DeviceWin* temp = NewComment(n);

  639. 	if (temp)

  640. 	{

  641. 		int ID=m_NextID++;

  642. 		//cerr<<"adding comment "<<ID<<endl;

  643. 		temp->m_DeviceGUI->SetID(ID);

  644. 		m_DeviceWinMap[ID]=temp;

  645. 	}

  646. }

  647. 

  648. //////////////////////////////////////////////////////////

  649. 

  650. void SynthModular::UpdateHostInfo()

  651. {   

  652. 	// used to use string streams, but this seems to cause a compiler bug 

  653. 	// at the moment, so fall back to using a temporary file 

  654. 	

  655. 	//std::stringstream str;

  656. 	fstream ofs("___temp.ssmtmp",ios::out);		

  657. 	//str<<*this;

  658. 	ofs<<*this;

  659. 	

  660. 	ClearUp();

  661. 				

  662. 	// update the settings

  663. 	m_Info.BUFSIZE    = SpiralInfo::BUFSIZE;

  664. 	m_Info.FRAGSIZE   = SpiralInfo::FRAGSIZE;

  665. 	m_Info.FRAGCOUNT  = SpiralInfo::FRAGCOUNT;	

  666. 	m_Info.SAMPLERATE = SpiralInfo::SAMPLERATE;

  667. 	m_Info.OUTPUTFILE = SpiralInfo::OUTPUTFILE;

  668. 	m_Info.MIDIFILE   = SpiralInfo::MIDIFILE; 

  669. 	m_Info.POLY       = SpiralInfo::POLY;

  670. 

  671. 	fstream ifs("___temp.ssmtmp",ios::in);			

  672. 	//str>>*this;

  673. 	ifs>>*this;

  674. 	

  675. 	system("rm -f ___temp.ssmtmp");

  676. 	

  677. }

  678. 

  679. //////////////////////////////////////////////////////////

  680. 

  681. // called when a callback output plugin wants to run the audio thread

  682. void SynthModular::cb_Update(void* o, bool mode)

  683. {

  684. 	m_CallbackUpdateMode=mode;

  685. 	((SynthModular*)o)->Update();

  686. }

  687. 

  688. // called by a blocking output plugin to notify the engine its ready to

  689. // take control of the update timing (so take the brakes off)

  690. void SynthModular::cb_Blocking(void* o, bool mode)

  691. {

  692. 	m_BlockingOutputPluginIsReady=mode;

  693. }

  694. 

  695. //////////////////////////////////////////////////////////

  696. 

  697. istream &operator>>(istream &s, SynthModular &o)

  698. {	

  699. 	o.PauseAudio();

  700. 

  701. 	string dummy,dummy2;

  702. 	int ver;

  703. 	s>>dummy>>dummy>>dummy>>ver;

  704. 	

  705. 	if (ver>FILE_VERSION)

  706. 	{

  707. 		SpiralInfo::Alert("Bad file, or more recent version.");

  708. 		return s;

  709. 	}

  710. 

  711. 	if (ver>2)

  712. 	{

  713. 		int MainWinX,MainWinY,MainWinW,MainWinH;

  714. 		int EditWinX,EditWinY,EditWinW,EditWinH;

  715. 	

  716. 		s>>MainWinX>>MainWinY>>MainWinW>>MainWinH;

  717. 		s>>EditWinX>>EditWinY>>EditWinW>>EditWinH;

  718. 	

  719. 		//o.m_MainWindow->resize(MainWinX,MainWinY,MainWinW,MainWinH);

  720. 		//o.m_EditorWindow->resize(EditWinX,EditWinY,EditWinW,EditWinH);	

  721. 	}

  722. 	

  723. 	int Num, ID, PluginID, x,y,ps,px,py;

  724. 	s>>dummy>>Num;

  725. 

  726. 	for(int n=0; n<Num; n++)

  727. 	{	

  728. 		#ifdef DEBUG_STREAM

  729. 		cerr<<"Loading Device "<<n<<endl;

  730. 		#endif

  731. 		

  732. 		s>>dummy;    

  733. 		s>>ID;       

  734. 		s>>dummy2;    

  735. 		s>>PluginID; 

  736. 		s>>x>>y;

  737. 		

  738. 		#ifdef DEBUG_STREAM

  739. 		cerr<<dummy<<" "<<ID<<" "<<dummy2<<" "<<PluginID<<" "<<x<<" "<<y<<endl;

  740. 		#endif

  741. 		

  742. 		if (ver>1) s>>ps>>px>>py;

  743. 		

  744. 		// Check we're not duplicating an ID

  745. 		if (o.m_DeviceWinMap.find(ID)!=o.m_DeviceWinMap.end())

  746. 		{

  747. 			SpiralInfo::Alert("Duplicate device ID found in file - aborting load");

  748. 			return s;

  749. 		}

  750. 				

  751. 		if (PluginID==COMMENT_ID)

  752. 		{		

  753. 			DeviceWin* temp = o.NewComment(PluginID, x, y);

  754. 			if (temp)

  755. 			{

  756. 				temp->m_DeviceGUI->SetID(ID);

  757. 				o.m_DeviceWinMap[ID]=temp;

  758. 				((Fl_CommentGUI*)(o.m_DeviceWinMap[ID]->m_DeviceGUI))->StreamIn(s); // load the plugin	

  759. 				if (o.m_NextID<=ID) o.m_NextID=ID+1;

  760. 			}

  761. 		}

  762. 		else

  763. 		{

  764. 			DeviceWin* temp = o.NewDeviceWin(PluginID, x, y);

  765. 			if (temp)

  766. 			{

  767. 				temp->m_DeviceGUI->SetID(ID);

  768. 				temp->m_Device->SetUpdateInfoCallback(ID,o.cb_UpdatePluginInfo);					

  769. 				o.m_DeviceWinMap[ID]=temp;

  770. 				o.m_DeviceWinMap[ID]->m_Device->StreamIn(s); // load the plugin

  771.  				

  772. 				if (ver>1 && o.m_DeviceWinMap[ID]->m_DeviceGUI->GetPluginWindow()) 

  773. 				{

  774. 					// set the GUI up with the loaded values

  775. 					// looks messy, but if we do it here, the plugin and it's gui can remain

  776. 					// totally seperated.

  777. 					((SpiralPluginGUI*)(o.m_DeviceWinMap[ID]->m_DeviceGUI->GetPluginWindow()))->

  778. 						UpdateValues(o.m_DeviceWinMap[ID]->m_Device);

  779. 

  780. 					// updates the data in the channel buffers, so the values don't

  781. 					// get overwritten in the next tick. (should maybe be somewhere else)

  782. 					o.m_DeviceWinMap[ID]->m_Device->GetChannelHandler()->FlushChannels();

  783. 

  784. 					// position the plugin window in the main window

  785. 					o.m_DeviceWinMap[ID]->m_DeviceGUI->GetPluginWindow()->position(px,py);

  786. 						

  787. 					if (ps) o.m_DeviceWinMap[ID]->m_DeviceGUI->GetPluginWindow()->show();

  788. 					else o.m_DeviceWinMap[ID]->m_DeviceGUI->GetPluginWindow()->hide();

  789. 					

  790. 					// load external files

  791. 					o.m_DeviceWinMap[ID]->m_Device->LoadExternalFiles(o.m_FilePath+"_files/");

  792. 				}

  793. 

  794. 				if (o.m_NextID<=ID) o.m_NextID=ID+1;

  795. 			}

  796. 			else 

  797. 			{

  798. 				// can't really recover if the plugin ID doesn't match a plugin, as

  799. 			    // we have no idea how much data in the stream belongs to this plugin

  800. 				SpiralInfo::Alert("Error in stream, can't really recover data from here on.");

  801. 				return s;

  802. 			}

  803. 		}	

  804. 	}

  805. 

  806. 	s>>*o.m_Canvas;

  807. 

  808. 	o.ResumeAudio();

  809. 	return s;

  810. }

  811. 

  812. //////////////////////////////////////////////////////////

  813. 

  814. ostream &operator<<(ostream &s, SynthModular &o)

  815. {

  816. 	o.PauseAudio();

  817. 

  818. 	s<<"SpiralSynthModular File Ver "<<FILE_VERSION<<endl;

  819. 		

  820. 	// make external files dir

  821. 	bool ExternalDirUsed=false;

  822. 	string command("mkdir "+o.m_FilePath+"_files");

  823. 	system(command.c_str());

  824. 	

  825. 	if (FILE_VERSION>2)

  826. 	{

  827. 		s<<o.m_MainWindow->x()<<" "<<o.m_MainWindow->y()<<" ";

  828. 		s<<o.m_MainWindow->w()<<" "<<o.m_MainWindow->h()<<" ";

  829. 		s<<o.m_EditorWindow->x()<<" "<<o.m_EditorWindow->y()<<" ";

  830. 		s<<o.m_EditorWindow->w()<<" "<<o.m_EditorWindow->h()<<endl;

  831. 	}

  832. 	

  833. 	// save out the SynthModular

  834. 	s<<"SectionList"<<endl;

  835. 	s<<o.m_DeviceWinMap.size()<<endl;

  836. 	

  837. 	for(map<int,DeviceWin*>::iterator i=o.m_DeviceWinMap.begin();

  838. 		i!=o.m_DeviceWinMap.end(); i++)

  839. 	{		

  840. 		s<<endl;

  841. 		s<<"Device ";

  842. 		s<<i->first<<" "; // save the id

  843. 		s<<"Plugin ";

  844. 		s<<i->second->m_PluginID<<endl;

  845. 		s<<i->second->m_DeviceGUI->x()<<" ";

  846. 		s<<i->second->m_DeviceGUI->y()<<" ";

  847. 		

  848. 		if (i->second->m_DeviceGUI->GetPluginWindow())

  849. 		{

  850. 			s<<i->second->m_DeviceGUI->GetPluginWindow()->visible()<<" ";

  851. 			s<<i->second->m_DeviceGUI->GetPluginWindow()->x()<<" ";

  852. 			s<<i->second->m_DeviceGUI->GetPluginWindow()->y()<<" ";

  853. 		}

  854. 		else

  855. 		{

  856. 			s<<0<<" "<<0<<" "<<0;

  857. 		}

  858. 		

  859. 		s<<endl;

  860. 		

  861. 		if (i->second->m_PluginID==COMMENT_ID)

  862. 		{

  863. 			// save the comment gui

  864. 			((Fl_CommentGUI*)(i->second->m_DeviceGUI))->StreamOut(s);

  865. 		}

  866. 		else

  867. 		{		

  868. 			// save the plugin

  869. 			i->second->m_Device->StreamOut(s); 

  870. 		}

  871. 		s<<endl;

  872. 		

  873. 		// save external files

  874. 		if (i->second->m_Device && i->second->m_Device->SaveExternalFiles(o.m_FilePath+"_files/"))

  875. 		{

  876. 			ExternalDirUsed=true;

  877. 		}

  878. 	}

  879. 	

  880. 	s<<endl<<*o.m_Canvas<<endl;

  881. 	

  882. 	// remove it if it wasn't used

  883. 	if (!ExternalDirUsed)

  884. 	{

  885. 		// i guess rmdir won't work if there is something in the dir

  886. 		// anyway, but best to be on the safe side. (could do rm -rf) :)

  887. 		string command("rmdir "+o.m_FilePath+"_files");

  888. 		system(command.c_str());

  889. 	}

  890. 	

  891. 	o.ResumeAudio();

  892. 

  893. 	return s;

  894. }

  895. 

  896. //////////////////////////////////////////////////////////

  897. 

  898. inline void SynthModular::cb_Close_i(Fl_Window* o, void* v)

  899. {

  900. 	m_SettingsWindow->hide();

  901. 	delete m_SettingsWindow;

  902. 	m_EditorWindow->hide();

  903. 	delete m_EditorWindow;

  904. 	o->hide();

  905. }

  906. 

  907. void SynthModular::cb_Close(Fl_Window* o, void* v)

  908. {((SynthModular*)(o->user_data()))->cb_Close_i(o,v);}

  909. 

  910. //////////////////////////////////////////////////////////

  911. 

  912. inline void SynthModular::cb_Load_i(Fl_Button* o, void* v)

  913. {

  914. 	if (m_DeviceWinMap.size()>0 && !Pawfal_YesNo("Load - Lose changes to current patch?"))

  915. 	{

  916. 		return;

  917. 	}	

  918. 	

  919. 	char *fn=fl_file_chooser("Load a patch", "*.ssm", NULL);

  920. 	

  921. 	if (fn && fn!='\0')

  922. 	{

  923. 		ifstream inf(fn);

  924. 		

  925. 		if (inf)

  926. 		{	

  927. 			m_FilePath=fn;	

  928. 			

  929. 			ClearUp();

  930. 			inf>>*this;

  931. 						

  932. 			TITLEBAR=LABEL+" "+fn;

  933. 			m_TopWindow->label(TITLEBAR.c_str());

  934. 		}

  935. 	}

  936. }

  937. 

  938. void SynthModular::cb_Load(Fl_Button* o, void* v)

  939. {((SynthModular*)(o->parent()->user_data()))->cb_Load_i(o,v);}

  940. 

  941. //////////////////////////////////////////////////////////

  942. 

  943. inline void SynthModular::cb_Save_i(Fl_Button* o, void* v)

  944. {

  945. 	char *fn=fl_file_chooser("Save a patch", "*.ssm", NULL);

  946. 	

  947. 	if (fn && fn!='\0')

  948. 	{	

  949. 		ifstream ifl(fn);

  950. 		if (ifl)

  951. 		{

  952. 			if (!Pawfal_YesNo("File [%s] exists, overwrite?",fn))

  953. 			{

  954. 				return;

  955. 			}			

  956. 		}

  957. 	

  958. 		ofstream of(fn);

  959. 		

  960. 		if (of)

  961. 		{	

  962. 			m_FilePath=fn;

  963. 			

  964. 			of<<*this;

  965. 					

  966. 			TITLEBAR=LABEL+" "+fn;

  967. 			m_TopWindow->label(TITLEBAR.c_str());

  968. 		}

  969. 	}

  970. }

  971. void SynthModular::cb_Save(Fl_Button* o, void* v)

  972. {((SynthModular*)(o->parent()->user_data()))->cb_Save_i(o,v);}

  973. 

  974. //////////////////////////////////////////////////////////

  975. 

  976. inline void SynthModular::cb_New_i(Fl_Button* o, void* v)

  977. {

  978. 	if (m_DeviceWinMap.size()>0 && !Pawfal_YesNo("New - Lose changes to current patch?"))

  979. 	{

  980. 		return;

  981. 	}	

  982. 

  983. 	m_TopWindow->label(TITLEBAR.c_str());

  984. 

  985. 	ClearUp();

  986. }

  987. void SynthModular::cb_New(Fl_Button* o, void* v)

  988. {((SynthModular*)(o->parent()->user_data()))->cb_New_i(o,v);}

  989. 

  990. //////////////////////////////////////////////////////////

  991. 

  992. inline void SynthModular::cb_NewDevice_i(Fl_Button* o, void* v)

  993. {

  994. 	AddDevice(*((int*)v));

  995. }

  996. void SynthModular::cb_NewDevice(Fl_Button* o, void* v)

  997. {((SynthModular*)(o->parent()->user_data()))->cb_NewDevice_i(o,v);}

  998. 

  999. //////////////////////////////////////////////////////////

  1000. 

  1001. inline void SynthModular::cb_NewDeviceFromMenu_i(Fl_Canvas* o, void* v)

  1002. {

  1003. 	AddDevice(*((int*)v),*((int*)v+1),*((int*)v+2));

  1004. }

  1005. void SynthModular::cb_NewDeviceFromMenu(Fl_Canvas* o, void* v)

  1006. {((SynthModular*)(o->user_data()))->cb_NewDeviceFromMenu_i(o,v);}

  1007. 

  1008. //////////////////////////////////////////////////////////

  1009. 

  1010. inline void SynthModular::cb_NewComment_i(Fl_Button* o, void* v)

  1011. {

  1012. 	AddComment(-1);

  1013. }

  1014. void SynthModular::cb_NewComment(Fl_Button* o, void* v)

  1015. {((SynthModular*)(o->user_data()))->cb_NewComment_i(o,v);}

  1016. 

  1017. //////////////////////////////////////////////////////////

  1018. 

  1019. inline void SynthModular::cb_OpenEditor_i(Fl_Button* o, void* v)

  1020. {

  1021. 	//if (m_EditorWindow->shown()) m_EditorWindow->hide();

  1022. 	//else m_EditorWindow->show();

  1023. }

  1024. void SynthModular::cb_OpenEditor(Fl_Button* o, void* v)

  1025. {((SynthModular*)(o->parent()->user_data()))->cb_OpenEditor_i(o,v);}

  1026. 

  1027. //////////////////////////////////////////////////////////

  1028. 

  1029. inline void SynthModular::cb_Rload_i(Fl_Button* o, void* v)

  1030. {

  1031. 	m_SettingsWindow->show();

  1032. 	

  1033. 	/*PluginManager::Get()->UnloadAll();

  1034. 

  1035. 	m_ToolBox->remove(m_ToolPack);

  1036. 	delete m_ToolPack;

  1037. 

  1038. 	m_ToolPack = new Fl_Pack(5,20,TOOLBOX_WIDTH-10, TOOLBOX_HEIGHT-40,"");

  1039.     m_ToolPack->type(FL_VERTICAL);

  1040. 	m_ToolPack->box(FL_NO_BOX);

  1041. 	m_ToolPack->color(SpiralSynthModularInfo::GUICOL_Tool);

  1042.     m_ToolPack->user_data((void*)(this));

  1043. 	m_ToolBox->add(m_ToolPack); 

  1044. 	m_ToolBox->redraw();

  1045. 	

  1046. 	LoadPlugins();*/

  1047. }

  1048. void SynthModular::cb_Rload(Fl_Button* o, void* v)

  1049. {((SynthModular*)(o->parent()->user_data()))->cb_Rload_i(o,v);}

  1050. 

  1051. //////////////////////////////////////////////////////////

  1052. 

  1053. inline void SynthModular::cb_Connection_i(Fl_Canvas* o, void* v)

  1054. {

  1055. 	CanvasWire *Wire;

  1056. 	Wire=(CanvasWire*)v;

  1057. 			

  1058. 	map<int,DeviceWin*>::iterator si=m_DeviceWinMap.find(Wire->OutputID);

  1059. 	if (si==m_DeviceWinMap.end())

  1060. 	{

  1061. 		char num[32]; 

  1062. 		sprintf(num,"%d",Wire->OutputID);

  1063. 		SpiralInfo::Alert("Warning: Connection problem - can't find source "+string(num));

  1064. 		return;

  1065. 	}

  1066. 	

  1067. 	map<int,DeviceWin*>::iterator di=m_DeviceWinMap.find(Wire->InputID);

  1068. 	if (di==m_DeviceWinMap.end())

  1069. 	{

  1070. 		char num[32]; 

  1071. 		sprintf(num,"%d",Wire->InputID);

  1072. 		SpiralInfo::Alert("Warning: Connection problem - can't find destination "+string(num));

  1073. 		return;

  1074. 	}

  1075. 

  1076. 	Sample *sample=NULL;

  1077. 	

  1078. 	if (!si->second->m_Device->GetOutput(Wire->OutputPort,&sample))

  1079. 	{ 

  1080. 		char num[32]; 

  1081. 		sprintf(num,"%d,%d",Wire->OutputID,Wire->OutputPort);

  1082. 		SpiralInfo::Alert("Warning: Connection problem - can't find source output "+string(num));

  1083. 		return; 

  1084. 	}

  1085. 	

  1086. 	if (!di->second->m_Device->SetInput(Wire->InputPort,(const Sample*)sample))

  1087. 	{ 

  1088. 		char num[32]; 

  1089. 		sprintf(num,"%d,%d",Wire->InputID,Wire->InputPort);

  1090. 		SpiralInfo::Alert("Warning: Connection problem - can't find source input "+string(num));

  1091. 		return;	

  1092. 	}

  1093. 	

  1094. }

  1095. void SynthModular::cb_Connection(Fl_Canvas* o, void* v)

  1096. {((SynthModular*)(o->user_data()))->cb_Connection_i(o,v);}

  1097. 

  1098. //////////////////////////////////////////////////////////

  1099. 

  1100. inline void SynthModular::cb_Unconnect_i(Fl_Canvas* o, void* v)

  1101. {

  1102. 	CanvasWire *Wire;

  1103. 	Wire=(CanvasWire*)v;

  1104. 	

  1105. 	//cerr<<Wire->InputID<<" "<<Wire->InputPort<<endl;

  1106. 	

  1107. 	map<int,DeviceWin*>::iterator di=m_DeviceWinMap.find(Wire->InputID);

  1108. 	if (di==m_DeviceWinMap.end())

  1109. 	{

  1110. 		//cerr<<"Can't find destination device "<<Wire->InputID<<endl;

  1111. 		return;

  1112. 	}

  1113. 

  1114. 	if (!di->second->m_Device->SetInput(Wire->InputPort,NULL))

  1115. 	{ cerr<<"Can't find destination device's Input"<<endl; return;	}

  1116. 	

  1117. }

  1118. void SynthModular::cb_Unconnect(Fl_Canvas* o, void* v)

  1119. {((SynthModular*)(o->user_data()))->cb_Unconnect_i(o,v);}

  1120. 

  1121. //////////////////////////////////////////////////////////

  1122. 

  1123. void SynthModular::cb_UpdatePluginInfo(int ID, void *PInfo)

  1124. {

  1125. 	map<int,DeviceWin*>::iterator i=m_DeviceWinMap.find(ID);

  1126. 	if (i!=m_DeviceWinMap.end())

  1127. 	{

  1128. 		DeviceGUIInfo Info=BuildDeviceGUIInfo(*((PluginInfo*)PInfo));

  1129. 	

  1130. 		(*i).second->m_DeviceGUI->Setup(Info);

  1131. 		(*i).second->m_DeviceGUI->redraw();

  1132. 	}

  1133. }

  1134. 

  1135. //////////////////////////////////////////////////////////

  1136. 

  1137. void SynthModular::LoadPatch(const char *fn)

  1138. {

  1139.     ifstream inf(fn);

  1140. 

  1141.     if (inf) 

  1142. 	{	

  1143. 	    m_FilePath=fn;	

  1144. 

  1145. 		ClearUp();

  1146. 	    inf>>*this;

  1147. 

  1148. 	    TITLEBAR=LABEL+" "+fn;

  1149. 	    m_TopWindow->label(TITLEBAR.c_str());

  1150.     }

  1151. }

  1152. 

  1153. //////////////////////////////////////////////////////////