falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
2625 Commits
16 Branches
14GB
Tree: a37ff5ceff
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a37ff5ceff'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/UI/EnvelopeUI.fl

908 lines
26KB
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. ctrldown=false;} {}

  55.   }

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

  57.     code {pair=pair_;} {}

  58.   }

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

  60.   } {

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

  62. int npoints=env->Penvpoints;

  63. 

  64. float  sum=0;

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

  66. 

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

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

  69. 

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

  71.   }

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

  73.   } {

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

  75. 

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

  77.   }

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

  79.   } {

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

  81. 

  82. int nearestpoint=0;

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

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

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

  86.    if (distance<nearestval) {

  87.      nearestpoint=i;

  88.      nearestval=distance;  

  89.    };

  90. };

  91. return(nearestpoint);} {}

  92.   }

  93.   Function {draw()} {private

  94.   } {

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

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

  97. int npoints=env->Penvpoints;

  98. 

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

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

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

  102. 

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

  104. 

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

  106. 

  107. //draw the lines

  108. fl_color(FL_GRAY);

  109. 

  110. fl_line_style(FL_SOLID);

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

  112. 

  113. //draws the evelope points and lines

  114. Fl_Color alb=FL_WHITE;

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

  116. fl_color(alb);

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

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

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

  120.     oldxx=xx;oldyy=yy;

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

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

  123.         else fl_color(alb);

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

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

  126. };

  127. 

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

  129. if (lastpoint>=0){

  130.     fl_color(FL_CYAN);

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

  132. };

  133. 

  134. //draw the sustain position

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

  136.     fl_color(FL_YELLOW);

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

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

  139. };

  140. 

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

  142. fl_font(FL_HELVETICA|FL_BOLD,10);

  143. float time=0.0;

  144. if (currentpoint<=0 && (!ctrldown||lastpoint <= 0)){

  145.    fl_color(alb);

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

  147. } else {

  148.    fl_color(255,0,0);

  149.    time=env->getdt(lastpoint);

  150. };

  151. char tmpstr[20];

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

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

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

  155. if (lastpoint>=0){

  156.     snprintf((char *)&tmpstr,20,"%d", env->Penvval[lastpoint]);

  157.     fl_draw(tmpstr,ox+lx-20,oy+ly-23,20,10,FL_ALIGN_RIGHT,NULL,0);

  158. }} {}

  159.   }

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

  161.   } {

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

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

  164. 

  165. // Some window magic makes us lose focus, so reassert it.

  166. if (event==FL_ENTER)

  167.     Fl::focus(this);

  168. 

  169. if ((event==FL_KEYDOWN || event==FL_KEYUP)){

  170.    int key = Fl::event_key();

  171.    if (key==FL_Control_L || key==FL_Control_R){

  172.         ctrldown = (event==FL_KEYDOWN);

  173.         redraw();

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

  175.     }

  176. }

  177. 

  178. if (event==FL_MOUSEWHEEL && lastpoint>=0) {

  179.     if (!ctrldown) {

  180.         int ny=env->Penvval[lastpoint] - Fl::event_dy();

  181.         env->Penvval[lastpoint]=ny < 0 ? 0 : ny > 127 ? 127 : ny;

  182.     } else if (lastpoint > 0) {

  183.         int newdt = Fl::event_dy() + env->Penvdt[lastpoint];

  184.         env->Penvdt[lastpoint] = newdt < 0 ? 0 : newdt > 127 ? 127 : newdt;

  185.     }

  186.     redraw();

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

  188. }

  189. 

  190. if (event==FL_PUSH) {

  191.   currentpoint=getnearest(x_,y_);

  192.   cpx=x_;

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

  194.   lastpoint=currentpoint;

  195.   redraw();

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

  197. };

  198. 

  199. if (event==FL_RELEASE){

  200.   currentpoint=-1;

  201.   redraw();

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

  203. };

  204. 

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

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

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

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

  209. 

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

  211.   int newdt=cpdt+dx;

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

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

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

  215. 

  216.   redraw();

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

  218. };

  219. 

  220. 

  221. return(1);} {}

  222.   }

  223.   decl {Fl_Box *pair;} {}

  224.   decl {EnvelopeParams *env;} {}

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

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

  227.   decl {int lastpoint;} {public

  228.   }

  229.   decl {bool ctrldown;} {}

  230. } 

  231. 

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

  233. } {

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

  235.     code {env=NULL;

  236. freemodeeditwindow=NULL;

  237. envADSR=NULL;

  238. envASR=NULL;

  239. envADSRfilter=NULL;

  240. envASRbw=NULL;

  241. envfree=NULL;} {}

  242.   }

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

  244.     code {envwindow->hide();

  245. hide();

  246. freemodeeditwindow->hide();

  247. delete (freemodeeditwindow);} {}

  248.   }

  249.   Function {make_freemode_edit_window()} {open

  250.   } {

  251.     Fl_Window freemodeeditwindow {

  252.       label Envelope

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

  254.     } {

  255.       Fl_Box freeedit {

  256.         label Envelope

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

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

  259.         class EnvelopeFreeEdit

  260.       }

  261.       Fl_Button addpoint {

  262.         label {Add point}

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

  264. if (curpoint<0) return;

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

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

  267. 

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

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

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

  271. };

  272. 

  273. if (curpoint==0) {

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

  275. };

  276. 

  277. env->Penvpoints++;

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

  279. 

  280. freeedit->lastpoint+=1;

  281. freeedit->redraw();

  282. envfree->redraw();

  283. 

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

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

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

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

  288.       }

  289.       Fl_Button deletepoint {

  290.         label {Delete point}

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

  292. if (curpoint<1) return;

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

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

  295. 

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

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

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

  299. };

  300. 

  301. env->Penvpoints--;

  302. 

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

  304. 

  305. 

  306. freeedit->lastpoint-=1;

  307. freeedit->redraw();

  308. envfree->redraw();

  309. 

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

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

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

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

  314.       }

  315.       Fl_Check_Button freemodebutton {

  316.         label FreeMode

  317.         callback {reinit();

  318. 

  319. freeedit->lastpoint=-1;

  320. freeedit->redraw();}

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

  322.       }

  323.       Fl_Check_Button forcedreleasecheck {

  324.         label frcR

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

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

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

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

  329.       }

  330.       Fl_Dial envstretchdial {

  331.         label {Str.}

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

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

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

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

  336.         class WidgetPDial

  337.       }

  338.       Fl_Button {} {

  339.         label Close

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

  341.         xywh {510 155 60 20} box THIN_UP_BOX

  342.       }

  343.       Fl_Check_Button linearenvelopecheck {

  344.         label L

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

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

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

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

  349.       }

  350.       Fl_Counter sustaincounter {

  351.         label Sust

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

  353. freeedit->redraw();

  354. envfree->redraw();}

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

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

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

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

  359.       }

  360.       Fl_Button {} {

  361.         label C

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

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

  364.       }

  365.       Fl_Button {} {

  366.         label P

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

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

  369.       }

  370.     }

  371.   }

  372.   Function {make_ADSR_window()} {open

  373.   } {

  374.     Fl_Window envADSR {open

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

  376.       class Fl_Group visible

  377.     } {

  378.       Fl_Group {} {

  379.         label {Amplitude Envelope}

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

  381.         code0 {set_module_parameters(o);}

  382.       } {

  383.         Fl_Dial e1adt {

  384.           label {A.dt}

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

  386. freeedit->redraw();}

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

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

  389.           class WidgetPDial

  390.         }

  391.         Fl_Dial e1ddt {

  392.           label {D.dt}

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

  394. freeedit->redraw();}

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

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

  397.           class WidgetPDial

  398.         }

  399.         Fl_Dial e1rdt {

  400.           label {R.dt}

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

  402. freeedit->redraw();}

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

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

  405.           class WidgetPDial

  406.         }

  407.         Fl_Dial e1sval {

  408.           label {S.val}

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

  410. freeedit->redraw();}

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

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

  413.           class WidgetPDial

  414.         }

  415.         Fl_Check_Button e1forcedrelease {

  416.           label frcR

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

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

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

  420.         }

  421.         Fl_Dial e1envstretch {

  422.           label Stretch

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

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

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

  426.           class WidgetPDial

  427.         }

  428.         Fl_Button {} {

  429.           label E

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

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

  432.         }

  433.         Fl_Check_Button e1linearenvelope {

  434.           label L

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

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

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

  438.         }

  439.         Fl_Button {} {

  440.           label C

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

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

  443.         }

  444.         Fl_Button {} {

  445.           label P

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

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

  448.         }

  449.       }

  450.     }

  451.   }

  452.   Function {make_ASR_window()} {open

  453.   } {

  454.     Fl_Window envASR {open

  455.       xywh {648 667 210 70} type Double

  456.       class Fl_Group visible

  457.     } {

  458.       Fl_Group {} {

  459.         label {Frequency Envelope}

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

  461.         code0 {set_module_parameters(o);}

  462.       } {

  463.         Fl_Dial e2aval {

  464.           label {A.val}

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

  466. freeedit->redraw();}

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

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

  469.           class WidgetPDial

  470.         }

  471.         Fl_Dial e2adt {

  472.           label {A.dt}

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

  474. freeedit->redraw();}

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

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

  477.           class WidgetPDial

  478.         }

  479.         Fl_Dial e2rval {

  480.           label {R.val}

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

  482. freeedit->redraw();}

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

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

  485.           class WidgetPDial

  486.         }

  487.         Fl_Dial e2rdt {

  488.           label {R.dt}

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

  490. freeedit->redraw();}

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

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

  493.           class WidgetPDial

  494.         }

  495.         Fl_Dial e2envstretch {

  496.           label Stretch

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

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

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

  500.           class WidgetPDial

  501.         }

  502.         Fl_Check_Button e2forcedrelease {

  503.           label frcR

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

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

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

  507.         }

  508.         Fl_Button {} {

  509.           label C

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

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

  512.         }

  513.         Fl_Button {} {

  514.           label P

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

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

  517.         }

  518.       }

  519.       Fl_Button {} {

  520.         label E

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

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

  523.       }

  524.     }

  525.   }

  526.   Function {make_ADSRfilter_window()} {open

  527.   } {

  528.     Fl_Window envADSRfilter {open selected

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

  530.       class Fl_Group visible

  531.     } {

  532.       Fl_Group {} {

  533.         label {Filter Envelope}

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

  535.         code0 {set_module_parameters(o);}

  536.       } {

  537.         Fl_Dial e3aval {

  538.           label {A.val}

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

  540. freeedit->redraw();}

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

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

  543.           class WidgetPDial

  544.         }

  545.         Fl_Dial e3adt {

  546.           label {A.dt}

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

  548. freeedit->redraw();}

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

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

  551.           class WidgetPDial

  552.         }

  553.         Fl_Dial e3dval {

  554.           label {D.val}

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

  556. freeedit->redraw();}

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

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

  559.           class WidgetPDial

  560.         }

  561.         Fl_Dial e3ddt {

  562.           label {D.dt}

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

  564. freeedit->redraw();}

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

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

  567.           class WidgetPDial

  568.         }

  569.         Fl_Dial e3rdt {

  570.           label {R.dt}

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

  572. freeedit->redraw();}

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

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

  575.           class WidgetPDial

  576.         }

  577.         Fl_Dial e3rval {

  578.           label {R.val}

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

  580. freeedit->redraw();}

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

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

  583.           class WidgetPDial

  584.         }

  585.         Fl_Dial e3envstretch {

  586.           label Stretch

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

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

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

  590.           class WidgetPDial

  591.         }

  592.         Fl_Check_Button e3forcedrelease {

  593.           label frcR

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

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

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

  597.         }

  598.         Fl_Button {} {

  599.           label E

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

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

  602.         }

  603.         Fl_Button {} {

  604.           label C

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

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

  607.         }

  608.         Fl_Button {} {

  609.           label P

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

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

  612.         }

  613.       }

  614.     }

  615.   }

  616.   Function {make_ASRbw_window()} {open

  617.   } {

  618.     Fl_Window envASRbw {open

  619.       xywh {362 642 210 70} type Double

  620.       code0 {set_module_parameters(o);}

  621.       class Fl_Group visible

  622.     } {

  623.       Fl_Group {} {

  624.         label {BandWidth Envelope}

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

  626.         code0 {set_module_parameters(o);}

  627.       } {

  628.         Fl_Dial e4aval {

  629.           label {A.val}

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

  631. freeedit->redraw();}

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

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

  634.           class WidgetPDial

  635.         }

  636.         Fl_Dial e4adt {

  637.           label {A.dt}

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

  639. freeedit->redraw();}

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

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

  642.           class WidgetPDial

  643.         }

  644.         Fl_Dial e4rval {

  645.           label {R.val}

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

  647. freeedit->redraw();}

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

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

  650.           class WidgetPDial

  651.         }

  652.         Fl_Dial e4rdt {

  653.           label {R.dt}

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

  655. freeedit->redraw();}

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

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

  658.           class WidgetPDial

  659.         }

  660.         Fl_Dial e4envstretch {

  661.           label Stretch

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

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

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

  665.           class WidgetPDial

  666.         }

  667.         Fl_Check_Button e4forcedrelease {

  668.           label frcR

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

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

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

  672.         }

  673.         Fl_Button {} {

  674.           label C

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

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

  677.         }

  678.         Fl_Button {} {

  679.           label P

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

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

  682.         }

  683.       }

  684.       Fl_Button {} {

  685.         label E

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

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

  688.       }

  689.     }

  690.   }

  691.   Function {make_free_window()} {open

  692.   } {

  693.     Fl_Window envfree {open

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

  695.       code0 {set_module_parameters(o);}

  696.       class Fl_Group visible

  697.     } {

  698.       Fl_Group envfreegroup {

  699.         label {Amplitude Envelope}

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

  701.         code0 {set_module_parameters(o);}

  702.       } {

  703.         Fl_Box freeeditsmall {

  704.           label Envelope

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

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

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

  708.           class EnvelopeFreeEdit

  709.         }

  710.         Fl_Button {} {

  711.           label E

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

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

  714.         }

  715.         Fl_Button {} {

  716.           label C

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

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

  719.         }

  720.         Fl_Button {} {

  721.           label P

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

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

  724.         }

  725.       }

  726.     }

  727.   }

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

  729.   } {

  730.     code {env=env_;

  731. make_ADSR_window();

  732. make_ASR_window();

  733. make_ADSRfilter_window();

  734. make_ASRbw_window();

  735. make_free_window();

  736. 

  737. make_freemode_edit_window();

  738. 

  739. envwindow=NULL;

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

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

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

  743. 

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

  745. 

  746. 

  747. freeeditsmall->setpair(freeedit);

  748. freeedit->setpair(freeeditsmall);

  749. 

  750. 

  751. refresh();} {}

  752.   }

  753.   Function {reinit()} {} {

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

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

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

  757.           else freemodebutton->value(0);

  758.   if (answer==0) return;

  759. };

  760. 

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

  762.      else env->Pfreemode=0;

  763. 

  764. hide();

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

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

  767. 

  768. freemodeeditwindow->hide();

  769. 

  770. envwindow->hide();

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

  772. par->hide();

  773. 

  774. 

  775. refresh();

  776. envwindow->show();

  777. par->redraw();

  778. 

  779. par->show();

  780. show();

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

  782. freemodeeditwindow->show();

  783. 

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

  785. 	freemodebutton->value(1);

  786. 	addpoint->show();

  787. 	deletepoint->show();

  788. 	forcedreleasecheck->show();

  789. }else{

  790. 	freemodebutton->value(0);

  791. 	addpoint->hide();

  792. 	deletepoint->hide();

  793. 	forcedreleasecheck->hide();

  794. };} {}

  795.   }

  796.   Function {refresh()} {open

  797.   } {

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

  799. 

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

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

  802. 	else sustaincounter->show();

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

  804. 

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

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

  807. 	else envstretchdial->show();

  808. 

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

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

  811. 	else linearenvelopecheck->show();

  812. 

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

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

  815. 	else forcedreleasecheck->show();

  816. 

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

  818. 	addpoint->hide();

  819. 	deletepoint->hide();

  820. } else {

  821. 	addpoint->show();

  822. 	deletepoint->show();

  823. }

  824. 

  825. freeedit->redraw();

  826. 

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

  828.    switch(env->Envmode){

  829.          case(1):

  830.          case(2):

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

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

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

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

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

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

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

  838.          break;

  839.          case(3):

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

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

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

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

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

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

  846.          break; 

  847.          case(4):

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

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

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

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

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

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

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

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

  856.          break; 

  857.          case(5):

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

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

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

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

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

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

  864.          break;

  865.          default:

  866.          break; 

  867.    };

  868. }else{

  869.        envfree->redraw();

  870. };

  871. 

  872. 

  873. envADSR->hide();

  874. envASR->hide();

  875. envADSRfilter->hide();

  876. envASRbw->hide();

  877. envfree->hide();

  878. 

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

  880.    switch(env->Envmode){

  881.          case(1):

  882.          case(2):

  883.            envwindow=envADSR;

  884.          break;

  885.          case(3):

  886.            envwindow=envASR;

  887.          break; 

  888.          case(4):

  889.            envwindow=envADSRfilter;

  890.          break; 

  891.          case(5):

  892.           envwindow=envASRbw;

  893.          break;

  894.          default:

  895.          break; 

  896.    };

  897. }else{

  898.    envwindow=envfree;

  899. };

  900. 

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

  902. 

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

  904.   }

  905.   decl {EnvelopeParams *env;} {}

  906.   decl {Fl_Group *envwindow;} {}

  907. }