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

1064 lines
28KB
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_ask.h>

  27. #include <FL/Fl_Box.h>

  28. #include <FL/Fl_Tooltip.h>

  29. 

  30. #include "SpiralSynthModular.h"

  31. #include "SpiralSound/PluginManager.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. 

  41. const static string LABEL = "SpiralSynthModular 0.1.1b1";

  42. static string TITLEBAR;

  43. 

  44. static const int FILE_VERSION = 3;

  45. static int Numbers[512];

  46. 

  47. static const int MAIN_WIDTH     = 700;

  48. static const int MAIN_HEIGHT    = 300;

  49. static const int SLIDER_WIDTH   = 15;

  50. static const int TOOLBOX_HEIGHT = MAIN_HEIGHT-40;

  51. static const int TOOLBOX_WIDTH  = 132+SLIDER_WIDTH;

  52. static const int ICON_DEPTH     = 3;

  53. static const int COMMENT_ID     = -1;

  54. 

  55. using namespace std;

  56. 

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

  58. bool SynthModular::m_CallbackUpdateMode = false;

  59. 

  60. //////////////////////////////////////////////////////////

  61. 

  62. DeviceWin::~DeviceWin()

  63. {	

  64. 	what happens now?

  65. 	this is a test for merging

  66. 	ah I see!

  67. } 

  68. 

  69. //////////////////////////////////////////////////////////

  70. 		

  71. SynthModular::SynthModular():

  72. m_NextID(0),

  73. m_NextPluginButton(1),

  74. m_NextPluginButtonXPos(5),

  75. m_NextPluginButtonYPos(20)

  76. { 	

  77. 	m_Info.BUFSIZE    = SpiralInfo::BUFSIZE;

  78. 	m_Info.FRAGSIZE   = SpiralInfo::FRAGSIZE;

  79. 	m_Info.FRAGCOUNT  = SpiralInfo::FRAGCOUNT;	

  80. 	m_Info.SAMPLERATE = SpiralInfo::SAMPLERATE;

  81. 	m_Info.OUTPUTFILE = SpiralInfo::OUTPUTFILE;

  82. 	m_Info.MIDIFILE   = SpiralInfo::MIDIFILE; 

  83. 	m_Info.POLY       = SpiralInfo::POLY;

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

  85. 	

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

  87. }

  88. 

  89. //////////////////////////////////////////////////////////

  90. 

  91. SynthModular::~SynthModular()

  92. { 

  93. 	ClearUp();

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

  95. }

  96. 

  97. //////////////////////////////////////////////////////////

  98. 

  99. void SynthModular::ClearUp()

  100. {

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

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

  103. 	{

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

  105. 		{

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

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

  108. 		}

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

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

  111. 		delete i->second->m_Device;

  112. 	}

  113. 	

  114. 	m_Canvas->Clear();

  115. 	m_DeviceWinMap.clear();

  116. 	m_NextID=0;

  117. }

  118. 

  119. //////////////////////////////////////////////////////////

  120. 

  121. void SynthModular::Update()

  122. {	

  123. 	// run the plugins

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

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

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

  127. 	{

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

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

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

  131. 		{

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

  133. 		}

  134. 	}

  135. }

  136. 

  137. //////////////////////////////////////////////////////////

  138. 

  139. void SynthModular::UpdatePluginGUIs()

  140. {

  141. 	// see if any need deleting		

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

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

  144. 	{	

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

  146. 		{

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

  148. 			{

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

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

  151. 			}

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

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

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

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

  156. 			if (i->second->m_Device) delete i->second->m_Device;

  157. 			m_DeviceWinMap.erase(i);

  158. 			break;

  159. 		}

  160. 	}

  161. }

  162. 

  163. //////////////////////////////////////////////////////////

  164. 

  165. SpiralWindowType *SynthModular::CreateWindow()

  166. {

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

  168. 	

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

  170. 	m_TopWindow->resizable(m_TopWindow);

  171. 	

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

  173. 	m_TopWindow->add(m_TopTile);

  174. 

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

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

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

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

  179. 	m_TopTile->add(m_MainWindow);

  180. 	

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

  182.     m_MainButtons->type(1);

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

  184. 	m_MainButtons->box(FL_FLAT_BOX);

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

  186. 	m_MainWindow->add(m_MainButtons); 

  187. 

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

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

  190. 	m_MainWindow->add(m_AppScroll);

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

  192. 

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

  194.     m_AppGroup->type(1);

  195. 	m_AppGroup->box(FL_FLAT_BOX);

  196.     m_AppGroup->labeltype(FL_ENGRAVED_LABEL);

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

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

  199. 	m_AppScroll->add(m_AppGroup);   	

  200. 

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

  202. 	m_Load->box(FL_NO_BOX);

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

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

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

  206.     m_Load->tooltip("Load a design file");		 

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

  208. 	m_MainButtons->add(m_Load);

  209. 	n++;

  210. 	

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

  212. 	m_Save->box(FL_NO_BOX);

  213. 	tPix = new Fl_Pixmap(save_xpm);

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

  215. 	delete tPix;	

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

  217.  	m_Save->tooltip("Save a design file");		 

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

  219. 	m_MainButtons->add(m_Save);

  220. 	n++;

  221. 		

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

  223. 	m_New->box(FL_NO_BOX);

  224. 	tPix = new Fl_Pixmap(new_xpm);

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

  226. 	delete tPix;	

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

  228.   	m_New->tooltip("New design");		 

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

  230. 	m_MainButtons->add(m_New);

  231. 	n++;

  232. 				

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

  234. 	m_Options->box(FL_NO_BOX);

  235. 	tPix = new Fl_Pixmap(options_xpm);

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

  237. 	delete tPix;		

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

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

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

  241. 	m_MainButtons->add(m_Options);

  242. 	n++;

  243. 	

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

  245. 	m_OpenEditor->box(FL_NO_BOX);

  246. 	tPix = new Fl_Pixmap(edit_xpm);

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

  248. 	delete tPix;	

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

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

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

  252. 	m_MainButtons->add(m_OpenEditor);

  253. 	n++;*/

  254. 			

  255. 	/////////////////

  256. 

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

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

  259. 	m_TopTile->add(m_EditorWindow);

  260. 	

  261. 	int edy = MAIN_HEIGHT;

  262. 	

  263. 	m_ToolBox = new Fl_Scroll(0,0+edy,TOOLBOX_WIDTH, MAIN_HEIGHT, "");

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

  265. 	m_ToolBox->box(FL_FLAT_BOX);

  266.     m_ToolBox->labeltype(FL_ENGRAVED_LABEL);

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

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

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

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

  271. 	m_EditorWindow->add(m_ToolBox);  

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

  273. 	

  274. 	Fl_Box *Label = new Fl_Box(5,3+edy,100,20,"");

  275. 	Label->box(FL_FLAT_BOX);

  276. 	Label->color(SpiralSynthModularInfo::GUICOL_Tool);

  277. 	Label->labeltype(FL_ENGRAVED_LABEL);

  278. 	Label->align(FL_ALIGN_TOP_LEFT|FL_ALIGN_INSIDE);

  279. 	m_ToolBox->add(Label);

  280. 	

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

  282.     m_ToolPack->type(FL_VERTICAL);

  283. 	m_ToolPack->box(FL_NO_BOX);

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

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

  286. 	m_ToolBox->add(m_ToolPack);  

  287. 	

  288. 	xoff=0; yoff=TOOLBOX_HEIGHT;

  289. 	

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

  291. 	m_EditorWindow->add(m_CanvasScroll);

  292. 	

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

  294.     m_Canvas->type(1);

  295. 	m_Canvas->box(FL_FLAT_BOX);

  296.     m_Canvas->labeltype(FL_ENGRAVED_LABEL);

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

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

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

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

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

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

  303. 	m_CanvasScroll->add(m_Canvas);   

  304. 

  305. 	/*m_NewComment = new Fl_Button(MAIN_WIDTH-15, MAIN_HEIGHT*2-15, 15, 30, "");

  306. 	m_NewComment->box(FL_NO_BOX);

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

  308. 	tPix = new Fl_Pixmap(comment_xpm);

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

  310. 	delete tPix;	

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

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

  313. 	m_NewComment->type(0);

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

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

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

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

  318. 	m_EditorWindow->add(m_NewComment);*/

  319. 

  320. 	m_SettingsWindow = new SettingsWindow;

  321. 	m_SettingsWindow->RegisterApp(this);

  322. 	

  323. 	return m_TopWindow;

  324. }

  325. 

  326. //////////////////////////////////////////////////////////

  327. 

  328. void SynthModular::LoadPlugins()

  329. {

  330. 

  331. 	int Width  = 40;

  332. 	int Height = 40;

  333. 	

  334. 	int SWidth  = 392;

  335. 	int SHeight = 187;

  336. 		

  337. 	Fl_Pixmap pic(SSM_xpm);

  338. 	

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

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

  341. 									                SWidth,SHeight,"SSM");

  342. 	Splash->border(0);

  343. 	

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

  345. 	pbut->box(FL_NO_BOX);

  346. 	pic.label(pbut);

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

  348. 	splashtext->labelsize(10);

  349. 	splashtext->box(FL_NO_BOX);

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

  351. 	Splash->add(pbut);

  352. 	Splash->add(splashtext);

  353. 	Splash->show();

  354. 

  355. 	int ID=-1;

  356. 	int Icon=0;

  357. 	Fl_Pack *IconPack;

  358. 

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

  360.     IconPack->type(FL_HORIZONTAL);

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

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

  363. 	m_ToolPack->add(IconPack);

  364. 

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

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

  367. 	{

  368. 		string Fullpath=SpiralSynthModularInfo::PLUGIN_PATH+*i;

  369. 

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

  371. 		if (ID!=PluginError)

  372. 		{	

  373. 			if (Icon>=ICON_DEPTH)

  374. 			{

  375. 				Icon=0;

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

  377. 	   	 		IconPack->type(FL_HORIZONTAL);

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

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

  380. 				m_ToolPack->add(IconPack); 

  381. 			}

  382. 		

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

  384. 			NewButton->labelsize(10);

  385. 			

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

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

  388. 			delete tPix;	

  389. 			

  390. 			IconPack->add(NewButton);

  391. 			NewButton->type(0);	

  392. 			NewButton->box(FL_PLASTIC_UP_BOX);				

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

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

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

  396. 			

  397. 			string tooltip=*i;

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

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

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

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

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

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

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

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

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

  407.                		Splash->redraw();

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

  409. 			

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

  411. 			NewButton->show();

  412. 			m_DeviceVec.push_back(NewButton);			

  413. 			Icon++;

  414. 		

  415. 			m_ToolBox->redraw();

  416. 		

  417. 			m_NextPluginButton++;

  418. 			Fl::check();

  419. 		}

  420. 	}

  421. 	

  422. 	Splash->hide();

  423. 	delete Splash;

  424. }

  425. 

  426. //////////////////////////////////////////////////////////

  427. 

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

  429. {

  430. 	DeviceGUIInfo Info;

  431. 	int Height=50;

  432. 	

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

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

  435. 	{

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

  437. 		{

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

  439. 		}

  440. 		else

  441. 		{

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

  443. 		}

  444. 	}

  445. 	

  446. 	// Make the guiinfo struct

  447. 	Info.XPos       = 0;

  448. 	Info.YPos       = 0;

  449. 	Info.Width      = 40;

  450. 	Info.Height     = Height;

  451. 	Info.NumInputs  = PInfo.NumInputs;

  452. 	Info.NumOutputs = PInfo.NumOutputs;

  453. 	Info.Name       = PInfo.Name;

  454. 	Info.PortTips   = PInfo.PortTips;

  455. 	Info.PortTypes  = PInfo.PortTypes;

  456. 	

  457. 	return Info;

  458. }

  459. 

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

  461. 

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

  463. {

  464. 	DeviceWin *nlw = new DeviceWin;

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

  466. 		

  467. 	if (!Plugin) return NULL;

  468. 	

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

  470. 

  471. 	if (!nlw->m_Device)

  472. 	{

  473. 		return NULL;

  474. 	}

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

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

  477. 

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

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

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

  481. 	nlw->m_PluginID     = n;

  482. 

  483. 	if (temp) 

  484. 	{	

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

  486. 		m_AppGroup->add(temp);		

  487. 		m_MainWindow->redraw();

  488. 	}

  489. 	DeviceGUIInfo Info=BuildDeviceGUIInfo(PInfo);

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

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

  492. 	

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

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

  495. 	m_Canvas->redraw();

  496. 

  497. 	return nlw;	

  498. }

  499. 

  500. //////////////////////////////////////////////////////////

  501. 

  502. void SynthModular::AddDevice(int n, int x=TOOLBOX_WIDTH+50, int y=400)

  503. {

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

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

  506. 	if (temp)

  507. 	{

  508. 		int ID=m_NextID++;

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

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

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

  512. 		m_DeviceWinMap[ID]=temp;

  513. 	}

  514. }

  515. 

  516. //////////////////////////////////////////////////////////

  517. 

  518. DeviceWin* SynthModular::NewComment(int n, int x=TOOLBOX_WIDTH+50, int y=400)

  519. {	

  520. 	DeviceWin *nlw = new DeviceWin;

  521. 	

  522. 	nlw->m_Device=NULL;

  523. 	nlw->m_PluginID  = COMMENT_ID;

  524. 	

  525. 	DeviceGUIInfo Info;	

  526. 	

  527. 	Info.XPos       = x; 

  528. 	Info.YPos       = y; 

  529. 	Info.Width      = 50;

  530. 	Info.Height     = 20;

  531. 	Info.NumInputs  = 0;

  532. 	Info.NumOutputs = 0;

  533. 	Info.Name = "";

  534. 	

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

  536. 			

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

  538. 	m_Canvas->redraw();

  539. 	

  540. 	return nlw;

  541. }

  542. 

  543. //////////////////////////////////////////////////////////

  544. 

  545. void SynthModular::AddComment(int n)

  546. {

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

  548. 	DeviceWin* temp = NewComment(n);

  549. 	if (temp)

  550. 	{

  551. 		int ID=m_NextID++;

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

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

  554. 		m_DeviceWinMap[ID]=temp;

  555. 	}

  556. }

  557. 

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

  559. 

  560. void SynthModular::UpdateHostInfo()

  561. {   

  562. 	std::stringstream str;		

  563. 	str<<*this;

  564. 	

  565. 	ClearUp();

  566. 	

  567. 	// update the settings

  568. 	m_Info.BUFSIZE    = SpiralInfo::BUFSIZE;

  569. 	m_Info.FRAGSIZE   = SpiralInfo::FRAGSIZE;

  570. 	m_Info.FRAGCOUNT  = SpiralInfo::FRAGCOUNT;	

  571. 	m_Info.SAMPLERATE = SpiralInfo::SAMPLERATE;

  572. 	m_Info.OUTPUTFILE = SpiralInfo::OUTPUTFILE;

  573. 	m_Info.MIDIFILE   = SpiralInfo::MIDIFILE; 

  574. 	m_Info.POLY       = SpiralInfo::POLY;

  575. 		

  576. 	str>>*this;

  577. }

  578. 

  579. //////////////////////////////////////////////////////////

  580. 

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

  582. {

  583. 	m_CallbackUpdateMode=mode;

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

  585. }

  586. 

  587. //////////////////////////////////////////////////////////

  588. 

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

  590. {	

  591. 	string dummy;

  592. 	int ver;

  593. 	s>>dummy>>dummy>>dummy>>ver;

  594. 	

  595. 	if (ver>FILE_VERSION)

  596. 	{

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

  598. 		return s;

  599. 	}

  600. 

  601. 	if (ver>2)

  602. 	{

  603. 		int MainWinX,MainWinY,MainWinW,MainWinH;

  604. 		int EditWinX,EditWinY,EditWinW,EditWinH;

  605. 	

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

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

  608. 	

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

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

  611. 	}

  612. 	

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

  614. 	s>>dummy>>Num;

  615. 	

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

  617. 	{	

  618. 		//cerr<<"Loading Device "<<n<<endl;

  619. 		

  620. 		s>>dummy;    //cerr<<dummy<<" ";

  621. 		s>>ID;       //cerr<<ID<<" ";

  622. 		s>>dummy;    //cerr<<dummy<<" ";

  623. 		s>>PluginID; //cerr<<PluginID<<endl;

  624. 		s>>x>>y;

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

  626. 		

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

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

  629. 		{

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

  631. 			return s;

  632. 		}

  633. 				

  634. 		if (PluginID==COMMENT_ID)

  635. 		{		

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

  637. 			if (temp)

  638. 			{

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

  640. 				o.m_DeviceWinMap[ID]=temp;

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

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

  643. 			}

  644. 		}

  645. 		else

  646. 		{

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

  648. 			if (temp)

  649. 			{

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

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

  652. 				o.m_DeviceWinMap[ID]=temp;

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

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

  655. 				{

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

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

  658. 						

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

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

  661. 					

  662. 					// load external files

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

  664. 				}

  665. 

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

  667. 			}

  668. 			else 

  669. 			{

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

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

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

  673. 				return s;

  674. 			}

  675. 		}	

  676. 	}

  677. 

  678. 	s>>*o.m_Canvas;

  679. 

  680. 	return s;

  681. }

  682. 

  683. //////////////////////////////////////////////////////////

  684. 

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

  686. {

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

  688. 		

  689. 	// make external files dir

  690. 	bool ExternalDirUsed=false;

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

  692. 	system(command.c_str());

  693. 	

  694. 	if (FILE_VERSION>2)

  695. 	{

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

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

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

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

  700. 	}

  701. 	

  702. 	// save out the SynthModular

  703. 	s<<"SectionList"<<endl;

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

  705. 	

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

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

  708. 	{		

  709. 		s<<endl;

  710. 		s<<"Device ";

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

  712. 		s<<"Plugin ";

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

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

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

  716. 		

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

  718. 		{

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

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

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

  722. 		}

  723. 		else

  724. 		{

  725. 			s<<0<<" "<<0<<" "<<0;

  726. 		}

  727. 		

  728. 		s<<endl;

  729. 		

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

  731. 		{

  732. 			// save the comment gui

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

  734. 		}

  735. 		else

  736. 		{		

  737. 			// save the plugin

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

  739. 		}

  740. 		s<<endl;

  741. 		

  742. 		// save external files

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

  744. 		{

  745. 			ExternalDirUsed=true;

  746. 		}

  747. 	}

  748. 	

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

  750. 	

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

  752. 	if (!ExternalDirUsed)

  753. 	{

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

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

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

  757. 		system(command.c_str());

  758. 	}

  759. 	

  760. 	return s;

  761. }

  762. 

  763. //////////////////////////////////////////////////////////

  764. 

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

  766. {

  767. 	m_SettingsWindow->hide();

  768. 	delete m_SettingsWindow;

  769. 	m_EditorWindow->hide();

  770. 	delete m_EditorWindow;

  771. 	o->hide();

  772. }

  773. 

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

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

  776. 

  777. //////////////////////////////////////////////////////////

  778. 

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

  780. {

  781. 	if (m_DeviceWinMap.size()>0 && !fl_ask("Load - Loose changes to current design?"))

  782. 	{

  783. 		return;

  784. 	}	

  785. 	

  786. 	char *fn=fl_file_chooser("Load a design", "*.ssm", NULL);

  787. 	

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

  789. 	{

  790. 		ifstream inf(fn);

  791. 		

  792. 		if (inf)

  793. 		{	

  794. 			m_FilePath=fn;	

  795. 			

  796. 			ClearUp();

  797. 			inf>>*this;

  798. 			

  799. 			TITLEBAR=LABEL+" "+fn;

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

  801. 		}

  802. 	}

  803. }

  804. 

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

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

  807. 

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

  809. 

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

  811. {

  812. 	char *fn=fl_file_chooser("Save a design", "*.ssm", NULL);

  813. 	

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

  815. 	{	

  816. 		ifstream ifl(fn);

  817. 		if (ifl)

  818. 		{

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

  820. 			{

  821. 				return;

  822. 			}			

  823. 		}

  824. 	

  825. 		ofstream of(fn);

  826. 		

  827. 		if (of)

  828. 		{	

  829. 			m_FilePath=fn;

  830. 		

  831. 			of<<*this;

  832. 						

  833. 			TITLEBAR=LABEL+" "+fn;

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

  835. 		}

  836. 	}

  837. }

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

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

  840. 

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

  842. 

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

  844. {

  845. 	if (m_DeviceWinMap.size()>0 && !fl_ask("New - Loose changes to current design?"))

  846. 	{

  847. 		return;

  848. 	}	

  849. 

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

  851. 

  852. 	ClearUp();

  853. }

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

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

  856. 

  857. //////////////////////////////////////////////////////////

  858. 

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

  860. {

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

  862. }

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

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

  865. 

  866. //////////////////////////////////////////////////////////

  867. 

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

  869. {

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

  871. }

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

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

  874. 

  875. //////////////////////////////////////////////////////////

  876. 

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

  878. {

  879. 	AddComment(-1);

  880. }

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

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

  883. 

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

  885. 

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

  887. {

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

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

  890. }

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

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

  893. 

  894. //////////////////////////////////////////////////////////

  895. 

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

  897. {

  898. 	m_SettingsWindow->show();

  899. 	

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

  901. 

  902. 	m_ToolBox->remove(m_ToolPack);

  903. 	delete m_ToolPack;

  904. 

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

  906.     m_ToolPack->type(FL_VERTICAL);

  907. 	m_ToolPack->box(FL_NO_BOX);

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

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

  910. 	m_ToolBox->add(m_ToolPack); 

  911. 	m_ToolBox->redraw();

  912. 	

  913. 	LoadPlugins();*/

  914. }

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

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

  917. 

  918. //////////////////////////////////////////////////////////

  919. 

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

  921. {

  922. 	CanvasWire *Wire;

  923. 	Wire=(CanvasWire*)v;

  924. 			

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

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

  927. 	{

  928. 		char num[32]; 

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

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

  931. 		return;

  932. 	}

  933. 	

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

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

  936. 	{

  937. 		char num[32]; 

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

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

  940. 		return;

  941. 	}

  942. 

  943. 	Sample *sample=NULL;

  944. 	

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

  946. 	{ 

  947. 		char num[32]; 

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

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

  950. 		return; 

  951. 	}

  952. 	

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

  954. 	{ 

  955. 		char num[32]; 

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

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

  958. 		return;	

  959. 	}

  960. 	

  961. }

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

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

  964. 

  965. //////////////////////////////////////////////////////////

  966. 

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

  968. {

  969. 	CanvasWire *Wire;

  970. 	Wire=(CanvasWire*)v;

  971. 	

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

  973. 	

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

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

  976. 	{

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

  978. 		return;

  979. 	}

  980. 

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

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

  983. 	

  984. }

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

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

  987. 

  988. //////////////////////////////////////////////////////////

  989. 

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

  991. {

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

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

  994. 	{

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

  996. 	

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

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

  999. 	}

  1000. }

  1001. 

  1002. //////////////////////////////////////////////////////////

  1003. 

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

  1005. {

  1006.     ifstream inf(fn);

  1007. 

  1008.     if (inf) 

  1009. 	{	

  1010. 	    m_FilePath=fn;	

  1011. 

  1012. 	    ClearUp();

  1013. 	    inf>>*this;

  1014. 

  1015. 	    TITLEBAR=LABEL+" "+fn;

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

  1017.     }

  1018. }

  1019. 

  1020. //////////////////////////////////////////////////////////

  1021. //////////////////////////////////////////////////////////

  1022. 

  1023. int main(int argc, char **argv)

  1024. {	

  1025. 	srand(time(NULL));

  1026. 	SpiralSynthModularInfo::Get()->LoadPrefs();

  1027. 	

  1028. 	// get args

  1029.     string cmd_filename="";

  1030.     bool cmd_specd = false;

  1031.     if (argc>1) 

  1032. 	{

  1033.         cmd_filename = argv[1];

  1034.         cmd_specd = true;

  1035.     }	

  1036. 	

  1037. 	Fl::visual(FL_DOUBLE|FL_RGB);

  1038. 	

  1039. 	SynthModular *synth=new SynthModular;

  1040. 	

  1041. 	Fl_Window* win = synth->CreateWindow();

  1042. 	synth->LoadPlugins();

  1043. 	win->xclass("");

  1044. 	win->show(argc, argv); // prevents stuff happening before the plugins have loaded

  1045. 	

  1046. 	Fl_Tooltip::size(10);	

  1047. 	Fl::visible_focus(false);

  1048. 		

  1049. 	// do we need to load a patch on startup? 

  1050.     if (cmd_specd) synth->LoadPatch(cmd_filename.c_str());        

  1051. 

  1052.     for (;;) 

  1053. 	{

  1054.     	if (!Fl::check()) break;

  1055. 		if (!synth->CallbackMode()) synth->Update();

  1056. 		synth->UpdatePluginGUIs(); // deletes any if necc

  1057. 		//else Fl::wait();

  1058.   	}

  1059. 	

  1060. 	delete synth;	

  1061. 	return 1;

  1062. }