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.
301 Commits
1 Branch
1.8MB
Tree: 119bb352d4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '119bb352d4'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/EnvelopePlugin/EnvelopePluginGUI.C

372 lines
13KB
Raw Blame History 

  1. /*  SpiralPlugin

  2.  *  Copyleft (C) 2000 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 "EnvelopePluginGUI.h"

  20. #include <FL/fl_draw.H>

  21. #include <FL/fl_draw.H>

  22. 

  23. using namespace std;

  24. 

  25. static const float TIMED_SLIDER_MAX = 3.0f;

  26. 

  27. ////////////////////////////////////////////

  28. 

  29. EnvelopePluginGUI::EnvelopePluginGUI(int w, int h,EnvelopePlugin *o,ChannelHandler *ch,const HostInfo *Info) :

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

  31. {

  32.         m_Tabs = new Fl_Tabs (5, 12, 132, 115, "");

  33.         m_Tabs->labelsize (10);

  34.         m_Tabs->box (FL_PLASTIC_DOWN_BOX);

  35.         add (m_Tabs);

  36. 

  37.         m_CtlGroup = new Fl_Group (5, 30, 132, 81, "Controls");

  38.         m_CtlGroup->labelsize (10);

  39.         m_Tabs->add (m_CtlGroup);

  40. 

  41. 	m_Thresh = new Fl_Slider (10, 38, 20, 70, "T");

  42. 	m_Thresh->user_data ((void*)(this));

  43. 	m_Thresh->type (FL_VERT_NICE_SLIDER);

  44. 	m_Thresh->selection_color (Info->GUI_COLOUR);

  45.         m_Thresh->box (FL_PLASTIC_DOWN_BOX);

  46.         m_Thresh->labelsize (10);

  47. 	m_Thresh->maximum (1.0);

  48.         m_Thresh->step (0.0001);

  49.         m_Thresh->value (0.99f);

  50.         m_Thresh->callback ((Fl_Callback*)cb_Thresh);

  51. 	m_CtlGroup->add (m_Thresh);

  52. 

  53. 	m_Attack = new Fl_Slider (30, 38, 20, 70, "A");

  54. 	m_Attack->user_data ((void*)(this));

  55. 	m_Attack->type (FL_VERT_NICE_SLIDER);

  56. 	m_Attack->selection_color (Info->GUI_COLOUR);

  57.         m_Attack->box (FL_PLASTIC_DOWN_BOX);

  58.         m_Attack->labelsize (10);

  59. 	m_Attack->maximum (TIMED_SLIDER_MAX);

  60.         m_Attack->step (0.0001);

  61.         m_Attack->value (3.0f);

  62.         m_Attack->callback ((Fl_Callback*)cb_Attack);

  63. 	m_CtlGroup->add (m_Attack);

  64. 

  65. 	m_Decay = new Fl_Slider (50, 38, 20, 70, "D");

  66. 	m_Decay->user_data ((void*)(this));

  67. 	m_Decay->type (FL_VERT_NICE_SLIDER);

  68. 	m_Decay->selection_color (Info->GUI_COLOUR);

  69. 	m_Decay->box (FL_PLASTIC_DOWN_BOX);

  70.         m_Decay->labelsize (10);

  71. 	m_Decay->maximum (TIMED_SLIDER_MAX);

  72.         m_Decay->step (0.0001);

  73.         m_Decay->value (2.29);

  74.         m_Decay->callback ((Fl_Callback*)cb_Decay);

  75. 	m_CtlGroup->add (m_Decay);

  76. 

  77. 	m_Sustain = new Fl_Slider (70, 38, 20, 70, "S");

  78. 	m_Sustain->user_data ((void*)(this));

  79. 	m_Sustain->type (FL_VERT_NICE_SLIDER);

  80. 	m_Sustain->selection_color (Info->GUI_COLOUR);

  81. 	m_Sustain->box (FL_PLASTIC_DOWN_BOX);

  82.         m_Sustain->labelsize (10);

  83. 	m_Sustain->maximum (1);

  84.         m_Sustain->step (0.0001);

  85.         m_Sustain->value (0.0);

  86.         m_Sustain->callback ((Fl_Callback*)cb_Sustain);

  87. 	m_CtlGroup->add (m_Sustain);

  88. 

  89. 	m_Release = new Fl_Slider (90, 38, 20, 70, "R");

  90. 	m_Release->user_data ((void*)(this));

  91. 	m_Release->type (FL_VERT_NICE_SLIDER);

  92. 	m_Release->selection_color (Info->GUI_COLOUR);

  93. 	m_Release->box (FL_PLASTIC_DOWN_BOX);

  94.         m_Release->labelsize (10);

  95. 	m_Release->maximum (TIMED_SLIDER_MAX);

  96.         m_Release->step (0.0001);

  97.         m_Release->value (2.0);

  98.         m_Release->callback ((Fl_Callback*)cb_Release);

  99. 	m_CtlGroup->add (m_Release);

  100. 

  101. 	m_Volume = new Fl_Slider (110, 38, 20, 70, "V");

  102. 	m_Volume->user_data ((void*)(this));

  103. 	m_Volume->type (FL_VERT_NICE_SLIDER);

  104. 	m_Volume->selection_color (Info->GUI_COLOUR);

  105. 	m_Volume->box (FL_PLASTIC_DOWN_BOX);

  106.         m_Volume->labelsize (10);

  107. 	m_Volume->maximum (1);

  108.         m_Volume->step (0.0001);

  109.         m_Volume->value (0.5f);

  110.         m_Volume->callback ((Fl_Callback*)cb_Volume);

  111. 	m_CtlGroup->add (m_Volume);

  112. 

  113.         m_NumGroup = new Fl_Group (5, 30, 132, 81, "Numbers");

  114.         m_NumGroup->labelsize (10);

  115.         m_Tabs->add (m_NumGroup);

  116. 

  117. 	m_NumThresh = new Fl_Counter (10, 35, 60, 20, "Threshold (%)");

  118. 	m_NumThresh->user_data ((void*)(this));

  119. 	m_NumThresh->type (FL_SIMPLE_COUNTER);

  120. 	m_NumThresh->color (Info->GUI_COLOUR);

  121.         m_NumThresh->box (FL_PLASTIC_UP_BOX);

  122.         m_NumThresh->labelsize (8);

  123. 	m_NumThresh->maximum (100);

  124. 	m_NumThresh->minimum (0);

  125.         m_NumThresh->step (1);

  126.         m_NumThresh->value (1);

  127.         m_NumThresh->callback ((Fl_Callback*)cb_NumThresh);

  128. 	m_NumGroup->add (m_NumThresh);

  129. 

  130.         m_NumAttack = new Fl_Counter (72, 35, 60, 20, "Attack (s)");

  131. 	m_NumAttack->user_data ((void*)(this));

  132. 	m_NumAttack->type (FL_SIMPLE_COUNTER);

  133. 	m_NumAttack->color (Info->GUI_COLOUR);

  134.         m_NumAttack->box (FL_PLASTIC_UP_BOX);

  135.         m_NumAttack->labelsize (8);

  136.         m_NumAttack->maximum (TIMED_SLIDER_MAX * TIMED_SLIDER_MAX);

  137.         m_NumAttack->minimum (0);

  138.         m_NumAttack->step (0.001);

  139.         m_NumAttack->value (0);

  140.         m_NumAttack->callback ((Fl_Callback*)cb_NumAttack);

  141. 	m_NumGroup->add (m_NumAttack);

  142. 

  143. 	m_NumDecay = new Fl_Counter (10, 65, 60, 20, "Decay (s)");

  144. 	m_NumDecay->user_data ((void*)(this));

  145. 	m_NumDecay->type (FL_SIMPLE_COUNTER);

  146. 	m_NumDecay->color (Info->GUI_COLOUR);

  147. 	m_NumDecay->box (FL_PLASTIC_UP_BOX);

  148.         m_NumDecay->labelsize (8);

  149. 	m_NumDecay->maximum (TIMED_SLIDER_MAX * TIMED_SLIDER_MAX);

  150.         m_NumDecay->minimum (0);

  151.         m_NumDecay->step (0.001);

  152.         m_NumDecay->value (0.5);

  153.         m_NumDecay->callback ((Fl_Callback*)cb_NumDecay);

  154. 	m_NumGroup->add (m_NumDecay);

  155. 

  156.         m_NumSustain = new Fl_Counter (72, 65, 60, 20, "Sustain (%)");

  157. 	m_NumSustain->user_data ((void*)(this));

  158. 	m_NumSustain->type (FL_SIMPLE_COUNTER);

  159. 	m_NumSustain->color (Info->GUI_COLOUR);

  160. 	m_NumSustain->box (FL_PLASTIC_UP_BOX);

  161.         m_NumSustain->labelsize (8);

  162.         m_NumSustain->maximum (100);

  163.         m_NumSustain->minimum (0);

  164.         m_NumSustain->step (1);

  165.         m_NumSustain->value (100);

  166.         m_NumSustain->callback ((Fl_Callback*)cb_NumSustain);

  167. 	m_NumGroup->add (m_NumSustain);

  168. 

  169. 	m_NumRelease = new Fl_Counter (10, 95, 60, 20, "Release (s)");

  170. 	m_NumRelease->user_data ((void*)(this));

  171. 	m_NumRelease->type (FL_SIMPLE_COUNTER);

  172. 	m_NumRelease->color (Info->GUI_COLOUR);

  173. 	m_NumRelease->box (FL_PLASTIC_UP_BOX);

  174.         m_NumRelease->labelsize (8);

  175. 	m_NumRelease->maximum (TIMED_SLIDER_MAX * TIMED_SLIDER_MAX);

  176.         m_NumRelease->minimum (0);

  177.         m_NumRelease->step (0.001);

  178.         m_NumRelease->value (1.0);

  179.         m_NumRelease->callback ((Fl_Callback*)cb_NumRelease);

  180. 	m_NumGroup->add (m_NumRelease);

  181. 

  182. 	m_NumVolume = new Fl_Counter (72, 95, 60, 20, "Volume (%)");

  183. 	m_NumVolume->user_data ((void*)(this));

  184. 	m_NumVolume->type (FL_SIMPLE_COUNTER);

  185. 	m_NumVolume->color (Info->GUI_COLOUR);

  186. 	m_NumVolume->box (FL_PLASTIC_UP_BOX);

  187.         m_NumVolume->labelsize (8);

  188.         m_NumVolume->maximum (100);

  189.         m_NumVolume->minimum (0);

  190.         m_NumVolume->step (1);

  191.         m_NumVolume->value (50);

  192.         m_NumVolume->callback ((Fl_Callback*)cb_NumVolume);

  193. 	m_NumGroup->add (m_NumVolume);

  194. 

  195.         end();

  196. }

  197. 

  198. void EnvelopePluginGUI::UpdateValues (SpiralPlugin *o) {

  199.      float val;

  200.      EnvelopePlugin *Plugin = (EnvelopePlugin*)o;

  201. 

  202.      val = Plugin->GetTrigThresh();

  203.      m_Thresh->value (1.0f - val);

  204.      m_NumThresh->value (100 * val);

  205. 

  206.      val = Plugin->GetAttack();

  207.      m_Attack->value (TIMED_SLIDER_MAX - sqrt (val));

  208.      m_NumAttack->value (val);

  209. 

  210.      val = Plugin->GetDecay();

  211.      m_Decay->value (TIMED_SLIDER_MAX - sqrt (val));

  212.      m_NumDecay->value (val);

  213. 

  214.      val = Plugin->GetSustain();

  215.      m_Sustain->value (1.0f - val);

  216.      m_NumSustain->value (100 * val);

  217. 

  218.      val = Plugin->GetRelease();

  219.      m_Release->value (TIMED_SLIDER_MAX - sqrt (val));

  220.      m_NumRelease->value (val);

  221. 

  222.      val = Plugin->GetVolume();

  223.      m_Volume->value (1.0f - val);

  224.      m_NumVolume->value (100 * val);

  225. }

  226. 

  227. // Slider Callbacks

  228. 

  229. inline void EnvelopePluginGUI::cb_Thresh_i (Fl_Slider* o, void* v) {

  230.        float val = (float)(1.0f - o->value());

  231.        m_GUICH->Set ("Trig", val);

  232.        m_NumThresh->value (100 * val);

  233. }

  234. 

  235. void EnvelopePluginGUI::cb_Thresh (Fl_Slider* o, void* v) {

  236.      ((EnvelopePluginGUI*)(o->user_data()))->cb_Thresh_i (o, v);

  237. }

  238. 

  239. inline void EnvelopePluginGUI::cb_Attack_i (Fl_Slider* o, void* v) {

  240.        float val = TIMED_SLIDER_MAX - o->value();

  241.        val *= val;

  242.        m_GUICH->Set ("Attack", val);

  243.        m_NumAttack->value (val);

  244. }

  245. 

  246. void EnvelopePluginGUI::cb_Attack (Fl_Slider* o, void* v) {

  247.      ((EnvelopePluginGUI*)(o->user_data()))->cb_Attack_i (o, v);

  248. }

  249. 

  250. inline void EnvelopePluginGUI::cb_Decay_i (Fl_Slider* o, void* v) {

  251.        float val = TIMED_SLIDER_MAX - o->value();

  252.        val *= val;

  253.        m_GUICH->Set ("Decay", val);

  254.        m_NumDecay->value (val);

  255. }

  256. 

  257. void EnvelopePluginGUI::cb_Decay (Fl_Slider* o, void* v) {

  258.      ((EnvelopePluginGUI*)(o->user_data()))->cb_Decay_i (o, v);

  259. }

  260. 

  261. inline void EnvelopePluginGUI::cb_Sustain_i (Fl_Slider* o, void* v) {

  262.        float val = (float)(1.0f - o->value());

  263.        m_GUICH->Set ("Sustain", val);

  264.        m_NumSustain->value (100 * val);

  265. }

  266. 

  267. void EnvelopePluginGUI::cb_Sustain (Fl_Slider* o, void* v) {

  268.      ((EnvelopePluginGUI*)(o->user_data()))->cb_Sustain_i (o, v);

  269. }

  270. 

  271. inline void EnvelopePluginGUI::cb_Release_i (Fl_Slider* o, void* v) {

  272.        float val = TIMED_SLIDER_MAX - o->value();

  273.        val *= val;

  274.        m_GUICH->Set ("Release", val);

  275.        m_NumRelease->value (val);

  276. }

  277. 

  278. void EnvelopePluginGUI::cb_Release (Fl_Slider* o, void* v) {

  279.      ((EnvelopePluginGUI*)(o->user_data()))->cb_Release_i (o, v);

  280. }

  281. 

  282. inline void EnvelopePluginGUI::cb_Volume_i (Fl_Slider* o, void* v) {

  283.        float val = (float)(1.0f - o->value());

  284.        m_GUICH->Set ("Volume", val);

  285.        m_NumVolume->value (100 * val);

  286. }

  287. 

  288. void EnvelopePluginGUI::cb_Volume (Fl_Slider* o, void* v) {

  289.      ((EnvelopePluginGUI*)(o->user_data()))->cb_Volume_i (o, v);

  290. }

  291. 

  292. // Counter Callbacks

  293. 

  294. inline void EnvelopePluginGUI::cb_NumThresh_i (Fl_Counter* o, void* v) {

  295.        float val = o->value() / 100;

  296.        m_GUICH->Set ("Trig", val);

  297.        m_Thresh->value (1.0f - val);

  298. }

  299. 

  300. void EnvelopePluginGUI::cb_NumThresh (Fl_Counter* o, void* v) {

  301.      ((EnvelopePluginGUI*)(o->user_data()))->cb_NumThresh_i (o, v);

  302. }

  303. 

  304. inline void EnvelopePluginGUI::cb_NumAttack_i (Fl_Counter* o, void* v) {

  305.        float val = o->value();

  306.        m_GUICH->Set ("Attack", val);

  307.        m_Attack->value (TIMED_SLIDER_MAX - sqrt (val));

  308. }

  309. 

  310. void EnvelopePluginGUI::cb_NumAttack (Fl_Counter* o, void* v) {

  311.      ((EnvelopePluginGUI*)(o->user_data()))->cb_NumAttack_i (o, v);

  312. }

  313. 

  314. inline void EnvelopePluginGUI::cb_NumDecay_i (Fl_Counter* o, void* v) {

  315.        float val = o->value();

  316.        m_GUICH->Set ("Decay", val);

  317.        m_Decay->value (TIMED_SLIDER_MAX - sqrt (val));

  318. }

  319. 

  320. void EnvelopePluginGUI::cb_NumDecay (Fl_Counter* o, void* v) {

  321.      ((EnvelopePluginGUI*)(o->user_data()))->cb_NumDecay_i (o, v);

  322. }

  323. 

  324. inline void EnvelopePluginGUI::cb_NumSustain_i (Fl_Counter* o, void* v) {

  325.        float val = o->value() / 100;

  326.        m_GUICH->Set ("Sustain", val);

  327.        m_Sustain->value (1.0f - val);

  328. }

  329. 

  330. void EnvelopePluginGUI::cb_NumSustain (Fl_Counter* o, void* v) {

  331.      ((EnvelopePluginGUI*)(o->user_data()))->cb_NumSustain_i (o, v);

  332. }

  333. 

  334. inline void EnvelopePluginGUI::cb_NumRelease_i (Fl_Counter* o, void* v) {

  335.        float val = o->value();

  336.        m_GUICH->Set ("Release", val);

  337.        m_Release->value (TIMED_SLIDER_MAX - sqrt (val));

  338. }

  339. 

  340. void EnvelopePluginGUI::cb_NumRelease (Fl_Counter* o, void* v) {

  341.      ((EnvelopePluginGUI*)(o->user_data()))->cb_NumRelease_i (o, v);

  342. }

  343. 

  344. inline void EnvelopePluginGUI::cb_NumVolume_i (Fl_Counter* o, void* v) {

  345.        float val = o->value() / 100;

  346.        m_GUICH->Set ("Volume", val);

  347.        m_Volume->value (1.0f - val);

  348. }

  349. 

  350. void EnvelopePluginGUI::cb_NumVolume (Fl_Counter* o, void* v) {

  351.      ((EnvelopePluginGUI*)(o->user_data()))->cb_NumVolume_i (o, v);

  352. }

  353. 

  354. // Help Text

  355. 

  356. const string EnvelopePluginGUI::GetHelpText (const string &loc) {

  357.     return string("")

  358.     + "An ADSR envelope. This plugin also has a built in\n"

  359.     + "amplifier for signals, so data fed through the Input\n"

  360.     + "and Output are amplified according to the envelope value.\n"

  361.     + "The envelope is triggered with an input CV, and the output\n"

  362.     + "CV is the value of the envelope at that time. The signal\n"

  363.     + "level needed to trigger the envelope can be set using\n"

  364.     + "the \"T\" slider, also the volume level of the output can\n"

  365.     + "be set with the \"V\" slider.\n\n"

  366.     + "This envelope can be used to mimic audio triggered effects\n"

  367.     + "units, by feeding the audio signal into the trigger CV.\n"

  368.     + "In fact, the envelope plugin itself can be made into a\n"

  369.     + "compressor, by feeding the audio signal into both inputs,\n"

  370.     + "and tweaking the ADSR values. \n";

  371. }