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

370 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. static const float TIMED_SLIDER_MAX = 3.0f;

  24. 

  25. ////////////////////////////////////////////

  26. 

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

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

  29. {

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

  31.         m_Tabs->labelsize (10);

  32.         m_Tabs->box (FL_PLASTIC_DOWN_BOX);

  33.         add (m_Tabs);

  34. 

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

  36.         m_CtlGroup->labelsize (10);

  37.         m_Tabs->add (m_CtlGroup);

  38. 

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

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

  41. 	m_Thresh->type (FL_VERT_NICE_SLIDER);

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

  43.         m_Thresh->box (FL_PLASTIC_DOWN_BOX);

  44.         m_Thresh->labelsize (10);

  45. 	m_Thresh->maximum (1.0);

  46.         m_Thresh->step (0.01);

  47.         m_Thresh->value (0.99f);

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

  49. 	m_CtlGroup->add (m_Thresh);

  50. 

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

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

  53. 	m_Attack->type (FL_VERT_NICE_SLIDER);

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

  55.         m_Attack->box (FL_PLASTIC_DOWN_BOX);

  56.         m_Attack->labelsize (10);

  57. 	m_Attack->maximum (TIMED_SLIDER_MAX);

  58.         m_Attack->step (0.01);

  59.         m_Attack->value (3.0f);

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

  61. 	m_CtlGroup->add (m_Attack);

  62. 

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

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

  65. 	m_Decay->type (FL_VERT_NICE_SLIDER);

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

  67. 	m_Decay->box (FL_PLASTIC_DOWN_BOX);

  68.         m_Decay->labelsize (10);

  69. 	m_Decay->maximum (TIMED_SLIDER_MAX);

  70.         m_Decay->step (0.01);

  71.         m_Decay->value (2.29);

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

  73. 	m_CtlGroup->add (m_Decay);

  74. 

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

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

  77. 	m_Sustain->type (FL_VERT_NICE_SLIDER);

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

  79. 	m_Sustain->box (FL_PLASTIC_DOWN_BOX);

  80.         m_Sustain->labelsize (10);

  81. 	m_Sustain->maximum (1);

  82.         m_Sustain->step (0.01);

  83.         m_Sustain->value (0.0);

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

  85. 	m_CtlGroup->add (m_Sustain);

  86. 

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

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

  89. 	m_Release->type (FL_VERT_NICE_SLIDER);

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

  91. 	m_Release->box (FL_PLASTIC_DOWN_BOX);

  92.         m_Release->labelsize (10);

  93. 	m_Release->maximum (TIMED_SLIDER_MAX);

  94.         m_Release->step (0.01);

  95.         m_Release->value (2.0);

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

  97. 	m_CtlGroup->add (m_Release);

  98. 

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

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

  101. 	m_Volume->type (FL_VERT_NICE_SLIDER);

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

  103. 	m_Volume->box (FL_PLASTIC_DOWN_BOX);

  104.         m_Volume->labelsize (10);

  105. 	m_Volume->maximum (1);

  106.         m_Volume->step (0.01);

  107.         m_Volume->value (0.5f);

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

  109. 	m_CtlGroup->add (m_Volume);

  110. 

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

  112.         m_NumGroup->labelsize (10);

  113.         m_Tabs->add (m_NumGroup);

  114. 

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

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

  117. 	m_NumThresh->type (FL_SIMPLE_COUNTER);

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

  119.         m_NumThresh->box (FL_PLASTIC_UP_BOX);

  120.         m_NumThresh->labelsize (8);

  121. 	m_NumThresh->maximum (100);

  122. 	m_NumThresh->minimum (0);

  123.         m_NumThresh->step (1);

  124.         m_NumThresh->value (1);

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

  126. 	m_NumGroup->add (m_NumThresh);

  127. 

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

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

  130. 	m_NumAttack->type (FL_SIMPLE_COUNTER);

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

  132.         m_NumAttack->box (FL_PLASTIC_UP_BOX);

  133.         m_NumAttack->labelsize (8);

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

  135.         m_NumAttack->minimum (0);

  136.         m_NumAttack->step (0.1);

  137.         m_NumAttack->value (0);

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

  139. 	m_NumGroup->add (m_NumAttack);

  140. 

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

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

  143. 	m_NumDecay->type (FL_SIMPLE_COUNTER);

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

  145. 	m_NumDecay->box (FL_PLASTIC_UP_BOX);

  146.         m_NumDecay->labelsize (8);

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

  148.         m_NumDecay->minimum (0);

  149.         m_NumDecay->step (0.1);

  150.         m_NumDecay->value (0.5);

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

  152. 	m_NumGroup->add (m_NumDecay);

  153. 

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

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

  156. 	m_NumSustain->type (FL_SIMPLE_COUNTER);

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

  158. 	m_NumSustain->box (FL_PLASTIC_UP_BOX);

  159.         m_NumSustain->labelsize (8);

  160.         m_NumSustain->maximum (100);

  161.         m_NumSustain->minimum (0);

  162.         m_NumSustain->step (1);

  163.         m_NumSustain->value (100);

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

  165. 	m_NumGroup->add (m_NumSustain);

  166. 

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

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

  169. 	m_NumRelease->type (FL_SIMPLE_COUNTER);

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

  171. 	m_NumRelease->box (FL_PLASTIC_UP_BOX);

  172.         m_NumRelease->labelsize (8);

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

  174.         m_NumRelease->minimum (0);

  175.         m_NumRelease->step (0.1);

  176.         m_NumRelease->value (1.0);

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

  178. 	m_NumGroup->add (m_NumRelease);

  179. 

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

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

  182. 	m_NumVolume->type (FL_SIMPLE_COUNTER);

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

  184. 	m_NumVolume->box (FL_PLASTIC_UP_BOX);

  185.         m_NumVolume->labelsize (8);

  186.         m_NumVolume->maximum (100);

  187.         m_NumVolume->minimum (0);

  188.         m_NumVolume->step (1);

  189.         m_NumVolume->value (50);

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

  191. 	m_NumGroup->add (m_NumVolume);

  192. 

  193.         end();

  194. }

  195. 

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

  197.      float val;

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

  199. 

  200.      val = Plugin->GetTrigThresh();

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

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

  203. 

  204.      val = Plugin->GetAttack();

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

  206.      m_NumAttack->value (val);

  207. 

  208.      val = Plugin->GetDecay();

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

  210.      m_NumDecay->value (val);

  211. 

  212.      val = Plugin->GetSustain();

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

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

  215. 

  216.      val = Plugin->GetRelease();

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

  218.      m_NumRelease->value (val);

  219. 

  220.      val = Plugin->GetVolume();

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

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

  223. }

  224. 

  225. // Slider Callbacks

  226. 

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

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

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

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

  231. }

  232. 

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

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

  235. }

  236. 

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

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

  239.        val *= val;

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

  241.        m_NumAttack->value (val);

  242. }

  243. 

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

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

  246. }

  247. 

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

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

  250.        val *= val;

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

  252.        m_NumDecay->value (val);

  253. }

  254. 

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

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

  257. }

  258. 

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

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

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

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

  263. }

  264. 

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

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

  267. }

  268. 

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

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

  271.        val *= val;

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

  273.        m_NumRelease->value (val);

  274. }

  275. 

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

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

  278. }

  279. 

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

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

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

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

  284. }

  285. 

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

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

  288. }

  289. 

  290. // Counter Callbacks

  291. 

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

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

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

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

  296. }

  297. 

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

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

  300. }

  301. 

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

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

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

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

  306. }

  307. 

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

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

  310. }

  311. 

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

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

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

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

  316. }

  317. 

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

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

  320. }

  321. 

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

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

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

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

  326. }

  327. 

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

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

  330. }

  331. 

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

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

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

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

  336. }

  337. 

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

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

  340. }

  341. 

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

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

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

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

  346. }

  347. 

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

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

  350. }

  351. 

  352. // Help Text

  353. 

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

  355.     return string("")

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

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

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

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

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

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

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

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

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

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

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

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

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

  369. }