falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
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.
1395 Commits
17 Branches
341MB
Tree: bd92aa6d2c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bd92aa6d2c'
${ noResults }
Carla/source/modules/native-plugins/ZynAddSubFX/UI/EnvelopeUI.fl

869 lines
25KB
Raw Blame History 

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

  2. version 1.0110 

  3. header_name {.h} 

  4. code_name {.cc}

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

  6. 

  7. decl {//License: GNU GPL version 2 or later} {} 

  8. 

  9. decl {\#include "WidgetPDial.h"} {public

  10. } 

  11. 

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

  13. } 

  14. 

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

  16. } 

  17. 

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

  19. } 

  20. 

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

  22. } 

  23. 

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

  25. } 

  26. 

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

  28. } 

  29. 

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

  31. } 

  32. 

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

  34. } 

  35. 

  36. decl {\#include "PresetsUI.h"} {public

  37. } 

  38. 

  39. decl {\#include "common.H"} {public

  40. } 

  41. 

  42. class EnvelopeFreeEdit {: {public Fl_Box}

  43. } {

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

  45.     code {env=NULL;

  46. pair=NULL;} {}

  47.   }

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

  49.     code {env=env_;

  50. oldx=-1;

  51. currentpoint=-1;

  52. cpx=0;

  53. lastpoint=-1;} {}

  54.   }

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

  56.     code {pair=pair_;} {}

  57.   }

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

  59.   } {

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

  61. int npoints=env->Penvpoints;

  62. 

  63. float  sum=0;

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

  65. 

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

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

  68. 

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

  70.   }

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

  72.   } {

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

  74. 

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

  76.   }

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

  78.   } {

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

  80. 

  81. int nearestpoint=0;

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

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

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

  85.    if (distance<nearestval) {

  86.      nearestpoint=i;

  87.      nearestval=distance;  

  88.    };

  89. };

  90. return(nearestpoint);} {}

  91.   }

  92.   Function {draw()} {private

  93.   } {

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

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

  96. int npoints=env->Penvpoints;

  97. 

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

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

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

  101. 

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

  103. 

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

  105. 

  106. //draw the lines

  107. fl_color(FL_GRAY);

  108. 

  109. fl_line_style(FL_SOLID);

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

  111. 

  112. //draws the evelope points and lines

  113. Fl_Color alb=FL_WHITE;

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

  115. fl_color(alb);

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

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

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

  119.     oldxx=xx;oldyy=yy;

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

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

  122.         else fl_color(alb);

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

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

  125. };

  126. 

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

  128. if (lastpoint>=0){

  129.     fl_color(FL_CYAN);

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

  131. };

  132. 

  133. //draw the sustain position

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

  135.     fl_color(FL_YELLOW);

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

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

  138. };

  139. 

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

  141. fl_font(FL_HELVETICA|FL_BOLD,10);

  142. float time=0.0;

  143. if (currentpoint<=0){

  144.    fl_color(alb);

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

  146. } else {

  147.    fl_color(255,0,0);

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

  149. };

  150. char tmpstr[20];

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

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

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

  154.   }

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

  156.   } {

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

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

  159. 

  160. if (event==FL_PUSH) {

  161.   currentpoint=getnearest(x_,y_);

  162.   cpx=x_;

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

  164.   lastpoint=currentpoint;

  165.   redraw();

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

  167. };

  168. 

  169. if (event==FL_RELEASE){

  170.   currentpoint=-1;

  171.   redraw();

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

  173. };

  174. 

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

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

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

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

  179. 

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

  181.   int newdt=cpdt+dx;

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

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

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

  185. 

  186.   redraw();

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

  188. };

  189. 

  190. 

  191. return(1);} {}

  192.   }

  193.   decl {Fl_Box *pair;} {}

  194.   decl {EnvelopeParams *env;} {}

  195.   decl {int oldx,oldy;} {}

  196.   decl {int currentpoint,cpx,cpdt;} {}

  197.   decl {int lastpoint;} {public

  198.   }

  199. } 

  200. 

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

  202. } {

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

  204.     code {env=NULL;

  205. freemodeeditwindow=NULL;

  206. envADSR=NULL;

  207. envASR=NULL;

  208. envADSRfilter=NULL;

  209. envASRbw=NULL;

  210. envfree=NULL;} {}

  211.   }

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

  213.     code {envwindow->hide();

  214. hide();

  215. freemodeeditwindow->hide();

  216. delete (freemodeeditwindow);} {}

  217.   }

  218.   Function {make_freemode_edit_window()} {open

  219.   } {

  220.     Fl_Window freemodeeditwindow {

  221.       label Envelope

  222.       xywh {702 269 575 180} type Double visible

  223.     } {

  224.       Fl_Box freeedit {

  225.         label Envelope

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

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

  228.         class EnvelopeFreeEdit

  229.       }

  230.       Fl_Button addpoint {

  231.         label {Add point}

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

  233. if (curpoint<0) return;

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

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

  236. 

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

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

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

  240. };

  241. 

  242. if (curpoint==0) {

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

  244. };

  245. 

  246. env->Penvpoints++;

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

  248. 

  249. freeedit->lastpoint+=1;

  250. freeedit->redraw();

  251. envfree->redraw();

  252. 

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

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

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

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

  257.       }

  258.       Fl_Button deletepoint {

  259.         label {Delete point}

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

  261. if (curpoint<1) return;

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

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

  264. 

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

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

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

  268. };

  269. 

  270. env->Penvpoints--;

  271. 

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

  273. 

  274. 

  275. freeedit->lastpoint-=1;

  276. freeedit->redraw();

  277. envfree->redraw();

  278. 

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

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

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

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

  283.       }

  284.       Fl_Light_Button freemodebutton {

  285.         label FreeMode

  286.         callback {reinit();

  287. 

  288. freeedit->lastpoint=-1;

  289. freeedit->redraw();}

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

  291.       }

  292.       Fl_Check_Button forcedreleasecheck {

  293.         label frcR

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

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

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

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

  298.       }

  299.       Fl_Dial envstretchdial {

  300.         label {Str.}

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

  302.         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

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

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

  305.         class WidgetPDial

  306.       }

  307.       Fl_Button {} {

  308.         label Close

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

  310.         xywh {510 155 60 20} box THIN_UP_BOX

  311.       }

  312.       Fl_Check_Button linearenvelopecheck {

  313.         label L

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

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

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

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

  318.       }

  319.       Fl_Counter sustaincounter {

  320.         label Sust

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

  322. freeedit->redraw();

  323. envfree->redraw();}

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

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

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

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

  328.       }

  329.       Fl_Button {} {

  330.         label C

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

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

  333.       }

  334.       Fl_Button {} {

  335.         label P

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

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

  338.       }

  339.     }

  340.   }

  341.   Function {make_ADSR_window()} {open

  342.   } {

  343.     Fl_Window envADSR {open

  344.       xywh {344 788 205 70} type Double color 50 labelfont 1

  345.       class Fl_Group visible

  346.     } {

  347.       Fl_Group {} {

  348.         label {Amplitude Envelope}

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

  350.         code0 {set_module_parameters(o);}

  351.       } {

  352.         Fl_Dial e1adt {

  353.           label {A.dt}

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

  355. freeedit->redraw();}

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

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

  358.           class WidgetPDial

  359.         }

  360.         Fl_Dial e1ddt {

  361.           label {D.dt}

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

  363. freeedit->redraw();}

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

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

  366.           class WidgetPDial

  367.         }

  368.         Fl_Dial e1rdt {

  369.           label {R.dt}

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

  371. freeedit->redraw();}

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

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

  374.           class WidgetPDial

  375.         }

  376.         Fl_Dial e1sval {

  377.           label {S.val}

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

  379. freeedit->redraw();}

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

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

  382.           class WidgetPDial

  383.         }

  384.         Fl_Check_Button e1forcedrelease {

  385.           label frcR

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

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

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

  389.         }

  390.         Fl_Dial e1envstretch {

  391.           label Stretch

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

  393.           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

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

  395.           class WidgetPDial

  396.         }

  397.         Fl_Button {} {

  398.           label E

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

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

  401.         }

  402.         Fl_Check_Button e1linearenvelope {

  403.           label L

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

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

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

  407.         }

  408.         Fl_Button {} {

  409.           label C

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

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

  412.         }

  413.         Fl_Button {} {

  414.           label P

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

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

  417.         }

  418.       }

  419.     }

  420.   }

  421.   Function {make_ASR_window()} {open

  422.   } {

  423.     Fl_Window envASR {open

  424.       xywh {648 667 210 70} type Double

  425.       class Fl_Group visible

  426.     } {

  427.       Fl_Group {} {

  428.         label {Frequency Envelope}

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

  430.         code0 {set_module_parameters(o);}

  431.       } {

  432.         Fl_Dial e2aval {

  433.           label {A.val}

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

  435. freeedit->redraw();}

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

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

  438.           class WidgetPDial

  439.         }

  440.         Fl_Dial e2adt {

  441.           label {A.dt}

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

  443. freeedit->redraw();}

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

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

  446.           class WidgetPDial

  447.         }

  448.         Fl_Dial e2rval {

  449.           label {R.val}

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

  451. freeedit->redraw();}

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

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

  454.           class WidgetPDial

  455.         }

  456.         Fl_Dial e2rdt {

  457.           label {R.dt}

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

  459. freeedit->redraw();}

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

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

  462.           class WidgetPDial

  463.         }

  464.         Fl_Dial e2envstretch {

  465.           label Stretch

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

  467.           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

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

  469.           class WidgetPDial

  470.         }

  471.         Fl_Check_Button e2forcedrelease {

  472.           label frcR

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

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

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

  476.         }

  477.         Fl_Button {} {

  478.           label C

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

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

  481.         }

  482.         Fl_Button {} {

  483.           label P

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

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

  486.         }

  487.       }

  488.       Fl_Button {} {

  489.         label E

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

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

  492.       }

  493.     }

  494.   }

  495.   Function {make_ADSRfilter_window()} {open

  496.   } {

  497.     Fl_Window envADSRfilter {open selected

  498.       xywh {627 569 275 70} type Double color 50 labelfont 1

  499.       class Fl_Group visible

  500.     } {

  501.       Fl_Group {} {

  502.         label {Filter Envelope}

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

  504.         code0 {set_module_parameters(o);}

  505.       } {

  506.         Fl_Dial e3aval {

  507.           label {A.val}

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

  509. freeedit->redraw();}

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

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

  512.           class WidgetPDial

  513.         }

  514.         Fl_Dial e3adt {

  515.           label {A.dt}

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

  517. freeedit->redraw();}

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

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

  520.           class WidgetPDial

  521.         }

  522.         Fl_Dial e3dval {

  523.           label {D.val}

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

  525. freeedit->redraw();}

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

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

  528.           class WidgetPDial

  529.         }

  530.         Fl_Dial e3ddt {

  531.           label {D.dt}

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

  533. freeedit->redraw();}

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

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

  536.           class WidgetPDial

  537.         }

  538.         Fl_Dial e3rdt {

  539.           label {R.dt}

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

  541. freeedit->redraw();}

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

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

  544.           class WidgetPDial

  545.         }

  546.         Fl_Dial e3rval {

  547.           label {R.val}

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

  549. freeedit->redraw();}

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

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

  552.           class WidgetPDial

  553.         }

  554.         Fl_Dial e3envstretch {

  555.           label Stretch

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

  557.           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

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

  559.           class WidgetPDial

  560.         }

  561.         Fl_Check_Button e3forcedrelease {

  562.           label frcR

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

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

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

  566.         }

  567.         Fl_Button {} {

  568.           label E

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

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

  571.         }

  572.         Fl_Button {} {

  573.           label C

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

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

  576.         }

  577.         Fl_Button {} {

  578.           label P

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

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

  581.         }

  582.       }

  583.     }

  584.   }

  585.   Function {make_ASRbw_window()} {open

  586.   } {

  587.     Fl_Window envASRbw {open

  588.       xywh {362 642 210 70} type Double

  589.       code0 {set_module_parameters(o);}

  590.       class Fl_Group visible

  591.     } {

  592.       Fl_Group {} {

  593.         label {BandWidth Envelope}

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

  595.         code0 {set_module_parameters(o);}

  596.       } {

  597.         Fl_Dial e4aval {

  598.           label {A.val}

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

  600. freeedit->redraw();}

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

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

  603.           class WidgetPDial

  604.         }

  605.         Fl_Dial e4adt {

  606.           label {A.dt}

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

  608. freeedit->redraw();}

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

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

  611.           class WidgetPDial

  612.         }

  613.         Fl_Dial e4rval {

  614.           label {R.val}

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

  616. freeedit->redraw();}

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

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

  619.           class WidgetPDial

  620.         }

  621.         Fl_Dial e4rdt {

  622.           label {R.dt}

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

  624. freeedit->redraw();}

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

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

  627.           class WidgetPDial

  628.         }

  629.         Fl_Dial e4envstretch {

  630.           label Stretch

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

  632.           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

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

  634.           class WidgetPDial

  635.         }

  636.         Fl_Check_Button e4forcedrelease {

  637.           label frcR

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

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

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

  641.         }

  642.         Fl_Button {} {

  643.           label C

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

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

  646.         }

  647.         Fl_Button {} {

  648.           label P

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

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

  651.         }

  652.       }

  653.       Fl_Button {} {

  654.         label E

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

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

  657.       }

  658.     }

  659.   }

  660.   Function {make_free_window()} {open

  661.   } {

  662.     Fl_Window envfree {open

  663.       xywh {376 436 205 70} type Double color 50 labelfont 1 resizable

  664.       code0 {set_module_parameters(o);}

  665.       class Fl_Group visible

  666.     } {

  667.       Fl_Group envfreegroup {

  668.         label {Amplitude Envelope}

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

  670.         code0 {set_module_parameters(o);}

  671.       } {

  672.         Fl_Box freeeditsmall {

  673.           label Envelope

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

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

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

  677.           class EnvelopeFreeEdit

  678.         }

  679.         Fl_Button {} {

  680.           label E

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

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

  683.         }

  684.         Fl_Button {} {

  685.           label C

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

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

  688.         }

  689.         Fl_Button {} {

  690.           label P

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

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

  693.         }

  694.       }

  695.     }

  696.   }

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

  698.   } {

  699.     code {env=env_;

  700. make_ADSR_window();

  701. make_ASR_window();

  702. make_ADSRfilter_window();

  703. make_ASRbw_window();

  704. make_free_window();

  705. 

  706. make_freemode_edit_window();

  707. 

  708. envwindow=NULL;

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

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

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

  712. 

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

  714. 

  715. 

  716. freeeditsmall->setpair(freeedit);

  717. freeedit->setpair(freeeditsmall);

  718. 

  719. 

  720. refresh();} {}

  721.   }

  722.   Function {reinit()} {} {

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

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

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

  726.           else freemodebutton->value(0);

  727.   if (answer==0) return;

  728. };

  729. 

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

  731.      else env->Pfreemode=0;

  732. 

  733. hide();

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

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

  736. 

  737. freemodeeditwindow->hide();

  738. 

  739. envwindow->hide();

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

  741. par->hide();

  742. 

  743. 

  744. refresh();

  745. envwindow->show();

  746. par->redraw();

  747. 

  748. par->show();

  749. show();

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

  751. freemodeeditwindow->show();

  752. 

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

  754. 	freemodebutton->value(1);

  755. 	addpoint->show();

  756. 	deletepoint->show();

  757. 	forcedreleasecheck->show();

  758. }else{

  759. 	freemodebutton->value(0);

  760. 	addpoint->hide();

  761. 	deletepoint->hide();

  762. 	forcedreleasecheck->hide();

  763. };} {}

  764.   }

  765.   Function {refresh()} {open

  766.   } {

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

  768. 

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

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

  771. 	else sustaincounter->show();

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

  773. 

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

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

  776. 	else envstretchdial->show();

  777. 

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

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

  780. 	else linearenvelopecheck->show();

  781. 

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

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

  784. 

  785. freeedit->redraw();

  786. 

  787. 

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

  789.    switch(env->Envmode){

  790.          case(1):

  791.          case(2):

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

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

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

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

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

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

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

  799.          break;

  800.          case(3):

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

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

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

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

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

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

  807.          break; 

  808.          case(4):

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

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

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

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

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

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

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

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

  817.          break; 

  818.          case(5):

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

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

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

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

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

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

  825.          break;

  826.          default:

  827.          break; 

  828.    };

  829. }else{

  830.        envfree->redraw();

  831. };

  832. 

  833. 

  834. envADSR->hide();

  835. envASR->hide();

  836. envADSRfilter->hide();

  837. envASRbw->hide();

  838. envfree->hide();

  839. 

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

  841.    switch(env->Envmode){

  842.          case(1):

  843.          case(2):

  844.            envwindow=envADSR;

  845.          break;

  846.          case(3):

  847.            envwindow=envASR;

  848.          break; 

  849.          case(4):

  850.            envwindow=envADSRfilter;

  851.          break; 

  852.          case(5):

  853.           envwindow=envASRbw;

  854.          break;

  855.          default:

  856.          break; 

  857.    };

  858. }else{

  859.    envwindow=envfree;

  860. };

  861. 

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

  863. 

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

  865.   }

  866.   decl {EnvelopeParams *env;} {}

  867.   decl {Fl_Group *envwindow;} {}

  868. }