falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
639 Commits
2 Branches
31MB
Tree: e8783f4db4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e8783f4db4'
${ noResults }
Cadence/c++/carla-backend/plugins/zynaddsubfx/UI/EnvelopeUI.fl

877 lines
25KB
Raw Blame History 

  1. # data file for the Fltk User Interface Designer (fluid)

  2. version 1.0300 

  3. header_name {.h} 

  4. code_name {.cc}

  5. decl {//Copyright (c) 2002-2005 Nasca Octavian Paul} {private local

  6. } 

  7. 

  8. decl {//License: GNU GPL version 2 or later} {private local

  9. } 

  10. 

  11. decl {\#include "WidgetPDial.h"} {public local

  12. } 

  13. 

  14. decl {\#include <stdio.h>} {public local

  15. } 

  16. 

  17. decl {\#include <stdlib.h>} {public local

  18. } 

  19. 

  20. decl {\#include "../globals.h"} {public local

  21. } 

  22. 

  23. decl {\#include <FL/Fl_Group.H>} {public local

  24. } 

  25. 

  26. decl {\#include "../Params/EnvelopeParams.h"} {public local

  27. } 

  28. 

  29. decl {\#include <FL/Fl_Box.H>} {public local

  30. } 

  31. 

  32. decl {\#include <FL/fl_draw.H>} {public local

  33. } 

  34. 

  35. decl {\#include <FL/fl_ask.H>} {public local

  36. } 

  37. 

  38. decl {\#include "PresetsUI.h"} {public local

  39. } 

  40. 

  41. decl {\#include "common.H"} {public local

  42. } 

  43. 

  44. class EnvelopeFreeEdit {: {public Fl_Box}

  45. } {

  46.   Function {EnvelopeFreeEdit(int x,int y, int w, int h, const char *label=0):Fl_Box(x,y,w,h,label)} {} {

  47.     code {env=NULL;

  48. pair=NULL;} {}

  49.   }

  50.   Function {init(EnvelopeParams *env_)} {} {

  51.     code {env=env_;

  52. oldx=-1;

  53. currentpoint=-1;

  54. cpx=0;

  55. lastpoint=-1;} {}

  56.   }

  57.   Function {setpair(Fl_Box *pair_)} {} {

  58.     code {pair=pair_;} {}

  59.   }

  60.   Function {getpointx(int n)} {return_type int

  61.   } {

  62.     code {int lx=w()-10;

  63. int npoints=env->Penvpoints;

  64. 

  65. float  sum=0;

  66. for (int i=1;i<npoints;i++) sum+=env->getdt(i)+1;

  67. 

  68. float sumbefore=0;//the sum of all points before the computed point

  69. for (int i=1;i<=n;i++) sumbefore+=env->getdt(i)+1;

  70. 

  71. return((int) (sumbefore/(float) sum*lx));} {}

  72.   }

  73.   Function {getpointy(int n)} {return_type int

  74.   } {

  75.     code {int ly=h()-10;

  76. 

  77. return((int) ((1.0-env->Penvval[n]/127.0)*ly));} {}

  78.   }

  79.   Function {getnearest(int x,int y)} {return_type int

  80.   } {

  81.     code {x-=5;y-=5;

  82. 

  83. int nearestpoint=0;

  84. int nearestval=1000000;//a big value

  85. for (int i=0;i<env->Penvpoints;i++){

  86.    int distance=abs(x-getpointx(i))+abs(y-getpointy(i));

  87.    if (distance<nearestval) {

  88.      nearestpoint=i;

  89.      nearestval=distance;  

  90.    };

  91. };

  92. return(nearestpoint);} {}

  93.   }

  94.   Function {draw()} {private

  95.   } {

  96.     code {int ox=x(),oy=y(),lx=w(),ly=h();

  97. if (env->Pfreemode==0) env->converttofree();

  98. int npoints=env->Penvpoints;

  99. 

  100. if (active_r()) fl_color(FL_BLACK);

  101.     else fl_color(90,90,90);

  102. if (!active_r()) currentpoint=-1;

  103. 

  104. fl_rectf(ox,oy,lx,ly);

  105. 

  106. ox+=5;oy+=5;lx-=10;ly-=10;

  107. 

  108. //draw the lines

  109. fl_color(FL_GRAY);

  110. 

  111. fl_line_style(FL_SOLID);

  112. fl_line(ox+2,oy+ly/2,ox+lx-2,oy+ly/2);

  113. 

  114. //draws the evelope points and lines

  115. Fl_Color alb=FL_WHITE;

  116. if (!active_r()) alb=fl_rgb_color(180,180,180);

  117. fl_color(alb);

  118. int oldxx=0,xx=0,oldyy=0,yy=getpointy(0);

  119. fl_rectf(ox-3,oy+yy-3,6,6);

  120. for (int i=1;i<npoints;i++){

  121.     oldxx=xx;oldyy=yy;

  122.     xx=getpointx(i);yy=getpointy(i);

  123.     if (i==currentpoint) fl_color(FL_RED);

  124.         else fl_color(alb);

  125.     fl_line(ox+oldxx,oy+oldyy,ox+xx,oy+yy);

  126.     fl_rectf(ox+xx-3,oy+yy-3,6,6);

  127. };

  128. 

  129. //draw the last moved point point (if exists)

  130. if (lastpoint>=0){

  131.     fl_color(FL_CYAN);

  132.     fl_rectf(ox+getpointx(lastpoint)-5,oy+getpointy(lastpoint)-5,10,10);

  133. };

  134. 

  135. //draw the sustain position

  136. if (env->Penvsustain>0){

  137.     fl_color(FL_YELLOW);

  138.     xx=getpointx(env->Penvsustain);

  139.     fl_line(ox+xx,oy+0,ox+xx,oy+ly);

  140. };

  141. 

  142. //Show the envelope duration and the current line duration

  143. fl_font(FL_HELVETICA|FL_BOLD,10);

  144. float time=0.0;

  145. if (currentpoint<=0){

  146.    fl_color(alb);

  147.    for (int i=1;i<npoints;i++) time+=env->getdt(i);

  148. } else {

  149.    fl_color(255,0,0);

  150.    time=env->getdt(currentpoint);

  151. };

  152. char tmpstr[20];

  153. if (time<1000.0) snprintf((char *)&tmpstr,20,"%.1fms",time);

  154.      else snprintf((char *)&tmpstr,20,"%.2fs",time/1000.0);

  155. fl_draw(tmpstr,ox+lx-20,oy+ly-10,20,10,FL_ALIGN_RIGHT,NULL,0);} {}

  156.   }

  157.   Function {handle(int event)} {return_type int

  158.   } {

  159.     code {int x_=Fl::event_x()-x();

  160. int y_=Fl::event_y()-y();

  161. 

  162. if (event==FL_PUSH) {

  163.   currentpoint=getnearest(x_,y_);

  164.   cpx=x_;

  165.   cpdt=env->Penvdt[currentpoint];

  166.   lastpoint=currentpoint;

  167.   redraw();

  168.   if (pair!=NULL) pair->redraw();

  169. };

  170. 

  171. if (event==FL_RELEASE){

  172.   currentpoint=-1;

  173.   redraw();

  174.   if (pair!=NULL) pair->redraw();

  175. };

  176. 

  177. if ((event==FL_DRAG)&&(currentpoint>=0)){

  178.   int ny=127-(int) (y_*127.0/h());

  179.   if (ny<0) ny=0;if (ny>127) ny=127;

  180.   env->Penvval[currentpoint]=ny;

  181. 

  182.   int dx=(int)((x_-cpx)*0.1);

  183.   int newdt=cpdt+dx;

  184.   if (newdt<0) newdt=0;if (newdt>127) newdt=127;

  185.   if (currentpoint!=0) env->Penvdt[currentpoint]=newdt;

  186.      else env->Penvdt[currentpoint]=0;

  187. 

  188.   redraw();

  189.   if (pair!=NULL) pair->redraw();

  190. };

  191. 

  192. 

  193. return(1);} {}

  194.   }

  195.   decl {Fl_Box *pair;} {private local

  196.   }

  197.   decl {EnvelopeParams *env;} {private local

  198.   }

  199.   decl {int oldx,oldy;} {private local

  200.   }

  201.   decl {int currentpoint,cpx,cpdt;} {private local

  202.   }

  203.   decl {int lastpoint;} {public local

  204.   }

  205. } 

  206. 

  207. class EnvelopeUI {open : {public Fl_Group,PresetsUI_}

  208. } {

  209.   Function {EnvelopeUI(int x,int y, int w, int h, const char *label=0):Fl_Group(x,y,w,h,label)} {} {

  210.     code {env=NULL;

  211. freemodeeditwindow=NULL;

  212. envADSR=NULL;

  213. envASR=NULL;

  214. envADSRfilter=NULL;

  215. envASRbw=NULL;

  216. envfree=NULL;} {}

  217.   }

  218.   Function {~EnvelopeUI()} {} {

  219.     code {envwindow->hide();

  220. hide();

  221. freemodeeditwindow->hide();

  222. delete (freemodeeditwindow);} {}

  223.   }

  224.   Function {make_freemode_edit_window()} {open

  225.   } {

  226.     Fl_Window freemodeeditwindow {

  227.       label Envelope

  228.       xywh {948 246 575 180} type Double visible

  229.     } {

  230.       Fl_Box freeedit {

  231.         label Envelope

  232.         xywh {5 5 565 145} box FLAT_BOX color 0

  233.         code0 {o->init(env);}

  234.         class EnvelopeFreeEdit

  235.       }

  236.       Fl_Button addpoint {

  237.         label {Add point}

  238.         callback {int curpoint=freeedit->lastpoint;

  239. if (curpoint<0) return;

  240. //if (curpoint>=env->Penvpoints-1) return;

  241. if (env->Penvpoints>=MAX_ENVELOPE_POINTS) return;

  242. 

  243. for (int i=env->Penvpoints;i>=curpoint+1;i--){

  244.    env->Penvdt[i]=env->Penvdt[i-1];

  245.    env->Penvval[i]=env->Penvval[i-1];

  246. };

  247. 

  248. if (curpoint==0) {

  249.   env->Penvdt[1]=64;

  250. };

  251. 

  252. env->Penvpoints++;

  253. if (curpoint<=env->Penvsustain) env->Penvsustain++;

  254. 

  255. freeedit->lastpoint+=1;

  256. freeedit->redraw();

  257. envfree->redraw();

  258. 

  259. sustaincounter->value(env->Penvsustain);

  260. sustaincounter->maximum(env->Penvpoints-2);}

  261.         xywh {115 155 80 20} box THIN_UP_BOX labelsize 11

  262.         code0 {if (env->Pfreemode==0) o->hide();}

  263.       }

  264.       Fl_Button deletepoint {

  265.         label {Delete point}

  266.         callback {int curpoint=freeedit->lastpoint;

  267. if (curpoint<1) return;

  268. if (curpoint>=env->Penvpoints-1) return;

  269. if (env->Penvpoints<=3) return;

  270. 

  271. for (int i=curpoint+1;i<env->Penvpoints;i++){

  272.    env->Penvdt[i-1]=env->Penvdt[i];

  273.    env->Penvval[i-1]=env->Penvval[i];

  274. };

  275. 

  276. env->Penvpoints--;

  277. 

  278. if (curpoint<=env->Penvsustain) env->Penvsustain--;

  279. 

  280. 

  281. freeedit->lastpoint-=1;

  282. freeedit->redraw();

  283. envfree->redraw();

  284. 

  285. sustaincounter->value(env->Penvsustain);

  286. sustaincounter->maximum(env->Penvpoints-2);}

  287.         xywh {200 155 80 20} box THIN_UP_BOX labelsize 11

  288.         code0 {if (env->Pfreemode==0) o->hide();}

  289.       }

  290.       Fl_Light_Button freemodebutton {

  291.         label FreeMode

  292.         callback {reinit();

  293. 

  294. freeedit->lastpoint=-1;

  295. freeedit->redraw();}

  296.         tooltip {Enable or disable the freemode} xywh {10 155 95 20} labelsize 11

  297.       }

  298.       Fl_Check_Button forcedreleasecheck {

  299.         label frcR

  300.         callback {env->Pforcedrelease=(int)o->value();}

  301.         tooltip {Forced Relase} xywh {410 165 40 15} down_box DOWN_BOX labelsize 10

  302.         code0 {o->value(env->Pforcedrelease);}

  303.         code1 {if (env->Pfreemode==0) o->hide();}

  304.       }

  305.       Fl_Dial envstretchdial {

  306.         label {Str.}

  307.         callback {env->Penvstretch=(int)o->value();}

  308.         tooltip {Envelope stretch (on lower notes make the envelope longer)} xywh {380 155 25 25} box ROUND_UP_BOX labelsize 10 align 4 maximum 127 step 1

  309.         code0 {o->value(env->Penvstretch);}

  310.         code1 {if (env->Pfreemode==0) o->hide();}

  311.         class WidgetPDial

  312.       }

  313.       Fl_Button {} {

  314.         label Close

  315.         callback {freemodeeditwindow->hide();}

  316.         xywh {510 155 60 20} box THIN_UP_BOX

  317.       }

  318.       Fl_Check_Button linearenvelopecheck {

  319.         label L

  320.         callback {env->Plinearenvelope=(int)o->value();}

  321.         tooltip {Linear Envelope} xywh {410 151 30 15} down_box DOWN_BOX labelsize 10

  322.         code0 {o->value(env->Plinearenvelope);}

  323.         code1 {if ((env->Pfreemode==0)||(env->Envmode>2)) o->hide();}

  324.       }

  325.       Fl_Counter sustaincounter {

  326.         label Sust

  327.         callback {env->Penvsustain=(int) o->value();

  328. freeedit->redraw();

  329. envfree->redraw();}

  330.         tooltip {Sustain (0 is disabled)} xywh {315 155 40 15} type Simple labelsize 11 align 4 minimum 0 maximum 127 step 1

  331.         code0 {o->value(env->Penvsustain);}

  332.         code1 {if (env->Pfreemode==0) o->hide();}

  333.         code2 {o->maximum(env->Penvpoints-2);}

  334.       }

  335.       Fl_Button {} {

  336.         label C

  337.         callback {presetsui->copy(env);}

  338.         xywh {465 160 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  339.       }

  340.       Fl_Button {} {

  341.         label P

  342.         callback {presetsui->paste(env,this);}

  343.         xywh {482 160 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  344.       }

  345.     }

  346.   }

  347.   Function {make_ADSR_window()} {open

  348.   } {

  349.     Fl_Window envADSR {open

  350.       xywh {341 765 205 70} type Double color 50 labelfont 1

  351.       class Fl_Group visible

  352.     } {

  353.       Fl_Group {} {

  354.         label {Amplitude Envelope}

  355.         xywh {0 0 205 70} box UP_BOX color 223 labeltype ENGRAVED_LABEL labelsize 10 align 17

  356.         code0 {set_module_parameters(o);}

  357.       } {

  358.         Fl_Dial e1adt {

  359.           label {A.dt}

  360.           callback {env->PA_dt=(int)o->value();

  361. freeedit->redraw();}

  362.           tooltip {Attack time} xywh {5 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  363.           code0 {o->value(env->PA_dt);}

  364.           class WidgetPDial

  365.         }

  366.         Fl_Dial e1ddt {

  367.           label {D.dt}

  368.           callback {env->PD_dt=(int)o->value();

  369. freeedit->redraw();}

  370.           tooltip {Decay time} xywh {40 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  371.           code0 {o->value(env->PD_dt);}

  372.           class WidgetPDial

  373.         }

  374.         Fl_Dial e1rdt {

  375.           label {R.dt}

  376.           callback {env->PR_dt=(int)o->value();

  377. freeedit->redraw();}

  378.           tooltip {Release time} xywh {110 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  379.           code0 {o->value(env->PR_dt);}

  380.           class WidgetPDial

  381.         }

  382.         Fl_Dial e1sval {

  383.           label {S.val}

  384.           callback {env->PS_val=(int)o->value();

  385. freeedit->redraw();}

  386.           tooltip {Sustain value} xywh {75 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  387.           code0 {o->value(env->PS_val);}

  388.           class WidgetPDial

  389.         }

  390.         Fl_Check_Button e1forcedrelease {

  391.           label frcR

  392.           callback {env->Pforcedrelease=(int)o->value();}

  393.           tooltip {Forced Relase} xywh {180 35 20 15} down_box DOWN_BOX labelsize 10 align 6

  394.           code0 {o->value(env->Pforcedrelease);}

  395.         }

  396.         Fl_Dial e1envstretch {

  397.           label Stretch

  398.           callback {env->Penvstretch=(int)o->value();}

  399.           tooltip {Envelope stretch (on lower notes makes the envelope longer)} xywh {145 25 25 25} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  400.           code0 {o->value(env->Penvstretch);}

  401.           class WidgetPDial

  402.         }

  403.         Fl_Button {} {

  404.           label E

  405.           callback {freemodeeditwindow->show();}

  406.           tooltip {Envelope window} xywh {185 5 15 15} labelfont 1 labelsize 10

  407.         }

  408.         Fl_Check_Button e1linearenvelope {

  409.           label L

  410.           callback {env->Plinearenvelope=(int)o->value();}

  411.           tooltip {The evelope is linear} xywh {180 20 15 15} down_box DOWN_BOX labelsize 10 align 4

  412.           code0 {o->value(env->Plinearenvelope);}

  413.         }

  414.         Fl_Button {} {

  415.           label C

  416.           callback {presetsui->copy(env);}

  417.           xywh {150 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  418.         }

  419.         Fl_Button {} {

  420.           label P

  421.           callback {presetsui->paste(env,this);}

  422.           xywh {167 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  423.         }

  424.       }

  425.     }

  426.   }

  427.   Function {make_ASR_window()} {open

  428.   } {

  429.     Fl_Window envASR {open

  430.       xywh {645 644 210 70} type Double

  431.       class Fl_Group visible

  432.     } {

  433.       Fl_Group {} {

  434.         label {Frequency Envelope}

  435.         xywh {0 0 210 70} box UP_BOX color 223 labeltype ENGRAVED_LABEL labelsize 10 align 17

  436.         code0 {set_module_parameters(o);}

  437.       } {

  438.         Fl_Dial e2aval {

  439.           label {A.val}

  440.           callback {env->PA_val=(int)o->value();

  441. freeedit->redraw();}

  442.           tooltip {Starting value} xywh {5 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  443.           code0 {o->value(env->PA_val);}

  444.           class WidgetPDial

  445.         }

  446.         Fl_Dial e2adt {

  447.           label {A.dt}

  448.           callback {env->PA_dt=(int)o->value();

  449. freeedit->redraw();}

  450.           tooltip {Attack time} xywh {40 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  451.           code0 {o->value(env->PA_dt);}

  452.           class WidgetPDial

  453.         }

  454.         Fl_Dial e2rval {

  455.           label {R.val}

  456.           callback {env->PR_val=(int)o->value();

  457. freeedit->redraw();}

  458.           tooltip {Release value} xywh {110 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  459.           code0 {o->value(env->PR_val);}

  460.           class WidgetPDial

  461.         }

  462.         Fl_Dial e2rdt {

  463.           label {R.dt}

  464.           callback {env->PR_dt=(int)o->value();

  465. freeedit->redraw();}

  466.           tooltip {Release time} xywh {75 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  467.           code0 {o->value(env->PR_dt);}

  468.           class WidgetPDial

  469.         }

  470.         Fl_Dial e2envstretch {

  471.           label Stretch

  472.           callback {env->Penvstretch=(int)o->value();}

  473.           tooltip {Envelope stretch (on lower notes makes the envelope longer)} xywh {145 25 25 25} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  474.           code0 {o->value(env->Penvstretch);}

  475.           class WidgetPDial

  476.         }

  477.         Fl_Check_Button e2forcedrelease {

  478.           label frcR

  479.           callback {env->Pforcedrelease=(int)o->value();}

  480.           tooltip {Forced release} xywh {180 25 15 25} down_box DOWN_BOX labelsize 10 align 6

  481.           code0 {o->value(env->Pforcedrelease);}

  482.         }

  483.         Fl_Button {} {

  484.           label C

  485.           callback {presetsui->copy(env);}

  486.           xywh {155 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  487.         }

  488.         Fl_Button {} {

  489.           label P

  490.           callback {presetsui->paste(env,this);}

  491.           xywh {172 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  492.         }

  493.       }

  494.       Fl_Button {} {

  495.         label E

  496.         callback {freemodeeditwindow->show();}

  497.         tooltip {Envelope window} xywh {190 5 15 15} labelfont 1 labelsize 10

  498.       }

  499.     }

  500.   }

  501.   Function {make_ADSRfilter_window()} {open

  502.   } {

  503.     Fl_Window envADSRfilter {open selected

  504.       xywh {624 546 275 70} type Double color 50 labelfont 1

  505.       class Fl_Group visible

  506.     } {

  507.       Fl_Group {} {

  508.         label {Filter Envelope}

  509.         xywh {0 0 275 70} box UP_BOX color 223 labeltype ENGRAVED_LABEL labelsize 10 align 17

  510.         code0 {set_module_parameters(o);}

  511.       } {

  512.         Fl_Dial e3aval {

  513.           label {A.val}

  514.           callback {env->PA_val=(int)o->value();

  515. freeedit->redraw();}

  516.           tooltip {Starting value} xywh {5 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  517.           code0 {o->value(env->PA_val);}

  518.           class WidgetPDial

  519.         }

  520.         Fl_Dial e3adt {

  521.           label {A.dt}

  522.           callback {env->PA_dt=(int)o->value();

  523. freeedit->redraw();}

  524.           tooltip {Attack time} xywh {40 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  525.           code0 {o->value(env->PA_dt);}

  526.           class WidgetPDial

  527.         }

  528.         Fl_Dial e3dval {

  529.           label {D.val}

  530.           callback {env->PD_val=(int)o->value();

  531. freeedit->redraw();}

  532.           tooltip {decay value} xywh {75 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  533.           code0 {o->value(env->PD_val);}

  534.           class WidgetPDial

  535.         }

  536.         Fl_Dial e3ddt {

  537.           label {D.dt}

  538.           callback {env->PD_dt=(int)o->value();

  539. freeedit->redraw();}

  540.           tooltip {decay time} xywh {110 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  541.           code0 {o->value(env->PD_dt);}

  542.           class WidgetPDial

  543.         }

  544.         Fl_Dial e3rdt {

  545.           label {R.dt}

  546.           callback {env->PR_dt=(int)o->value();

  547. freeedit->redraw();}

  548.           tooltip {Release time} xywh {145 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  549.           code0 {o->value(env->PR_dt);}

  550.           class WidgetPDial

  551.         }

  552.         Fl_Dial e3rval {

  553.           label {R.val}

  554.           callback {env->PR_val=(int)o->value();

  555. freeedit->redraw();}

  556.           tooltip {Release value} xywh {180 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  557.           code0 {o->value(env->PR_val);}

  558.           class WidgetPDial

  559.         }

  560.         Fl_Dial e3envstretch {

  561.           label Stretch

  562.           callback {env->Penvstretch=(int)o->value();}

  563.           tooltip {Envelope stretch (on lower notes makes the envelope longer)} xywh {215 25 25 25} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  564.           code0 {o->value(env->Penvstretch);}

  565.           class WidgetPDial

  566.         }

  567.         Fl_Check_Button e3forcedrelease {

  568.           label frcR

  569.           callback {env->Pforcedrelease=(int)o->value();}

  570.           tooltip {Forced Relase} xywh {250 30 15 20} down_box DOWN_BOX labelsize 10 align 6

  571.           code0 {o->value(env->Pforcedrelease);}

  572.         }

  573.         Fl_Button {} {

  574.           label E

  575.           callback {freemodeeditwindow->show();}

  576.           xywh {255 5 15 15} labelfont 1 labelsize 10

  577.         }

  578.         Fl_Button {} {

  579.           label C

  580.           callback {presetsui->copy(env);}

  581.           xywh {220 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  582.         }

  583.         Fl_Button {} {

  584.           label P

  585.           callback {presetsui->paste(env,this);}

  586.           xywh {237 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  587.         }

  588.       }

  589.     }

  590.   }

  591.   Function {make_ASRbw_window()} {open

  592.   } {

  593.     Fl_Window envASRbw {open

  594.       xywh {359 619 210 71} type Double

  595.       code0 {set_module_parameters(o);}

  596.       class Fl_Group visible

  597.     } {

  598.       Fl_Group {} {

  599.         label {BandWidth Envelope}

  600.         xywh {0 0 210 70} box UP_BOX color 223 labeltype ENGRAVED_LABEL labelsize 10 align 17

  601.         code0 {set_module_parameters(o);}

  602.       } {

  603.         Fl_Dial e4aval {

  604.           label {A.val}

  605.           callback {env->PA_val=(int)o->value();

  606. freeedit->redraw();}

  607.           tooltip {Starting value} xywh {5 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  608.           code0 {o->value(env->PA_val);}

  609.           class WidgetPDial

  610.         }

  611.         Fl_Dial e4adt {

  612.           label {A.dt}

  613.           callback {env->PA_dt=(int)o->value();

  614. freeedit->redraw();}

  615.           tooltip {Attack time} xywh {40 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  616.           code0 {o->value(env->PA_dt);}

  617.           class WidgetPDial

  618.         }

  619.         Fl_Dial e4rval {

  620.           label {R.val}

  621.           callback {env->PR_val=(int)o->value();

  622. freeedit->redraw();}

  623.           tooltip {Release value} xywh {110 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  624.           code0 {o->value(env->PR_val);}

  625.           class WidgetPDial

  626.         }

  627.         Fl_Dial e4rdt {

  628.           label {R.dt}

  629.           callback {env->PR_dt=(int)o->value();

  630. freeedit->redraw();}

  631.           tooltip {Release time} xywh {75 20 30 30} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  632.           code0 {o->value(env->PR_dt);}

  633.           class WidgetPDial

  634.         }

  635.         Fl_Dial e4envstretch {

  636.           label Stretch

  637.           callback {env->Penvstretch=(int)o->value();}

  638.           tooltip {Envelope stretch (on lower notes makes the envelope longer)} xywh {145 25 25 25} box ROUND_UP_BOX labelsize 10 maximum 127 step 1

  639.           code0 {o->value(env->Penvstretch);}

  640.           class WidgetPDial

  641.         }

  642.         Fl_Check_Button e4forcedrelease {

  643.           label frcR

  644.           callback {env->Pforcedrelease=(int)o->value();}

  645.           tooltip {Forced release} xywh {180 25 15 25} down_box DOWN_BOX labelsize 10 align 6

  646.           code0 {o->value(env->Pforcedrelease);}

  647.         }

  648.         Fl_Button {} {

  649.           label C

  650.           callback {presetsui->copy(env);}

  651.           xywh {155 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  652.         }

  653.         Fl_Button {} {

  654.           label P

  655.           callback {presetsui->paste(env,this);}

  656.           xywh {172 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  657.         }

  658.       }

  659.       Fl_Button {} {

  660.         label E

  661.         callback {freemodeeditwindow->show();}

  662.         xywh {190 5 15 15} labelfont 1 labelsize 10

  663.       }

  664.     }

  665.   }

  666.   Function {make_free_window()} {open

  667.   } {

  668.     Fl_Window envfree {open

  669.       xywh {373 413 205 70} type Double color 50 labelfont 1 resizable

  670.       code0 {set_module_parameters(o);}

  671.       class Fl_Group visible

  672.     } {

  673.       Fl_Group envfreegroup {

  674.         label {Amplitude Envelope}

  675.         xywh {0 0 205 70} box UP_BOX color 223 labeltype ENGRAVED_LABEL labelsize 10 align 17 resizable

  676.         code0 {set_module_parameters(o);}

  677.       } {

  678.         Fl_Box freeeditsmall {

  679.           label Envelope

  680.           callback {envfree->redraw();}

  681.           xywh {5 20 195 45} box FLAT_BOX color 0 resizable

  682.           code0 {o->init(env);}

  683.           class EnvelopeFreeEdit

  684.         }

  685.         Fl_Button {} {

  686.           label E

  687.           callback {freemodeeditwindow->show();}

  688.           xywh {185 5 15 15} labelfont 1 labelsize 10

  689.         }

  690.         Fl_Button {} {

  691.           label C

  692.           callback {presetsui->copy(env);}

  693.           xywh {150 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  694.         }

  695.         Fl_Button {} {

  696.           label P

  697.           callback {presetsui->paste(env,this);}

  698.           xywh {167 5 15 15} box THIN_UP_BOX color 179 labelfont 1 labelsize 10 labelcolor 7

  699.         }

  700.       }

  701.     }

  702.   }

  703.   Function {init(EnvelopeParams *env_)} {open

  704.   } {

  705.     code {env=env_;

  706. make_ADSR_window();

  707. make_ASR_window();

  708. make_ADSRfilter_window();

  709. make_ASRbw_window();

  710. make_free_window();

  711. 

  712. make_freemode_edit_window();

  713. 

  714. envwindow=NULL;

  715. if (env->Envmode==3) envfreegroup->label("Frequency Envelope");

  716. if (env->Envmode==4) envfreegroup->label("Filter Envelope");

  717. if (env->Envmode==5) envfreegroup->label("Bandwidth Envelope");

  718. 

  719. freemodeeditwindow->label(this->label());

  720. 

  721. 

  722. freeeditsmall->setpair(freeedit);

  723. freeedit->setpair(freeeditsmall);

  724. 

  725. 

  726. refresh();} {}

  727.   }

  728.   Function {reinit()} {} {

  729.     code {if (env->Pfreemode!=0){

  730.   int answer=fl_choice("Disable the free mode of the Envelope?","No","Yes",NULL);

  731.   if (env->Pfreemode!=0) freemodebutton->value(1);

  732.           else freemodebutton->value(0);

  733.   if (answer==0) return;

  734. };

  735. 

  736. if (env->Pfreemode==0) env->Pfreemode=1;

  737.      else env->Pfreemode=0;

  738. 

  739. hide();

  740. int winx=freemodeeditwindow->x();

  741. int winy=freemodeeditwindow->y();

  742. 

  743. freemodeeditwindow->hide();

  744. 

  745. envwindow->hide();

  746. Fl_Group *par=envwindow->parent();

  747. par->hide();

  748. 

  749. 

  750. refresh();

  751. envwindow->show();

  752. par->redraw();

  753. 

  754. par->show();

  755. show();

  756. freemodeeditwindow->position(winx,winy);

  757. freemodeeditwindow->show();

  758. 

  759. if (env->Pfreemode!=0) {

  760. 	freemodebutton->value(1);

  761. 	addpoint->show();

  762. 	deletepoint->show();

  763. 	forcedreleasecheck->show();

  764. }else{

  765. 	freemodebutton->value(0);

  766. 	addpoint->hide();

  767. 	deletepoint->hide();

  768. 	forcedreleasecheck->hide();

  769. };} {}

  770.   }

  771.   Function {refresh()} {open

  772.   } {

  773.     code {freemodebutton->value(env->Pfreemode);

  774. 

  775. sustaincounter->value(env->Penvsustain);

  776. if (env->Pfreemode==0) sustaincounter->hide();

  777. 	else sustaincounter->show();

  778. sustaincounter->maximum(env->Penvpoints-2);

  779. 

  780. envstretchdial->value(env->Penvstretch);

  781. if (env->Pfreemode==0) envstretchdial->hide();

  782. 	else envstretchdial->show();

  783. 

  784. linearenvelopecheck->value(env->Plinearenvelope);

  785. if ((env->Pfreemode==0)||(env->Envmode>2)) linearenvelopecheck->hide();

  786. 	else linearenvelopecheck->show();

  787. 

  788. forcedreleasecheck->value(env->Pforcedrelease);

  789. if (env->Pfreemode==0) forcedreleasecheck->hide();

  790. 

  791. freeedit->redraw();

  792. 

  793. 

  794. if (env->Pfreemode==0){

  795.    switch(env->Envmode){

  796.          case(1):

  797.          case(2):

  798. 		e1adt->value(env->PA_dt);

  799. 		e1ddt->value(env->PD_dt);

  800. 		e1sval->value(env->PS_val);

  801. 		e1rdt->value(env->PR_dt);

  802. 		e1envstretch->value(env->Penvstretch);

  803. 		e1linearenvelope->value(env->Plinearenvelope);

  804. 		e1forcedrelease->value(env->Pforcedrelease);

  805.          break;

  806.          case(3):

  807. 		e2aval->value(env->PA_val);

  808. 		e2adt->value(env->PA_dt);

  809. 		e2rdt->value(env->PR_dt);

  810. 		e2rval->value(env->PR_val);

  811. 		e2envstretch->value(env->Penvstretch);

  812. 		e2forcedrelease->value(env->Pforcedrelease);

  813.          break; 

  814.          case(4):

  815. 		e3aval->value(env->PA_val);

  816. 		e3adt->value(env->PA_dt);

  817. 		e3dval->value(env->PD_val);

  818. 		e3ddt->value(env->PD_dt);

  819. 		e3rdt->value(env->PR_dt);

  820. 		e3rval->value(env->PR_val);

  821. 		e3envstretch->value(env->Penvstretch);

  822. 		e3forcedrelease->value(env->Pforcedrelease);

  823.          break; 

  824.          case(5):

  825. 		e4aval->value(env->PA_val);

  826. 		e4adt->value(env->PA_dt);

  827. 		e4rdt->value(env->PR_dt);

  828. 		e4rval->value(env->PR_val);

  829. 		e4envstretch->value(env->Penvstretch);

  830. 		e4forcedrelease->value(env->Pforcedrelease);

  831.          break;

  832.          default:

  833.          break; 

  834.    };

  835. }else{

  836.        envfree->redraw();

  837. };

  838. 

  839. 

  840. envADSR->hide();

  841. envASR->hide();

  842. envADSRfilter->hide();

  843. envASRbw->hide();

  844. envfree->hide();

  845. 

  846. if (env->Pfreemode==0){

  847.    switch(env->Envmode){

  848.          case(1):

  849.          case(2):

  850.            envwindow=envADSR;

  851.          break;

  852.          case(3):

  853.            envwindow=envASR;

  854.          break; 

  855.          case(4):

  856.            envwindow=envADSRfilter;

  857.          break; 

  858.          case(5):

  859.           envwindow=envASRbw;

  860.          break;

  861.          default:

  862.          break; 

  863.    };

  864. }else{

  865.    envwindow=envfree;

  866. };

  867. 

  868. envwindow->resize(this->x(),this->y(),this->w(),this->h());

  869. 

  870. envwindow->show();} {}

  871.   }

  872.   decl {EnvelopeParams *env;} {private local

  873.   }

  874.   decl {Fl_Group *envwindow;} {private local

  875.   }

  876. }