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.
224 Commits
1 Branch
1.8MB
Tree: 486efa5215
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '486efa5215'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/LADSPAPlugin/LADSPAPluginGUI.C

1478 lines
43KB
Raw Blame History 

  1. /*  LADSPAPluginGUI.C

  2.  *  Copyleft (C) 2000 David Griffiths <dave@pawfal.org>

  3.  *  LADSPA Plugin by Nicolas Noble <nicolas@nobis-crew.org>

  4.  *  Modified by Mike Rawes <myk@waxfrenzy.org>

  5.  *

  6.  *  This program is free software; you can redistribute it and/or modify

  7.  *  it under the terms of the GNU General Public License as published by

  8.  *  the Free Software Foundation; either version 2 of the License, or

  9.  *  (at your option) any later version.

  10.  *

  11.  *  This program is distributed in the hope that it will be useful,

  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14.  *  GNU General Public License for more details.

  15.  *

  16.  *  You should have received a copy of the GNU General Public License

  17.  *  along with this program; if not, write to the Free Software

  18.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  19. */

  20. 

  21. #include <cstdio>

  22. #include <cmath>

  23. #include <cstring>

  24. #include <dlfcn.h>

  25. #include <vector>

  26. #include <algorithm>

  27. 

  28. #include <FL/fl_draw.H>

  29. #include <FL/Fl_Tooltip.H>

  30. 

  31. #include "LADSPAPluginGUI.h"

  32. #include "LADSPAInfo.h"

  33. 

  34. using namespace std;

  35. 

  36. LADSPAPluginGUI::LADSPAPluginGUI(int w, int h,

  37.                                  LADSPAPlugin *o,

  38.                                  ChannelHandler *ch,

  39.                                  const HostInfo *Info,

  40.                                  const vector<LADSPAInfo::PluginEntry> &PVec) :

  41. SpiralPluginGUI(w,h,o,ch)

  42. {

  43. 	m_GUIColour = (Fl_Color)Info->GUI_COLOUR;

  44.         m_GUIBox = (Fl_Boxtype)Info->GUIDEVICE_Box;

  45. 	m_PluginList = PVec;

  46. 

  47. // Get maximum input port count

  48. 	m_GUICH->GetData("GetMaxInputPortCount",&(m_MaxInputPortCount));

  49. 

  50. // Set up buffers for data transfer via ChannelHandler

  51. 	m_InputPortNames = (char *)malloc(256 * m_MaxInputPortCount);

  52. 	m_InputPortSettings = (PortSetting *)malloc(sizeof(PortSetting) * m_MaxInputPortCount);

  53. 	m_InputPortValues = (PortValue *)calloc(m_MaxInputPortCount, sizeof(PortValue));

  54. 	m_InputPortDefaults = (float *)calloc(m_MaxInputPortCount, sizeof(float));

  55. 

  56. 	if (!(m_InputPortNames && m_InputPortSettings &&

  57. 	      m_InputPortValues && m_InputPortDefaults)) {

  58. 		cerr<<"LADSPA Plugin (GUI): Memory allocation error\n"<<endl;

  59. 	}

  60. 

  61. 	m_InputPortCount = 0;

  62. 	m_UnconnectedInputs = 0;

  63. 	m_PortIndex = 0;

  64. 

  65. // Set up widgets

  66. 	m_BKnob = new Fl_Button(5,15,50,20,"Knobs");

  67. 	m_BKnob->labelsize (10);

  68. 	m_BKnob->type(FL_TOGGLE_BUTTON);

  69. 	m_BKnob->box(m_GUIBox);

  70. 	m_BKnob->color(Info->GUI_COLOUR);

  71. 	m_BKnob->selection_color(m_GUIColour);

  72. 	m_BKnob->callback((Fl_Callback *)cb_BKnob);

  73. 	add(m_BKnob);

  74. 

  75. 	m_BSlider = new Fl_Button(60,15,50,20,"Sliders");

  76. 	m_BSlider->labelsize (10);

  77. 	m_BSlider->type(FL_TOGGLE_BUTTON);

  78. 	m_BSlider->box(m_GUIBox);

  79. 	m_BSlider->color(m_GUIColour);

  80. 	m_BSlider->selection_color(m_GUIColour);

  81. 	m_BSlider->callback((Fl_Callback *)cb_BSlider);

  82. 	add(m_BSlider);

  83. 

  84. 	m_BSetup = new Fl_Button(w - 55,15,50,20,"Setup...");

  85. 	m_BSetup->labelsize (10);

  86. 	m_BSetup->type(FL_TOGGLE_BUTTON);

  87. 	m_BSetup->box(m_GUIBox);

  88. 	m_BSetup->color(m_GUIColour);

  89. 	m_BSetup->selection_color(m_GUIColour);

  90. 	m_BSetup->callback((Fl_Callback *)cb_BSetup);

  91. 	add(m_BSetup);

  92. 

  93. 	m_KnobGroup = new Fl_Group(5, 35, w - 10, h - 40, "");

  94. 	add(m_KnobGroup);

  95. 

  96. 	m_SliderGroup = new Fl_Group(5, 35, 490, 275, "");

  97. 	add(m_SliderGroup);

  98. 

  99. 	m_SetupGroup = new Fl_Group(5, 35, 490, 275, "");

  100. 

  101. 	m_NameLabel = new Fl_Box(10,45,480,15,"None");

  102. 	m_NameLabel->align(FL_ALIGN_LEFT|FL_ALIGN_CLIP|FL_ALIGN_INSIDE);

  103. 	m_NameLabel->labelsize(12);

  104. 	m_SetupGroup->add(m_NameLabel);

  105. 

  106. 	m_MakerLabel = new Fl_Box(10,65,480,15,"None");

  107. 	m_MakerLabel->align(FL_ALIGN_LEFT|FL_ALIGN_CLIP|FL_ALIGN_INSIDE);

  108. 	m_MakerLabel->labelsize(12);

  109. 	m_SetupGroup->add(m_MakerLabel);

  110. 

  111. 	m_Browser = new Fl_Choice(50, 90, 440, 22,"Plugin:");

  112. 	m_Browser->box(m_GUIBox);

  113. 	m_Browser->labelsize(12);

  114. 	m_Browser->textsize(12);

  115. 	m_Browser->callback((Fl_Callback *)cb_Select);

  116. 

  117. 	m_Browser->add("(None)");

  118. 	m_PluginIDLookup.push_back(0);

  119. 

  120. // The plugin list is already formatted for addition to our drop-down,

  121. // so just add all items as they are

  122. 	unsigned long size = m_Browser->size();

  123. 	int depth = 1;

  124. 

  125. 	for (vector<LADSPAInfo::PluginEntry>::iterator i=m_PluginList.begin();

  126. 	     i!=m_PluginList.end(); i++)

  127. 	{

  128. 		m_Browser->add(i->Name.c_str());

  129. 

  130. 		unsigned int dsize = m_Browser->size() - size;

  131. 		int ddepth = i->Depth - depth;

  132. 

  133. 		size = m_Browser->size();

  134. 		depth = i->Depth;

  135. 

  136. 	// Add blanks to ID Lookup vector to account for sub-menus

  137. 		for (unsigned long j = 1; j < (dsize - ddepth); j++) {

  138. 			m_PluginIDLookup.push_back(0);

  139. 		}

  140. 	// Add to ID Lookup vector (this maps Menu Items to Unique IDs)

  141. 		m_PluginIDLookup.push_back(i->UniqueID);

  142. 	}

  143. 

  144. 	m_Browser->value(0);

  145. 

  146. 	m_SetupGroup->add(m_Browser);

  147. 

  148. 	m_InputScroll = new Fl_Scroll(10,135,480,145);

  149. 	m_InputScroll->box(m_GUIBox);

  150. 	m_InputScroll->color((Fl_Color)Info->GUICOL_Device);

  151. 	m_InputScroll->labelsize(12);

  152. 	m_InputScroll->align(FL_ALIGN_TOP_LEFT);

  153. 	m_InputScroll->type(Fl_Scroll::VERTICAL);

  154. 

  155. 	m_InputPack = new Fl_Pack(15,140,470,135,"");

  156. 	m_InputPack->color((Fl_Color)Info->GUICOL_Device);

  157. 	m_InputScroll->add(m_InputPack);

  158. 

  159. 	m_SetupGroup->add(m_InputScroll);

  160. 

  161. 	m_ValueLabel = new Fl_Box(15,120,60,15,"Value");

  162. 	m_ValueLabel->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  163. 	m_ValueLabel->labelsize(12);

  164. 	m_SetupGroup->add(m_ValueLabel);

  165. 

  166. 	m_DefaultLabel = new Fl_Box(77,120,60,15,"Default");

  167. 	m_DefaultLabel->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  168. 	m_DefaultLabel->labelsize(12);

  169. 	m_SetupGroup->add(m_DefaultLabel);

  170. 

  171. 	m_MinLabel = new Fl_Box(139,120,60,15,"Min");

  172. 	m_MinLabel->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  173. 	m_MinLabel->labelsize(12);

  174. 	m_SetupGroup->add(m_MinLabel);

  175. 

  176. 	m_MaxLabel = new Fl_Box(201,120,60,15,"Max");

  177. 	m_MaxLabel->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  178. 	m_MaxLabel->labelsize(12);

  179. 	m_SetupGroup->add(m_MaxLabel);

  180. 

  181. 	m_ClampLabel = new Fl_Box(275,120,10,15,"Clamp?");

  182. 	m_ClampLabel->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  183. 	m_ClampLabel->labelsize(12);

  184. 	m_SetupGroup->add(m_ClampLabel);

  185. 

  186. 	m_PortLabel = new Fl_Box(335,120,60,15,"Port Name");

  187. 	m_PortLabel->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  188. 	m_PortLabel->labelsize(12);

  189. 	m_SetupGroup->add(m_PortLabel);

  190. 

  191. 	m_UpdateInputs = new Fl_LED_Button (10, 282, 25, 25, "Update input values?");

  192. 	m_UpdateInputs->labelsize(12);

  193. 	m_UpdateInputs->value(true);

  194. 	m_UpdateInputs->callback((Fl_Callback *)cb_UpdateInputs);

  195. 

  196. 	m_SetupGroup->add(m_UpdateInputs);

  197. 

  198. 	add(m_SetupGroup);

  199. 

  200. 	m_PortIndex = 0;

  201. 

  202. 	SetPage(2);

  203. 

  204. 	end();

  205. }

  206. 

  207. LADSPAPluginGUI::~LADSPAPluginGUI(void)

  208. {

  209. 	if (m_InputPortNames)    free(m_InputPortNames);

  210. 	if (m_InputPortSettings) free(m_InputPortSettings);

  211. 	if (m_InputPortValues)   free(m_InputPortValues);

  212. 	if (m_InputPortDefaults) free(m_InputPortDefaults);

  213. 

  214. 	m_PluginIDLookup.clear();

  215. 

  216. 	Fl::check();

  217. }

  218. 

  219. // This is done all the time

  220. void LADSPAPluginGUI::Update(void)

  221. {

  222. 	char temp[256];

  223. 	bool state_changed = false;

  224. 

  225. 	m_GUICH->GetData("GetInputPortCount", &(m_InputPortCount));

  226. 	m_GUICH->GetData("GetInputPortValues", m_InputPortValues);

  227. 	m_GUICH->GetData("GetInputPortDefaults", m_InputPortDefaults);

  228. 

  229. // Need to show that a connection is present

  230. // regardless of Refresh being set

  231. 	for (unsigned long p = 0; p < m_InputPortCount; p++) {

  232. 	// Check if plugin connect state is different to GUI state

  233. 	// A readonly default implies connection

  234. 		if ((m_InputPortValues[p].Connected &&

  235. 		     !(m_PortDefault[p]->readonly())) ||

  236. 		    (m_PortDefault[p]->readonly() &&

  237. 		     !(m_InputPortValues[p].Connected))) {

  238. 			if (m_InputPortValues[p].Connected) {

  239. 			// Disable

  240. 				m_PortDefault[p]->readonly(1);

  241. 				m_PortDefault[p]->color(FL_BACKGROUND_COLOR);

  242. 			} else {

  243. 			// Enable

  244. 				m_PortDefault[p]->readonly(0);

  245. 				m_PortDefault[p]->color(FL_BACKGROUND2_COLOR);

  246. 			// Update knob and slider inputs to new value

  247. 				sprintf(temp,"%.4f", m_InputPortDefaults[p]);

  248. 				m_KnobDefaults[p]->value(temp);

  249. 				m_SliderDefaults[p]->value(temp);

  250. 			}

  251. 

  252. 			sprintf(temp,"%.4f", m_InputPortDefaults[p]);

  253. 			m_PortDefault[p]->value(temp);

  254. 

  255. 			SetControlValue(p, BOTH);

  256. 

  257. 			state_changed = true;

  258. 		}

  259. 

  260. 	// Only update values if Refresh is set

  261. 		if (m_UpdateInputs->value()) {

  262. 			sprintf(temp,"%.4f", m_InputPortValues[p].Value);

  263. 			m_PortValue[p]->value(temp);

  264. 

  265. 			if (m_InputPortValues[p].Connected) {

  266. 				sprintf(temp,"%.4f", m_InputPortDefaults[p]);

  267. 				m_PortDefault[p]->value(temp);

  268. 			}

  269. 		}

  270. 	}

  271. 

  272. // If a connection has been added/removed, we need to

  273. // rearrange the knobs

  274. 	if (state_changed) {

  275. 	// Count the unconnected ports

  276. 		m_UnconnectedInputs = 0;

  277. 		for (unsigned long p = 0; p < m_InputPortCount; p++) {

  278. 			if (!(m_InputPortValues[p].Connected)) m_UnconnectedInputs++;

  279. 		}

  280. 		UpdateKnobs();

  281. 		UpdateSliders();

  282. 

  283. 		m_BKnob->resize(x()+5, y()+15, 50, 20);

  284. 		m_BSlider->resize(x()+60, y()+15, 50, 20);

  285. 		m_BSetup->resize(x() + w() - 55, y()+15, 50, 20);

  286. 	}

  287. }

  288. 

  289. // This lot is only done on patch load

  290. void LADSPAPluginGUI::UpdateValues(SpiralPlugin *o)

  291. {

  292. 	LADSPAPlugin* Plugin = (LADSPAPlugin*)o;

  293. 	SetUniqueID(Plugin->GetUniqueID());

  294. 	SetName(Plugin->GetName());

  295. 	SetMaker(Plugin->GetMaker());

  296. 	SetUpdateInputs(Plugin->GetUpdateInputs());

  297. 	m_InputPortCount = Plugin->GetInputPortCount();

  298. 

  299. 	m_UnconnectedInputs = Plugin->GetUnconnectedInputs();

  300. 

  301. 	const char *name;

  302. 

  303. 	for (unsigned long p = 0; p < m_InputPortCount; p++) {

  304. 		name = Plugin->GetInputPortName(p);

  305. 		strncpy((char *)(m_InputPortNames + p * 256), name, 256);

  306. 

  307. 		m_InputPortSettings[p] = Plugin->GetInputPortSetting(p);

  308. 		m_InputPortDefaults[p] = Plugin->GetInputPortDefault(p);

  309. 		m_InputPortValues[p] = Plugin->GetInputPortValue(p);

  310. 

  311. 		AddPortInfo(p);

  312. 		SetPortSettings(p);

  313. 		SetControlValue(p, BOTH);

  314. 	}

  315. 

  316. 	SetPage(Plugin->GetPage());

  317. 

  318. 	m_PortIndex = m_InputPortCount;

  319. }

  320. 

  321. // ****************************************************************************

  322. // **                    Protected Member Functions                          **

  323. // ****************************************************************************

  324. 

  325. const string LADSPAPluginGUI::GetHelpText(const string &loc)

  326. {

  327. //	if (loc == "DE") {

  328. //	} else if (loc == "FR") {

  329. //	} else {

  330. 	// Default to English?

  331. 		return string("LADSPA Plugin\n")

  332. 		            + "\n"

  333. 		            + "This plugin allows you to use any LADSPA plugin in SSM.\n"

  334. 		            + "\n"

  335. 		            + "It grows or shrinks the device GUI to allow you to connect\n"

  336. 		            + "up the ports as any other native SSM plugin, so you can\n"

  337. 		            + "seamlessly use the plugins as part of your layouts.\n"

  338. 		            + "\n"

  339. 		            + "The GUI window has two tabbed sections, Control and Setup.\n"

  340. 		            + "\n"

  341. 		            + "Setup is used to choose which LADSPA plugin to use, and\n"

  342. 		            + "allows you to configure port information.\n"

  343. 		            + "\n"

  344. 		            + "Once you have chosen a plugin, a row will appear for each\n"

  345. 		            + "input port:\n"

  346. 		            + "\n"

  347. 		            + "Value\n"

  348. 		            + "    The value being input to the port from a connection.\n"

  349. 		            + "Default\n"

  350. 		            + "    The value used as input if there is no connection. If\n"

  351. 		            + "    the port is connected, the default will use the value.\n"

  352. 		            + "    Upon disconnection, it will retain the last value\n"

  353. 		            + "    received.\n"

  354. 		            + "Min, Max\n"

  355. 		            + "    The range of values to scale a connected signal to,\n"

  356. 		            + "    assuming the signal is in the range -1.0 to +1.0.\n"

  357. 		            + "Clamp\n"

  358. 		            + "    Whether to scale inputs - if unchecked, the input is\n"

  359. 		            + "    not scaled.\n"

  360. 		            + "Port Name\n"

  361. 		            + "    The name of the port, as supplied by the plugin.\n"

  362. 		            + "\n"

  363. 		            + "The Control tab will display a control knob for each port\n"

  364. 		            + "that is not connected. This allows adjustment of input\n"

  365. 		            + "directly.";

  366. //	}

  367. }

  368. 

  369. // ****************************************************************************

  370. // **                      Private Member Functions                          **

  371. // ****************************************************************************

  372. 

  373. // Clear plugin selection and all related stuff

  374. void LADSPAPluginGUI::ClearPlugin(void)

  375. {

  376. 	m_InputPortCount = 0;

  377. 	m_UnconnectedInputs = 0;

  378. 	m_PortIndex = 0;

  379. 

  380. 	m_GUICH->SetCommand(LADSPAPlugin::CLEARPLUGIN);

  381. 	m_GUICH->Wait();

  382. 

  383. // Clear out setup scroll

  384. 	while (m_InputPack->children() > 0) {

  385. 		Fl_Group *g = (Fl_Group *)m_InputPack->child(0);

  386. 		while (g->children() > 0) {

  387. 			Fl_Widget *w = g->child(0);

  388. 			g->remove(w);

  389. 		}

  390. 		m_InputPack->remove(g);

  391. 		delete g;

  392. 	}

  393. 

  394. // Clear out Knob and Slider groups

  395. 	while (m_KnobGroup->children() > 0) m_KnobGroup->remove(m_KnobGroup->child(0));

  396. 	while (m_SliderGroup->children() > 0) m_SliderGroup->remove(m_SliderGroup->child(0));

  397. 

  398. // Clear out all port widgets

  399. 	for (vector<Fl_Output *>::iterator i = m_PortValue.begin(); i != m_PortValue.end(); i++) delete *i;

  400. 	m_PortValue.clear();

  401. 	for (vector<Fl_Input *>::iterator i = m_PortMin.begin(); i != m_PortMin.end(); i++) delete *i;

  402. 	m_PortMin.clear();

  403. 	for (vector<Fl_Input *>::iterator i = m_PortMax.begin(); i != m_PortMax.end(); i++) delete *i;

  404. 	m_PortMax.clear();

  405. 	for (vector<Fl_Check_Button *>::iterator i = m_PortClamp.begin(); i != m_PortClamp.end(); i++) delete *i;

  406. 	m_PortClamp.clear();

  407. 	for (vector<Fl_Input *>::iterator i = m_PortDefault.begin(); i != m_PortDefault.end(); i++) delete *i;

  408. 	m_PortDefault.clear();

  409. 	for (vector<Fl_Knob *>::iterator i = m_Knobs.begin(); i != m_Knobs.end(); i++) delete *i;

  410. 	m_Knobs.clear();

  411. 	for (vector<Fl_Slider *>::iterator i = m_Sliders.begin(); i != m_Sliders.end(); i++) delete *i;

  412. 	m_Sliders.clear();

  413. 	for (vector<Fl_Input *>::iterator i = m_KnobDefaults.begin(); i != m_KnobDefaults.end(); i++) delete *i;

  414. 	m_KnobDefaults.clear();

  415. 	for (vector<Fl_Input *>::iterator i = m_SliderDefaults.begin(); i != m_SliderDefaults.end(); i++) delete *i;

  416. 	m_SliderDefaults.clear();

  417. 	for (vector<Fl_Box *>::iterator i = m_KnobLabels.begin(); i != m_KnobLabels.end(); i++) delete *i;

  418. 	m_KnobLabels.clear();

  419. 	for (vector<Fl_Box *>::iterator i = m_SliderLabels.begin(); i != m_SliderLabels.end(); i++) delete *i;

  420. 	m_SliderLabels.clear();

  421. 

  422. // Free label buffers

  423. 	for (vector<char *>::iterator i = m_KnobLabelBuffers.begin(); i != m_KnobLabelBuffers.end(); i++) {

  424. 		if (*i) free (*i);

  425. 	}

  426. 	m_KnobLabelBuffers.clear();

  427. 	for (vector<char *>::iterator i = m_SliderLabelBuffers.begin(); i != m_SliderLabelBuffers.end(); i++) {

  428. 		if (*i) free (*i);

  429. 	}

  430. 	m_SliderLabelBuffers.clear();

  431. 

  432. 	m_SetupGroup->redraw();

  433. }

  434. 

  435. // Setup from selected plugin

  436. void LADSPAPluginGUI::SelectPlugin(void)

  437. {

  438. // Now get the new values to populate GUI controls

  439. 	m_GUICH->GetData("GetName", m_Name);

  440. 	m_GUICH->GetData("GetMaker", m_Maker);

  441. 	m_GUICH->GetData("GetInputPortCount", &(m_InputPortCount));

  442. 	m_GUICH->GetData("GetInputPortNames", m_InputPortNames);

  443. 	m_GUICH->GetData("GetInputPortSettings", m_InputPortSettings);

  444. 	m_GUICH->GetData("GetInputPortDefaults", m_InputPortDefaults);

  445. 

  446. 	SetName((const char *)m_Name);

  447. 	SetMaker((const char *)m_Maker);

  448. 

  449. 	for (unsigned long p = 0; p < m_InputPortCount; p++) {

  450. 		AddPortInfo(p);

  451. 		SetPortSettings(p);

  452. 		SetControlValue(p, BOTH);

  453. 	}

  454. 

  455. 	m_PortIndex = m_InputPortCount;

  456. 	m_UnconnectedInputs = m_InputPortCount;

  457. 

  458. 	m_SetupGroup->redraw();

  459. 

  460. }

  461. 

  462. // Change current page (Knobs/Sliders/Setup), resizing window

  463. // to fit the contents

  464. void LADSPAPluginGUI::SetPage(int index)

  465. {

  466. 	m_Page = index;

  467. 

  468. 	switch (m_Page) {

  469. 		case 0:

  470. 		{

  471. 			m_BKnob->value(1);

  472. 			m_BKnob->deactivate();

  473. 			m_BSlider->value(0);

  474. 			m_BSlider->activate();

  475. 			m_BSetup->value(0);

  476. 			m_BSetup->activate();

  477. 

  478. 			m_KnobGroup->show();

  479. 			m_SliderGroup->hide();

  480. 			m_SetupGroup->hide();

  481. 

  482. 			UpdateKnobs();

  483. 			break;

  484. 		}

  485. 		case 1:

  486. 		{

  487. 			m_BKnob->value(0);

  488. 			m_BKnob->activate();

  489. 			m_BSlider->value(1);

  490. 			m_BSlider->deactivate();

  491. 			m_BSetup->value(0);

  492. 			m_BSetup->activate();

  493. 

  494. 			m_KnobGroup->hide();

  495. 			m_SliderGroup->show();

  496. 			m_SetupGroup->hide();

  497. 

  498. 			UpdateSliders();

  499. 			break;

  500. 		}

  501. 		default:

  502. 		{

  503. 			m_BKnob->value(0);

  504. 			m_BKnob->activate();

  505. 			m_BSlider->value(0);

  506. 			m_BSlider->activate();

  507. 			m_BSetup->value(1);

  508. 			m_BSetup->deactivate();

  509. 

  510. 			m_KnobGroup->hide();

  511. 			m_SliderGroup->hide();

  512. 			m_SetupGroup->show();

  513. 

  514. 			Resize(500, 320);

  515. 

  516. 			m_KnobGroup->resize(x()+5, y()+35, w()-10, h()-40);

  517. 			m_SliderGroup->resize(x()+5, y()+35, w()-10, h()-40);

  518. 			m_SetupGroup->resize(x()+5, y()+35, w()-10, h()-40);

  519. 		}

  520. 	}

  521. 

  522. 	m_BKnob->resize(x()+5, y()+15, 50, 20);

  523. 	m_BSlider->resize(x()+60, y()+15, 50, 20);

  524. 	m_BSetup->resize(x() + w() - 55, y()+15, 50, 20);

  525. }

  526. 

  527. void LADSPAPluginGUI::SetUniqueID(unsigned long n)

  528. {

  529. 	m_UniqueID = n;

  530. 

  531. 	vector<unsigned long>::iterator i = std::find(m_PluginIDLookup.begin(), m_PluginIDLookup.end(), m_UniqueID);

  532. 

  533. 	if (i != m_PluginIDLookup.end()) {

  534. 		m_Browser->value(i - m_PluginIDLookup.begin());

  535. 	} else {

  536. 		m_Browser->value(0);

  537. 	}

  538. }

  539. 

  540. void LADSPAPluginGUI::SetName(const char *s)

  541. {

  542. 	m_NameLabel->label(s);

  543. }

  544. 

  545. void LADSPAPluginGUI::SetMaker(const char *s)

  546. {

  547. 	char temp[256];

  548. 	unsigned int len = strlen(s);

  549. 

  550. 	strncpy(temp, s, len);

  551. 	// If this has got an "@" in it FLTK thinks it's a special character not an E.mail address

  552. 	int t=0;

  553. 	for (unsigned int f=0; f<len; f++) {

  554. 		if (t==255) break;

  555. 		if (temp[f]=='@') m_Maker[t++]='@';

  556. 		m_Maker[t++]=temp[f];

  557. 	}

  558. 	m_Maker[t]=0;

  559. 	m_MakerLabel->label (m_Maker);

  560. }

  561. 

  562. void LADSPAPluginGUI::SetPortSettings(unsigned long p)

  563. {

  564. 	char temp[256];

  565. 	sprintf(temp,"%.4f", m_InputPortSettings[p].Min);

  566. 	m_PortMin[p]->value(temp);

  567. 

  568. 	sprintf(temp,"%.4f", m_InputPortSettings[p].Max);

  569. 	m_PortMax[p]->value(temp);

  570. 

  571. 	sprintf(temp, "%d", m_InputPortSettings[p].Clamp);

  572. 	m_PortClamp[p]->value(atoi(temp));

  573. 

  574. 	sprintf(temp, "%.4f", m_InputPortDefaults[p]);

  575. 	m_PortDefault[p]->value(temp);

  576. 	m_KnobDefaults[p]->value(temp);

  577. 	m_SliderDefaults[p]->value(temp);

  578. }

  579. 

  580. void LADSPAPluginGUI::SetUpdateInputs(bool state)

  581. {

  582. 	m_UpdateInputState = state;

  583. 	m_UpdateInputs->value(m_UpdateInputState);

  584. }

  585. 

  586. // Setup all controls (Knob, Slider, Settings) for given port

  587. void LADSPAPluginGUI::AddPortInfo(unsigned long p)

  588. {

  589. 	Fl_Group* NewGroup = new Fl_Group(0,0,460,24,"");

  590. 	NewGroup->box(FL_FLAT_BOX);

  591. 	m_InputPack->add(NewGroup);

  592. 

  593. // Value

  594. 	Fl_Output* NewOutput = new Fl_Output(0,0,60,18,"");

  595. 	NewOutput->box(m_GUIBox);

  596.         NewOutput->value(0);

  597. 	NewOutput->textsize(10);

  598. 	NewOutput->color(FL_BACKGROUND_COLOR);

  599. 	NewOutput->readonly(1);

  600. 	NewGroup->add(NewOutput);

  601. 	m_PortValue.push_back(NewOutput);

  602. 

  603. // Fixed Value/Default

  604. 	Fl_Input* NewInput = new Fl_Input(62,0,60,18,"");

  605. 	NewInput->box(fl_down(m_GUIBox));

  606. 	//NewInput->color(m_GUIColour);

  607. 	NewInput->value(0);

  608. 	NewInput->textsize(10);

  609. 	NewInput->callback((Fl_Callback *)cb_Default);

  610. 	NewGroup->add(NewInput);

  611. 	m_PortDefault.push_back(NewInput);

  612. 

  613. // Min

  614. 	NewInput = new Fl_Input(124,0,60,18,"");

  615. 	NewInput->box(fl_down(m_GUIBox));

  616. 	//NewInput->color(m_GUIColour);

  617. 	NewInput->value(0);

  618. 	NewInput->textsize(10);

  619. 	NewInput->callback((Fl_Callback *)cb_Min);

  620. 	NewGroup->add(NewInput);

  621. 	m_PortMin.push_back(NewInput);

  622. 

  623. // Max

  624. 	NewInput = new Fl_Input(186,0,60,18,"");

  625. 	NewInput->box(fl_down(m_GUIBox));

  626. 	//NewInput->color(m_GUIColour);

  627. 	NewInput->value(0);

  628. 	NewInput->textsize(10);

  629. 	NewInput->callback((Fl_Callback *)cb_Max);

  630. 	NewGroup->add(NewInput);

  631. 	m_PortMax.push_back(NewInput);

  632. 

  633. // Clamp

  634. 	Fl_Check_Button* NewCheckButton = new Fl_Check_Button(255,0,10,18,"");

  635. 	NewCheckButton->value(0);

  636. 	NewCheckButton->callback((Fl_Callback *)cb_Clamp);

  637. 	NewGroup->add(NewCheckButton);

  638. 	m_PortClamp.push_back(NewCheckButton);

  639. 

  640. // Port Name

  641. 	Fl_Box* NewText = new Fl_Box(315,0,10,18,"");

  642. 	NewText->label((const char *)(m_InputPortNames + p * 256));

  643. 	NewText->labelsize(10);

  644. 	NewText->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);

  645. 	NewGroup->add(NewText);

  646. 

  647. 	NewGroup->redraw();

  648. 	m_InputPack->redraw();

  649. 	m_InputScroll->redraw();

  650. 

  651. // Control knobs and sliders - these aren't positoned or displayed yet,

  652. // as this will depend on what is connected. All that is decided in

  653. // UpdateKnobs()

  654. 

  655. // Knob

  656. 	Fl_Knob* NewKnob = new Fl_Knob(0,0,40,40,"");

  657. 	NewKnob->color(m_GUIColour);

  658. 	NewKnob->callback((Fl_Callback *)cb_Knob);

  659. 	NewKnob->hide();

  660. 	m_KnobGroup->add(NewKnob);

  661. 	m_Knobs.push_back(NewKnob);

  662. 

  663. // Direct input box for knob

  664. 	NewInput = new Fl_Input(0,0,60,16);

  665. 	NewInput->box(fl_down(m_GUIBox));

  666. 	//NewInput->color(m_GUIColour);

  667. 	NewInput->value(0);

  668. 	NewInput->textsize(10);

  669. 	NewInput->callback((Fl_Callback *)cb_KnobValue);

  670. 	NewInput->hide();

  671. 	m_KnobGroup->add(NewInput);

  672. 	m_KnobDefaults.push_back(NewInput);

  673. 

  674. // Knob Label

  675. // Get maximum 19 characters (excluding "(AU)"/"(CV)" bit)

  676. 	size_t len = strlen((const char *)(m_InputPortNames + p * 256));

  677. 	len = len > 24 ? 19 : len - 5;

  678. 	char *kl = (char *)malloc(len+1);

  679. 	if (kl) {

  680. 		strncpy(kl, (const char *)(m_InputPortNames + p * 256), len);

  681. 		kl[len] = '\0';

  682. 		m_KnobLabelBuffers.push_back(kl);

  683. 	}

  684. 	NewText = new Fl_Box(0,0,100,12,(const char *)kl);

  685. 	NewText->align(FL_ALIGN_CENTER|FL_ALIGN_CLIP|FL_ALIGN_INSIDE);

  686. 	NewText->labelfont(FL_COURIER);

  687. 	NewText->labelsize(9);

  688. 	NewText->hide();

  689. 	m_KnobGroup->add(NewText);

  690. 	m_KnobLabels.push_back(NewText);

  691. 

  692. // Slider

  693. 	Fl_Slider* NewSlider = new Fl_Slider(0,0,20,100,"");

  694. 	NewSlider->box(fl_down(m_GUIBox));

  695. 	NewSlider->type(FL_VERT_NICE_SLIDER);

  696. 	NewSlider->selection_color(m_GUIColour);

  697. 	NewSlider->callback((Fl_Callback *)cb_Slider);

  698. 	NewSlider->hide();

  699. 	m_SliderGroup->add(NewSlider);

  700. 	m_Sliders.push_back(NewSlider);

  701. 

  702. // Direct input box for slider

  703. 	NewInput = new Fl_Input(0,0,56,16);

  704. 	NewInput->box(fl_down(m_GUIBox));

  705. 	//NewInput->color(m_GUIColour);

  706. 	NewInput->value(0);

  707. 	NewInput->textsize(10);

  708. 	NewInput->callback((Fl_Callback *)cb_SliderValue);

  709. 	NewInput->hide();

  710. 	m_SliderGroup->add(NewInput);

  711. 	m_SliderDefaults.push_back(NewInput);

  712. 

  713. // Slider Label

  714. // Copy and truncate knob label to 11 chars for slider

  715. 	len = len > 11 ? 11 : len;

  716. 	char *sl = (char *)malloc(len+1);

  717. 	if (kl && sl) {

  718. 		strncpy(sl, (const char *)kl, len);

  719. 		sl[len] = '\0';

  720. 		m_SliderLabelBuffers.push_back(sl);

  721. 	}

  722. 	NewText = new Fl_Box(0,0,60,12,(const char *)sl);

  723. 	NewText->align(FL_ALIGN_CENTER|FL_ALIGN_CLIP|FL_ALIGN_INSIDE);

  724. 	NewText->labelfont(FL_COURIER);

  725. 	NewText->labelsize(9);

  726. 	NewText->hide();

  727. 	m_SliderGroup->add(NewText);

  728. 	m_SliderLabels.push_back(NewText);

  729. 

  730. // Set the range values

  731. 	SetControlRange(p, m_InputPortSettings[p].Min, m_InputPortSettings[p].Max);

  732. }

  733. 

  734. // Rearrange knobs depending on connections

  735. // Knobs corresponding to connected ports are hidden,

  736. // the rest are shown

  737. void LADSPAPluginGUI::UpdateKnobs(void)

  738. {

  739. 	float sqrcount = sqrtf((float)m_UnconnectedInputs);

  740. 	float fsqrcount = floorf(sqrcount);

  741. 	float diff = sqrcount - fsqrcount;

  742. 	int cols = (int)fsqrcount;

  743. 	int rows = (int)fsqrcount;

  744. 

  745. 	rows += diff > 0.0f ? 1 : 0;

  746. 	cols += diff > 0.5f ? 1 : 0;

  747. 

  748. 	if (m_Page == 0) {

  749. 	// Size window to fit if current page is showing knobs

  750. 		int width;

  751. 		int height;

  752. 

  753. 		if (m_UnconnectedInputs == 0) {

  754. 		// No knobs - minimal size

  755. 			width = 170;

  756. 			height = 80;

  757. 		} else if (m_UnconnectedInputs < 3) {

  758. 		// Single row for one or two knobs

  759. 			width = 10+m_UnconnectedInputs*100;

  760. 			height = 45+80;

  761. 			width = width < 170 ? 170 : width;

  762. 		} else {

  763. 		// Auto arrange

  764. 			width = 10+cols*100;

  765. 			height = 45+rows*80;

  766. 			width = width < 170 ? 170 : width;

  767. 		}

  768. 		Resize (width, height);

  769. 

  770. 	// Resize all groups to fit

  771. 		m_KnobGroup->resize(x()+5, y()+35, w()-10, h()-40);

  772. 		m_SliderGroup->resize(x()+5, y()+35, w()-10, h()-40);

  773. 		m_SetupGroup->resize(x()+5, y()+35, w()-10, h()-40);

  774. 

  775. 		redraw();

  776. 	}

  777. 

  778. // Add knobs into group

  779. 	int column = 0;

  780. 	int row = 0;

  781. 	for (unsigned long p = 0; p < m_InputPortCount; p++)

  782. 	{

  783. 		if (!m_InputPortValues[p].Connected) {

  784. 			if (m_UnconnectedInputs == 1) {

  785. 			// Single knob - centre

  786. 				m_Knobs[p]->resize(x()+35+30,y()+45,40,40);

  787. 				m_KnobDefaults[p]->resize(x()+35+20,y()+45+40,60,16);

  788. 				m_KnobLabels[p]->resize(x()+5+30,y()+45+55,100,15);

  789. 			} else if (m_UnconnectedInputs == 2) {

  790. 			// Two knobs - put in single row

  791. 				column = row;

  792. 				m_Knobs[p]->resize(x()+35+column*100,y()+45,40,40);

  793. 				m_KnobDefaults[p]->resize(x()+25+column*100,y()+45+40,60,16);

  794. 				m_KnobLabels[p]->resize(x()+5+column*100,y()+45+55,100,15);

  795. 			} else {

  796. 			// Auto arrange

  797. 				m_Knobs[p]->resize(x()+35+column*100, y()+45+row*80,40,40);

  798. 				m_KnobDefaults[p]->resize(x()+25+column*100,y()+45+40+row*80,60,16);

  799. 				m_KnobLabels[p]->resize(x()+5+column*100,y()+45+55+row*80,100,15);

  800. 			}

  801. 

  802. 			if (++column==cols) {

  803. 				column = 0;

  804. 				row++;

  805. 			}

  806. 

  807. 			m_Knobs[p]->show();

  808. 			m_KnobDefaults[p]->show();

  809. 			m_KnobLabels[p]->show();

  810. 		} else {

  811. 			m_Knobs[p]->hide();

  812. 			m_KnobDefaults[p]->hide();

  813. 			m_KnobLabels[p]->hide();

  814. 		}

  815. 	}

  816. }

  817. 

  818. // Rearrange sliders depending on connections

  819. // Sliders corresponding to connected ports are hidden,

  820. // the rest are shown

  821. void LADSPAPluginGUI::UpdateSliders(void)

  822. {

  823. 	int cols;

  824. 	int rows;

  825. 	int fullrows = 0;

  826. 

  827. 	if (m_UnconnectedInputs < 9) {

  828. 		cols = m_UnconnectedInputs;

  829. 		rows = 1;

  830. 		fullrows = 1;

  831. 	} else {

  832. 		float sqrcount = sqrt((float)m_UnconnectedInputs);

  833. 		float aspect;

  834. 		int diff;

  835. 

  836. 		cols = (int)floorf(sqrcount * 2.0f);

  837. 		rows = (int)floorf(sqrcount * 0.5f);

  838. 		aspect = (float)cols / (float)rows;

  839. 		diff = cols * rows - m_UnconnectedInputs;

  840. 

  841. 		if (diff < 0) {

  842. 			if (aspect > 4.0f) {

  843. 				rows++;

  844. 				diff += cols;

  845. 			}

  846. 			if (diff > rows - 1) {

  847. 				cols -= (int)floorf((float)diff / (float)rows);

  848. 			} else if (diff < 0) {

  849. 				cols += (int)ceilf(fabsf((float)diff) / (float)rows);

  850. 			}

  851. 		}

  852. 		fullrows = rows - (cols * rows - m_UnconnectedInputs);

  853. 	}

  854. 

  855. 	if (m_Page == 1) {

  856. 	// Size window to fit if current page is showing sliders

  857. 		int width;

  858. 		int height;

  859. 

  860. 		if (m_UnconnectedInputs == 0) {

  861. 		// No sliders - minimal size

  862. 			width = 170;

  863. 			height = 80;

  864. 		} else if (m_UnconnectedInputs < 3) {

  865. 		// Single row of centred sliders if less than three

  866. 			width = 170;

  867. 			height = 45+140;

  868. 		} else if (m_UnconnectedInputs < 9) {

  869. 		// Single row for up to eight sliders

  870. 			width = 10+m_UnconnectedInputs*60;

  871. 			height = 45+140;

  872. 			width = width < 170 ? 170 : width;

  873. 		} else {

  874. 		// Auto arrange

  875. 			width = 10+cols*60;

  876. 			height = 45+rows*140;

  877. 			width = width < 170 ? 170 : width;

  878. 		}

  879. 		Resize (width, height);

  880. 

  881. 	// Resize all groups to fit

  882. 		m_KnobGroup->resize(x()+5, y()+35, w()-10, h()-40);

  883. 		m_SliderGroup->resize(x()+5, y()+35, w()-10, h()-40);

  884. 		m_SetupGroup->resize(x()+5, y()+35, w()-10, h()-40);

  885. 	}

  886. 

  887. // Add sliders into group

  888. 	int column = 0;

  889. 	int row = 0;

  890. 	for (unsigned long p = 0; p < m_InputPortCount; p++)

  891. 	{

  892. 		if (!m_InputPortValues[p].Connected) {

  893. 			if (m_UnconnectedInputs == 0) {

  894. 			// Nothing

  895. 			} else if (m_UnconnectedInputs < 3) {

  896. 			// Single row of centred sliders if less than three

  897. 			// Width is 170, with 5 pixel 'border'

  898. 				int offset=(160-m_UnconnectedInputs*60)/2;

  899. 				m_Sliders[p]->resize(x()+25+offset+column*60, y()+45,20,100);

  900. 				m_SliderDefaults[p]->resize(x()+7+offset+column*60,y()+45+101,56,16);

  901. 				m_SliderLabels[p]->resize(x()+5+offset+column*60, y()+45+116,60,15);

  902. 			} else {

  903. 			// Arrange as per columns and rows

  904. 				m_Sliders[p]->resize(x()+25+column*60, y()+45+row*140,20,100);

  905. 				m_SliderDefaults[p]->resize(x()+7+column*60,y()+45+101+row*140,56,16);

  906. 				m_SliderLabels[p]->resize(x()+5+column*60, y()+45+116+row*140,60,15);

  907. 			}

  908. 

  909. 			if (++column==(cols - (row < fullrows ? 0 : 1))) {

  910. 				column = 0;

  911. 				row++;

  912. 			}

  913. 			m_Sliders[p]->show();

  914. 			m_SliderDefaults[p]->show();

  915. 			m_SliderLabels[p]->show();

  916. 		} else {

  917. 			m_Sliders[p]->hide();

  918. 			m_SliderDefaults[p]->hide();

  919. 			m_SliderLabels[p]->hide();

  920. 		}

  921. 	}

  922. }

  923. 

  924. // Set value of slider and/or knob (both use the same settings)

  925. void LADSPAPluginGUI::SetControlValue(unsigned long p, WhichControl wc)

  926. {

  927. 	float min = atof(m_PortMin[p]->value());

  928. 	float max = atof(m_PortMax[p]->value());

  929. 	float value = atof(m_PortDefault[p]->value());

  930. 

  931. 	float logbase = m_InputPortSettings[p].LogBase;

  932. 	if (logbase > 1.0f) {

  933. 	// Logarithmic control - requires conversion

  934. 		if (fabsf(value) > logbase) {

  935. 			if (value > 0.0f) {

  936. 				value = logf(value) / logf(logbase);

  937. 			} else {

  938. 				value = -logf(-value) / logf(logbase);

  939. 			}

  940. 		} else {

  941. 			value /= logbase;

  942. 		}

  943. 	}

  944. 

  945. 	if (wc == KNOB   || wc == BOTH) m_Knobs[p]->value(value);

  946. 

  947. // Invert slider value, as sliders are upside down

  948. 	if (wc == SLIDER || wc == BOTH) m_Sliders[p]->value(m_Sliders[p]->maximum() - value + m_Sliders[p]->minimum());

  949. }

  950. 

  951. // Set range of slider and knob (both use the same settings)

  952. void LADSPAPluginGUI::SetControlRange(unsigned long p, float min, float max)

  953. {

  954. 	if (m_InputPortSettings[p].Integer) {

  955. 	// Integer control - integer steps between minimum and maximum

  956. 		min = floorf(min + 0.5f);

  957. 		max = floorf(max + 0.5f);

  958. 

  959. 	// Change steps to map to integers

  960. 		m_Knobs[p]->step(1.0f);

  961. 		m_Knobs[p]->scaleticks((int)(max - min));

  962. 		m_Sliders[p]->step(1.0f / (max - min));

  963. 	} else {

  964. 		float logbase = m_InputPortSettings[p].LogBase;

  965. 		if (logbase > 1.0f) {

  966. 		// Continuous logarithmic control

  967. 			float loglogbase = logf(logbase);

  968. 

  969. 			if (fabsf(min) > logbase) {

  970. 				if (min > logbase) {

  971. 					min = logf(min) / loglogbase;

  972. 				} else {

  973. 					min = -logf(-min) / loglogbase;

  974. 				}

  975. 			} else {

  976. 				min /= logbase;

  977. 			}

  978. 			if (fabsf(max) > logbase) {

  979. 				if (max > logbase) {

  980. 					max = logf(max) / loglogbase;

  981. 				} else {

  982. 					max = -logf(-max) / loglogbase;

  983. 				}

  984. 			} else {

  985. 				max /= logbase;

  986. 			}

  987. 		} else {

  988. 		// Continuous linear control

  989. 		// Same as given min and max

  990. 		}

  991. 

  992. 		m_Knobs[p]->step((max - min) / 10000.0f);

  993. 		m_Sliders[p]->step((max - min) / 10000.0f);

  994. 	}

  995. 

  996. 	m_Knobs[p]->minimum(min);

  997. 	m_Knobs[p]->maximum(max);

  998. 	m_Sliders[p]->minimum(min);

  999. 	m_Sliders[p]->maximum(max);

  1000. }

  1001. 

  1002. // The current value ('Default') can be changed from all three pages

  1003. void LADSPAPluginGUI::SetPortValue(unsigned long p, float value, int frompage)

  1004. {

  1005. 	m_Default = value;

  1006. 	m_Min = atof(m_PortMin[p]->value());

  1007. 	m_Max = atof(m_PortMax[p]->value());

  1008. 

  1009. // Pass current port index

  1010. 	m_GUICH->SetData("SetInputPortIndex", &p);

  1011. 

  1012. // If default is out of [Min, Max] range, stretch range

  1013. 	if (m_Default < m_Min) {

  1014. 		m_PortMin[p]->value(m_PortDefault[p]->value());

  1015. 		m_Min = m_Default;

  1016. 

  1017. 	// Pass new Minimum to plugin

  1018. 		m_GUICH->SetData("SetInputPortMin", &m_Min);

  1019. 		m_GUICH->SetCommand(LADSPAPlugin::SETMAX);

  1020. 		m_GUICH->Wait();

  1021. 

  1022. 	// Reconfigure knob range

  1023. 		SetControlRange(m_PortIndex, m_Min, m_Max);

  1024. 	} else if (m_Default > m_Max) {

  1025. 		m_PortMax[p]->value(m_PortDefault[p]->value());

  1026. 		m_Max = m_Default;

  1027. 

  1028. 	// Pass new Maximum to plugin

  1029. 		m_GUICH->SetData("SetInputPortMax", &m_Max);

  1030. 		m_GUICH->SetCommand(LADSPAPlugin::SETMAX);

  1031. 		m_GUICH->Wait();

  1032. 

  1033. 	// Reconfigure knob and slider range

  1034. 		SetControlRange(p, m_Min, m_Max);

  1035. 	}

  1036. 

  1037. // Pass new default to plugin

  1038. 	m_GUICH->SetData("SetInputPortDefault", &m_Default);

  1039. 	m_GUICH->SetCommand(LADSPAPlugin::SETDEFAULT);

  1040. 

  1041. // Update other two default input boxes

  1042. 	char temp[256];

  1043. 	sprintf(temp, "%.4f", m_Default);

  1044. 

  1045. 	switch (frompage)

  1046. 	{

  1047. 		case 0:

  1048. 		{

  1049. 		// Set from knob page - update slider and setup defaults

  1050. 			m_SliderDefaults[p]->value(temp);

  1051. 			m_PortDefault[p]->value(temp);

  1052. 			break;

  1053. 		}

  1054. 		case 1:

  1055. 		{

  1056. 		// Set from slider page - update knob and setup defaults

  1057. 			m_KnobDefaults[p]->value(temp);

  1058. 			m_PortDefault[p]->value(temp);

  1059. 			break;

  1060. 		}

  1061. 		default:

  1062. 		{

  1063. 		// Set from setup page - update knob and slider defaults

  1064. 			m_KnobDefaults[p]->value(temp);

  1065. 			m_SliderDefaults[p]->value(temp);

  1066. 		}

  1067. 	}

  1068. 

  1069. // Set knob and slider to corresponding position

  1070. 	SetControlValue(p, BOTH);

  1071. }

  1072. 

  1073. // Convert value supplied by a control (knob/slider) to actual

  1074. // value in range

  1075. float LADSPAPluginGUI::ConvertControlValue(unsigned long p, float value)

  1076. {

  1077. 	float logbase = m_InputPortSettings[p].LogBase;

  1078. 	if (logbase > 1.0f) {

  1079. 	// Logarithmic control - convert back to actual value

  1080. 		if (fabsf(value) > 1.0f) {

  1081. 			if (value > 0.0f) {

  1082. 				value = powf(logbase, value);

  1083. 			} else {

  1084. 				value = -powf(logbase, -value);

  1085. 			}

  1086. 		} else {

  1087. 			value *= logbase;

  1088. 		}

  1089. 	}

  1090. 

  1091. 	return value;

  1092. }

  1093. 

  1094. // ****************************************************************************

  1095. // **                     Widget Callback Functions                          **

  1096. // ****************************************************************************

  1097. 

  1098. inline void LADSPAPluginGUI::cb_BKnob_i(Fl_Button* o)

  1099. {

  1100. 	SetPage(0);

  1101. 

  1102. 	m_GUICH->SetData("SetPage", &m_Page);

  1103. 	m_GUICH->SetCommand(LADSPAPlugin::SETPAGE);

  1104. }

  1105. void LADSPAPluginGUI::cb_BKnob(Fl_Button* o)

  1106. {   //                     GUI

  1107. 	((LADSPAPluginGUI*)(o->parent()))->cb_BKnob_i(o);

  1108. }

  1109. 

  1110. inline void LADSPAPluginGUI::cb_BSlider_i(Fl_Button* o)

  1111. {

  1112. 	SetPage(1);

  1113. 

  1114. 	m_GUICH->SetData("SetPage", &m_Page);

  1115. 	m_GUICH->SetCommand(LADSPAPlugin::SETPAGE);

  1116. }

  1117. void LADSPAPluginGUI::cb_BSlider(Fl_Button* o)

  1118. {   //                     GUI

  1119. 	((LADSPAPluginGUI*)(o->parent()))->cb_BSlider_i(o);

  1120. }

  1121. 

  1122. inline void LADSPAPluginGUI::cb_BSetup_i(Fl_Button* o)

  1123. {

  1124. 	SetPage(2);

  1125. 

  1126. 	m_GUICH->SetData("SetPage", &m_Page);

  1127. 	m_GUICH->SetCommand(LADSPAPlugin::SETPAGE);

  1128. }

  1129. void LADSPAPluginGUI::cb_BSetup(Fl_Button* o)

  1130. {   //                     GUI

  1131. 	((LADSPAPluginGUI*)(o->parent()))->cb_BSetup_i(o);

  1132. }

  1133. 

  1134. inline void LADSPAPluginGUI::cb_Select_i(Fl_Choice* o)

  1135. {

  1136. 	ClearPlugin();

  1137. 

  1138. 	unsigned long m_UniqueID = m_PluginIDLookup[o->value()];

  1139. 

  1140. 	if (m_UniqueID != 0) {

  1141. 	// Plugin selected

  1142. 		m_GUICH->SetData("SetUniqueID",&m_UniqueID);

  1143. 		m_GUICH->SetCommand(LADSPAPlugin::SELECTPLUGIN);

  1144. 		m_GUICH->Wait();

  1145. 	}

  1146. 	SelectPlugin();

  1147.         // Make sure GUI frame can fit all the ports

  1148.         Resize (w(), h());

  1149. }

  1150. void LADSPAPluginGUI::cb_Select(Fl_Choice* o)

  1151. {   //                     Group     GUI

  1152. 	((LADSPAPluginGUI*)(o->parent()->parent()))->cb_Select_i(o);

  1153. }

  1154. 

  1155. inline void LADSPAPluginGUI::cb_UpdateInputs_i(Fl_LED_Button* o)

  1156. {

  1157. 	m_UpdateInputState = (bool)(o->value());

  1158. 

  1159. 	m_GUICH->SetData("SetUpdateInputs", &m_UpdateInputState);

  1160. 	m_GUICH->SetCommand(LADSPAPlugin::SETUPDATEINPUTS);

  1161. }

  1162. void LADSPAPluginGUI::cb_UpdateInputs(Fl_LED_Button* o)

  1163. {   //                     Group     GUI

  1164. 	((LADSPAPluginGUI*)(o->parent()->parent()))->cb_UpdateInputs_i(o);

  1165. }

  1166. 

  1167. inline void LADSPAPluginGUI::cb_Default_i(Fl_Input* o)

  1168. {

  1169. // Which Default was changed?

  1170. 	bool do_search = false;

  1171. 	if (m_PortIndex == m_PortDefault.size()) { do_search = true; }

  1172. 	if (!do_search) { do_search = (o != (m_PortDefault[m_PortIndex])) ? true : false; }

  1173. 

  1174. 	if (do_search) {

  1175. 	// Only bother to re-query if it is different from last one changed

  1176. 		vector<Fl_Input *>::iterator i = std::find(m_PortDefault.begin(),

  1177. 		                                           m_PortDefault.end(),

  1178. 		                                           o);

  1179. 		m_PortIndex = distance(m_PortDefault.begin(), i);

  1180. 	}

  1181. 

  1182. 	float value = atof(o->value());

  1183. 	SetPortValue(m_PortIndex, value, 2);

  1184. }

  1185. void LADSPAPluginGUI::cb_Default(Fl_Input* o)

  1186. {   //                  Group        Pack      Scroll    Group     GUI

  1187. 	((LADSPAPluginGUI*)(o->parent()->parent()->parent()->parent()->parent()))->cb_Default_i(o);

  1188. }

  1189. 

  1190. inline void LADSPAPluginGUI::cb_Min_i(Fl_Input* o)

  1191. {

  1192. // Which Min was changed?

  1193. 	bool do_search = false;

  1194. 	if (m_PortIndex == m_PortMin.size()) { do_search = true; }

  1195. 	if (!do_search) { do_search = (o != (m_PortMin[m_PortIndex])) ? true : false; }

  1196. 

  1197. 	if (do_search) {

  1198. 	// Only bother to re-query if it is different from last one changed

  1199. 		vector<Fl_Input *>::iterator i = std::find(m_PortMin.begin(),

  1200. 		                                           m_PortMin.end(),

  1201. 		                                           o);

  1202. 		m_PortIndex = distance(m_PortMin.begin(), i);

  1203. 	}

  1204. 

  1205. // Pass current port index

  1206. 	m_GUICH->SetData("SetInputPortIndex", &m_PortIndex);

  1207. 

  1208. // Check that min is really min and max is really max

  1209. 	m_Min = atof(o->value());

  1210. 	m_Max = atof(m_PortMax[m_PortIndex]->value());

  1211. 

  1212. 	if (m_Min > m_Max) {

  1213. 	// Swap min and max (need to set max as well)

  1214. 		float min = m_Min;

  1215. 		m_Min = m_Max;

  1216. 		m_Max = min;

  1217. 

  1218. 		m_GUICH->SetData("SetInputPortMax", &m_Max);

  1219. 		m_GUICH->SetCommand(LADSPAPlugin::SETMAX);

  1220. 		m_GUICH->Wait();

  1221. 

  1222. 	// Swap displayed min and max

  1223. 		char temp[256];

  1224. 		strncpy(temp, m_PortMin[m_PortIndex]->value(), 256);

  1225. 		m_PortMin[m_PortIndex]->value(m_PortMax[m_PortIndex]->value());

  1226. 		m_PortMax[m_PortIndex]->value(temp);

  1227. 		m_PortMin[m_PortIndex]->redraw();

  1228. 		m_PortMax[m_PortIndex]->redraw();

  1229. 	}

  1230. 	m_GUICH->SetData("SetInputPortMin", &m_Min);

  1231. 	m_GUICH->SetCommand(LADSPAPlugin::SETMIN);

  1232. 

  1233. // Clip default to range

  1234. 	m_Default = atof(m_PortDefault[m_PortIndex]->value());

  1235. 	if (m_Default < m_Min) {

  1236. 		m_Default = m_Min;

  1237. 		m_GUICH->SetData("SetInputPortDefault",&m_Default);

  1238. 

  1239. 		m_GUICH->Wait();

  1240. 		m_GUICH->SetCommand(LADSPAPlugin::SETDEFAULT);

  1241. 

  1242. 	// Print to default input box, and the input boxes on the

  1243. 	// knob and slider pages

  1244. 		char temp[256];

  1245. 		sprintf(temp, "%.4f", m_Default);

  1246. 		m_PortDefault[m_PortIndex]->value(temp);

  1247. 		m_KnobDefaults[m_PortIndex]->value(temp);

  1248. 		m_SliderDefaults[m_PortIndex]->value(temp);

  1249. 	}

  1250. 

  1251. // Reposition and reconfigure knob and slider to reflect new range

  1252. 	SetControlValue(m_PortIndex, BOTH);

  1253. 	SetControlRange(m_PortIndex, m_Min, m_Max);

  1254. }

  1255. void LADSPAPluginGUI::cb_Min(Fl_Input* o)

  1256. {   //                  Group        Pack      Scroll    Group     GUI

  1257. 	((LADSPAPluginGUI*)(o->parent()->parent()->parent()->parent()->parent()))->cb_Min_i(o);

  1258. }

  1259. 

  1260. inline void LADSPAPluginGUI::cb_Max_i(Fl_Input* o)

  1261. {

  1262. // Which Max was changed?

  1263. 	bool do_search = false;

  1264. 	if (m_PortIndex == m_PortMax.size()) { do_search = true; }

  1265. 	if (!do_search) { do_search = (o != (m_PortMax[m_PortIndex])) ? true : false; }

  1266. 

  1267. 	if (do_search) {

  1268. 	// Only bother to re-query if it is different from last one changed

  1269. 		vector<Fl_Input *>::iterator i = std::find(m_PortMax.begin(),

  1270. 		                                           m_PortMax.end(),

  1271. 		                                           o);

  1272. 		m_PortIndex = distance(m_PortMax.begin(), i);

  1273. 	}

  1274. 

  1275. // Pass value to plugin

  1276. 	m_GUICH->SetData("SetInputPortIndex", &m_PortIndex);

  1277. 

  1278. // Check that min is really min and max is really max

  1279. 	m_Max = atof(o->value());

  1280. 	m_Min = atof(m_PortMin[m_PortIndex]->value());

  1281. 

  1282. 	if (m_Min > m_Max) {

  1283. 	// Swap min and max (need to set max as well)

  1284. 		float max = m_Min;

  1285. 		m_Min = m_Max;

  1286. 		m_Max = max;

  1287. 

  1288. 		m_GUICH->SetData("SetInputPortMin", &m_Min);

  1289. 		m_GUICH->SetCommand(LADSPAPlugin::SETMIN);

  1290. 		m_GUICH->Wait();

  1291. 

  1292. 	// Swap displayed min and max

  1293. 		char temp[256];

  1294. 		strncpy(temp, m_PortMax[m_PortIndex]->value(), 256);

  1295. 		m_PortMax[m_PortIndex]->value(m_PortMin[m_PortIndex]->value());

  1296. 		m_PortMin[m_PortIndex]->value(temp);

  1297. 		m_PortMax[m_PortIndex]->redraw();

  1298. 		m_PortMin[m_PortIndex]->redraw();

  1299. 	}

  1300. 

  1301. 	m_GUICH->SetData("SetInputPortMax", &m_Max);

  1302. 	m_GUICH->SetCommand(LADSPAPlugin::SETMAX);

  1303. 

  1304. // Clip default to range

  1305. 	m_Default = atof(m_PortDefault[m_PortIndex]->value());

  1306. 	if (m_Default > m_Max) {

  1307. 		m_Default = m_Max;

  1308. 		m_GUICH->SetData("SetInputPortDefault",&m_Default);

  1309. 

  1310. 		m_GUICH->Wait();

  1311. 		m_GUICH->SetCommand(LADSPAPlugin::SETDEFAULT);

  1312. 

  1313. 	// Print to displayed default

  1314. 		char temp[256];

  1315. 		sprintf(temp, "%.4f", m_Default);

  1316. 		m_PortDefault[m_PortIndex]->value(temp);

  1317. 		m_KnobDefaults[m_PortIndex]->value(temp);

  1318. 		m_SliderDefaults[m_PortIndex]->value(temp);

  1319. 	}

  1320. 

  1321. // Reposition and reconfigure knob to reflect new range

  1322. 	SetControlValue(m_PortIndex, BOTH);

  1323. 	SetControlRange(m_PortIndex, m_Min, m_Max);

  1324. }

  1325. void LADSPAPluginGUI::cb_Max(Fl_Input* o)

  1326. {   //                  Group        Pack      Scroll    Group     GUI

  1327. 	((LADSPAPluginGUI*)(o->parent()->parent()->parent()->parent()->parent()))->cb_Max_i(o);

  1328. }

  1329. 

  1330. inline void LADSPAPluginGUI::cb_Clamp_i(Fl_Check_Button* o)

  1331. {

  1332. // Which Clamp was changed?

  1333. 	bool do_search = false;

  1334. 	if (m_PortIndex == m_PortClamp.size()) { do_search = true; }

  1335. 	if (!do_search) { do_search = (o != (m_PortClamp[m_PortIndex])) ? true : false; }

  1336. 

  1337. 	if (do_search) {

  1338. 	// Only bother to re-query if it is different from last one changed

  1339. 		vector<Fl_Check_Button *>::iterator i = std::find(m_PortClamp.begin(),

  1340. 		                                                  m_PortClamp.end(),

  1341. 		                                                  o);

  1342. 		m_PortIndex = distance(m_PortClamp.begin(), i);

  1343. 	}

  1344. 

  1345. 	m_Clamp = (bool)(o->value());

  1346. 

  1347. // Pass value to plugin

  1348. 	m_GUICH->SetData("SetInputPortIndex", &m_PortIndex);

  1349. 	m_GUICH->SetData("SetInputPortClamp", &m_Clamp);

  1350. 	m_GUICH->SetCommand(LADSPAPlugin::SETCLAMP);

  1351. }

  1352. void LADSPAPluginGUI::cb_Clamp(Fl_Check_Button* o)

  1353. {   //                  Group        Pack      Scroll    Group     GUI

  1354. 	((LADSPAPluginGUI*)(o->parent()->parent()->parent()->parent()->parent()))->cb_Clamp_i(o);

  1355. }

  1356. 

  1357. inline void LADSPAPluginGUI::cb_Knob_i(Fl_Knob *o)

  1358. {

  1359. // First, find which knob is being adjusted

  1360. 	bool do_search = false;

  1361. 	if (m_PortIndex == m_Knobs.size()) { do_search = true; }

  1362. 	if (!do_search) { do_search = (o != (m_Knobs[m_PortIndex])) ? true : false; }

  1363. 

  1364. 	if (do_search) {

  1365. 	// Only bother to re-query knob if it is different from last one adjusted

  1366. 		vector<Fl_Knob *>::iterator i = std::find(m_Knobs.begin(),

  1367. 		                                          m_Knobs.end(),

  1368. 		                                          o);

  1369. 		m_PortIndex = distance(m_Knobs.begin(), i);

  1370. 	}

  1371. 

  1372. // Get value

  1373. 	m_Default = ConvertControlValue(m_PortIndex, o->value());

  1374. 

  1375. // Pass value to plugin

  1376. 	m_GUICH->SetData("SetInputPortIndex", &m_PortIndex);

  1377. 	m_GUICH->SetData("SetInputPortDefault", &m_Default);

  1378. 	m_GUICH->SetCommand(LADSPAPlugin::SETDEFAULT);

  1379. 

  1380. // Copy to Default field in Port Setup list

  1381. 	char temp[256];

  1382. 	sprintf(temp, "%.4f", m_Default);

  1383. 	m_PortDefault[m_PortIndex]->value(temp);

  1384. 	m_KnobDefaults[m_PortIndex]->value(temp);

  1385. 	m_SliderDefaults[m_PortIndex]->value(temp);

  1386. 

  1387. // Set corresponding slider

  1388. 	SetControlValue(m_PortIndex, SLIDER);

  1389. }

  1390. void LADSPAPluginGUI::cb_Knob(Fl_Knob *o)

  1391. {   //                     Group     GUI

  1392. 	((LADSPAPluginGUI*)(o->parent()->parent()))->cb_Knob_i(o);

  1393. }

  1394. 

  1395. inline void LADSPAPluginGUI::cb_KnobValue_i(Fl_Input *o)

  1396. {

  1397. // Which Knob Value was changed?

  1398. 	bool do_search = false;

  1399. 	if (m_PortIndex == m_KnobDefaults.size()) { do_search = true; }

  1400. 	if (!do_search) { do_search = (o != (m_KnobDefaults[m_PortIndex])) ? true : false; }

  1401. 

  1402. 	if (do_search) {

  1403. 	// Only bother to re-query if it is different from last one changed

  1404. 		vector<Fl_Input *>::iterator i = std::find(m_KnobDefaults.begin(),

  1405. 		                                           m_KnobDefaults.end(),

  1406. 		                                           o);

  1407. 		m_PortIndex = distance(m_KnobDefaults.begin(), i);

  1408. 	}

  1409. 

  1410. 	float value = atof(o->value());

  1411. 	SetPortValue(m_PortIndex, value, 0);

  1412. }

  1413. void LADSPAPluginGUI::cb_KnobValue(Fl_Input *o)

  1414. {   //                     Group     GUI

  1415. 	((LADSPAPluginGUI*)(o->parent()->parent()))->cb_KnobValue_i(o);

  1416. }

  1417. 

  1418. inline void LADSPAPluginGUI::cb_Slider_i(Fl_Slider *o)

  1419. {

  1420. // First, find which slider is being adjusted

  1421. 	bool do_search = false;

  1422. 	if (m_PortIndex == m_Sliders.size()) { do_search = true; }

  1423. 	if (!do_search) { do_search = (o != (m_Sliders[m_PortIndex])) ? true : false; }

  1424. 

  1425. 	if (do_search) {

  1426. 	// Only bother to re-query slider if it is different from last one adjusted

  1427. 		vector<Fl_Slider *>::iterator i = std::find(m_Sliders.begin(),

  1428. 		                                            m_Sliders.end(),

  1429. 		                                            o);

  1430. 		m_PortIndex = distance(m_Sliders.begin(), i);

  1431. 	}

  1432. 

  1433. // Get value (Invert it, as sliders are upside down)

  1434. 	m_Default = ConvertControlValue(m_PortIndex, o->maximum() - o->value() + o->minimum());

  1435. 

  1436. // Pass value to plugin

  1437. 	m_GUICH->SetData("SetInputPortIndex", &m_PortIndex);

  1438. 	m_GUICH->SetData("SetInputPortDefault", &m_Default);

  1439. 	m_GUICH->SetCommand(LADSPAPlugin::SETDEFAULT);

  1440. 

  1441. // Copy to Default field in Port Setup list

  1442. 	char temp[256];

  1443. 	sprintf(temp, "%.4f", m_Default);

  1444. 	m_PortDefault[m_PortIndex]->value(temp);

  1445. 	m_KnobDefaults[m_PortIndex]->value(temp);

  1446. 	m_SliderDefaults[m_PortIndex]->value(temp);

  1447. 

  1448. // Set corresponding knob

  1449. 	SetControlValue(m_PortIndex, KNOB);

  1450. }

  1451. void LADSPAPluginGUI::cb_Slider(Fl_Slider *o)

  1452. {   //                     Group     GUI

  1453. 	((LADSPAPluginGUI*)(o->parent()->parent()))->cb_Slider_i(o);

  1454. }

  1455. 

  1456. inline void LADSPAPluginGUI::cb_SliderValue_i(Fl_Input *o)

  1457. {

  1458. // Which Slider Value was changed?

  1459. 	bool do_search = false;

  1460. 	if (m_PortIndex == m_SliderDefaults.size()) { do_search = true; }

  1461. 	if (!do_search) { do_search = (o != (m_SliderDefaults[m_PortIndex])) ? true : false; }

  1462. 

  1463. 	if (do_search) {

  1464. 	// Only bother to re-query if it is different from last one changed

  1465. 		vector<Fl_Input *>::iterator i = std::find(m_SliderDefaults.begin(),

  1466. 		                                           m_SliderDefaults.end(),

  1467. 		                                           o);

  1468. 		m_PortIndex = distance(m_SliderDefaults.begin(), i);

  1469. 	}

  1470. 

  1471. 	float value = atof(o->value());

  1472. 	SetPortValue(m_PortIndex, value, 1);

  1473. }

  1474. void LADSPAPluginGUI::cb_SliderValue(Fl_Input *o)

  1475. {   //                     Group     GUI

  1476. 	((LADSPAPluginGUI*)(o->parent()->parent()))->cb_SliderValue_i(o);

  1477. }